From 53bb9859272417e818d43b0cdbb2a12c08fb16e6 Mon Sep 17 00:00:00 2001
From: JavaEdge <sss2855845850@gmail.com>
Date: Sun, 15 Dec 2024 23:08:43 +0800
Subject: [PATCH 01/20] docs:update special

---
 .vscode/.server-controller-port.log           |   2 +-
 docs/.vuepress/config.js                      |  93 ++--
 .../AI/llm/goodbye-cursor-hello-windsurf.md   | 148 ++++++
 ...m-deployment-tips-tricks-and-techniques.md | 149 ++++++
 docs/md/AI/llm/only-ai-flow-can-do.md         | 340 ++++++++++++++
 docs/md/AI/llm/qwen-QwQ.md                    | 237 ++++++++++
 ...or-growing-and-protecting-the-data-tier.md | 256 +++++++++++
 ...service-level-prioritized-load-shedding.md | 230 ++++++++++
 ...10\345\277\205\347\234\213\357\274\201.md" | 125 +++++
 .../career/mastering-architecture-diagrams.md | 139 ++++++
 docs/md/design/measuring-technical-debt.md    |  92 ++++
 ...244\215&\345\244\247\351\207\217ifelse.md" | 428 ++++++++++++++++++
 ...01\345\245\245\344\271\211\357\274\201.md" | 218 +++++++++
 .../docker-install-configure-seata-server.md  | 218 +++++++++
 docs/md/serverless/serverless-is-a-scam.md    |  79 ++++
 docs/md/spring/SpringBoot3.4-release.md       | 391 ++++++++++++++++
 16 files changed, 3103 insertions(+), 42 deletions(-)
 create mode 100644 docs/md/AI/llm/goodbye-cursor-hello-windsurf.md
 create mode 100644 docs/md/AI/llm/navigating-llm-deployment-tips-tricks-and-techniques.md
 create mode 100644 docs/md/AI/llm/only-ai-flow-can-do.md
 create mode 100644 docs/md/AI/llm/qwen-QwQ.md
 create mode 100644 docs/md/biz-arch/data-gateway-a-platform-for-growing-and-protecting-the-data-tier.md
 create mode 100644 docs/md/biz-arch/enhancing-netflix-reliability-with-service-level-prioritized-load-shedding.md
 create mode 100644 "docs/md/biz-arch/\351\253\230\346\200\247\350\203\275\346\216\222\345\220\215\347\263\273\347\273\237\347\232\204\346\240\270\345\277\203\346\236\266\346\236\204\345\216\237\347\220\206\357\274\214\346\236\266\346\236\204\345\270\210\345\277\205\347\234\213\357\274\201.md"
 create mode 100644 docs/md/career/mastering-architecture-diagrams.md
 create mode 100644 docs/md/design/measuring-technical-debt.md
 create mode 100644 "docs/md/design/\346\236\266\346\236\204\345\270\210\346\225\231\344\275\240kill\347\245\226\344\274\240\347\237\263\345\261\261\344\273\243\347\240\201\351\207\215\345\244\215&\345\244\247\351\207\217ifelse.md"
 create mode 100644 "docs/md/distdb/03-BASE \350\277\230\350\203\275\346\222\221\345\244\232\344\271\205\357\274\237\345\274\272\344\270\200\350\207\264\346\200\247\346\211\215\346\230\257\344\272\213\345\212\241\345\244\204\347\220\206\347\232\204\347\273\210\346\236\201\345\245\245\344\271\211\357\274\201.md"
 create mode 100644 docs/md/seata/docker-install-configure-seata-server.md
 create mode 100644 docs/md/serverless/serverless-is-a-scam.md
 create mode 100644 docs/md/spring/SpringBoot3.4-release.md

diff --git a/.vscode/.server-controller-port.log b/.vscode/.server-controller-port.log
index b31d9d137..d338b7efa 100644
--- a/.vscode/.server-controller-port.log
+++ b/.vscode/.server-controller-port.log
@@ -1,5 +1,5 @@
 {
   "port": 9145,
-  "time": 1731744690501,
+  "time": 1734190844439,
   "version": "0.0.3"
 }
\ No newline at end of file
diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index f47ab0963..e2b71bf23 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -321,19 +321,6 @@ module.exports = {
                                         text: '消息队列基础',
                                         link: '/md/RocketMQ/消息队列面试必问解析.md'
                                     },
-                                    {
-                                        text: 'RocketMQ基础',
-                                        link: '/md/RocketMQ/01-RocketMQ核心内容.md'
-                                    },
-                                    {
-                                        text: 'RocketMQ存储设计',
-                                        link: '/md/RocketMQ/核心概念.md'
-                                    },
-
-                                    {
-                                        text: 'RocketMQ业务实战',
-                                        link: '/md/RocketMQ/02-基于电商场景的高并发RocketMQ实战.md'
-                                    },
                                 ]
                             },
 
@@ -362,18 +349,18 @@ module.exports = {
                             },
 
                             {
-                                text: '常见攻击手段',
+                                text: 'OAuth2.0',
                                 items: [{
-                                    text: '常见攻击手段概述',
+                                    text: 'OAuth2.0专栏概述',
                                     link: '/md/security/01-OAuth 2.0实战-为什么要先获取授权码code.md'
                                 }, ]
                             },
 
                             {
-                                text: 'OAuth2.0',
+                                text: 'Arthas',
                                 items: [{
-                                    text: 'OAuth2.0专栏概述',
-                                    link: '/md/security/01-OAuth 2.0实战-为什么要先获取授权码code.md'
+                                    text: 'Arthas使用',
+                                    link: '/md/arthas/Arthas使用.md'
                                 }, ]
                             },
                         ]
@@ -445,16 +432,6 @@ module.exports = {
                                 }, ]
                             },
 
-
-                            {
-                                text: 'Arthas',
-                                items: [{
-                                    text: 'Arthas使用',
-                                    link: '/md/arthas/Arthas使用.md'
-                                }, ]
-                            },
-
-
                             {
                                 text: 'Dubbo',
                                 items: [{
@@ -508,14 +485,6 @@ module.exports = {
                                         text: '基础',
                                         link: '/md/redis/00-数据结构的最佳实践.md'
                                     },
-                                    {
-                                        text: '源码',
-                                        link: '/md/redis/00-数据结构的最佳实践.md'
-                                    },
-                                    {
-                                        text: '业务',
-                                        link: '/md/redis/00-数据结构的最佳实践.md'
-                                    },
                                 ]
                             },
 
@@ -570,10 +539,6 @@ module.exports = {
                                         text: '00-互联网大厂的大数据平台架构',
                                         link: '/md/bigdata/大数据平台架构.md'
                                     },
-                                    {
-                                        text: '01-对象存储',
-                                        link: '/md/bigdata/对象存储.md'
-                                    },
                                 ]
                             },
 
@@ -668,6 +633,14 @@ module.exports = {
                                     link: '/md/k8s/00-Kubernetes的基本架构.md'
                                 }]
                             },
+                            
+                            {
+                                text: 'ServerLess',
+                                items: [{
+                                    text: 'serverless-is-a-scam',
+                                    link: '/md/serverless/serverless-is-a-scam.md'
+                                }]
+                            },
 
                             {
                                 text: '监控',
@@ -741,7 +714,15 @@ module.exports = {
                                     text: '00-阿里秋招高频算法题汇总-基础篇',
                                     link: '/md/algorithm/leetcode/00-阿里秋招高频算法题汇总-基础篇.md'
                                 }, ]
-                            }
+                            },
+
+                            {
+                                text: '常见攻击手段',
+                                items: [{
+                                    text: '常见攻击手段概述',
+                                    link: '/md/security/01-OAuth 2.0实战-为什么要先获取授权码code.md'
+                                }, ]
+                            },
                         ]
                     },
                     {
@@ -949,6 +930,7 @@ module.exports = {
                                 "08-视频推荐索引构建",
                                 "小游戏的大促实践",
                                 "事件中心架构概述",
+                                "高性能排名系统的核心架构原理，架构师必看！",
                             ]
                         },
                         {
@@ -962,6 +944,8 @@ module.exports = {
                                 "短链系统设计（design tiny url）",
                                 "打造一个高并发的十万用户 IM 聊天系统，你需要了解这些架构设计技巧！",
                                 "netflixs-distributed-counter-abstraction",
+                                "data-gateway-a-platform-for-growing-and-protecting-the-data-tier",
+                                "enhancing-netflix-reliability-with-service-level-prioritized-load-shedding",
                             ]
                         },
 
@@ -1373,6 +1357,15 @@ module.exports = {
                                 "SpringBoot默认线程池",
                             ]
                         },
+                        
+                        {
+                            title: "SpringBoot新特性",
+                            collapsable: false,
+                            sidebarDepth: 0,
+                            children: [
+                                "SpringBoot3.4-release",
+                            ]
+                        },
                     ],
 
 
@@ -1401,6 +1394,7 @@ module.exports = {
                             "03-Seata柔性事务",
                             "04-Seata是什么?",
                             "05-开始",
+                            "docker-install-configure-seata-server",
                         ]
                     }],
 
@@ -1660,6 +1654,15 @@ module.exports = {
                             "kafka-versions",
                         ]
                     }, ],
+                    
+                    "/md/serverless/": [{
+                        title: "serverLess",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "serverless-is-a-scam",
+                        ]
+                    }, ],
 
                     "/md/RocketMQ/": [{
                             title: "消息队列基础",
@@ -1818,6 +1821,7 @@ module.exports = {
                         sidebarDepth: 0,
                         children: [
                             "01-爆火的分布式数据库到底是个啥？",
+                            "03-BASE 还能撑多久？强一致性才是事务处理的终极奥义！",
                             "18-分布式数据库的HTAP能统一OLTP和 OLAP吗？",
                             "21-查询执行引擎：加速聚合计算加速",
 
@@ -1954,6 +1958,7 @@ module.exports = {
                             "09-程序员的“三步走”发展战略",
                             "10-为何我建议你学会抄代码",
                             "11-计师能去哪些央国企？",
+                            "mastering-architecture-diagrams",
                         ]
                     }],
 
@@ -2057,6 +2062,10 @@ module.exports = {
                                 "contextual-retrieval",
                                 "lm-studio-transform-mac-into-ai-tool",
                                 "计算机使用功能",
+                                "navigating-llm-deployment-tips-tricks-and-techniques",
+                                "goodbye-cursor-hello-windsurf",
+                                "qwen-QwQ",
+                                "only-ai-flow-can-do",
                             ]
                         },
                         {
@@ -2235,6 +2244,8 @@ module.exports = {
                                 "evolution-software-architecture-mainframes-to-distributed-computing",
                                 "cell-based-architecture-distributed-systems",
                                 "cell-based-architecture-resilient-fault-tolerant-systems",
+                                "架构师教你kill祖传石山代码重复&大量ifelse",
+                                "measuring-technical-debt",
                             ]
                         },
                         {
diff --git a/docs/md/AI/llm/goodbye-cursor-hello-windsurf.md b/docs/md/AI/llm/goodbye-cursor-hello-windsurf.md
new file mode 100644
index 000000000..31a35cc20
--- /dev/null
+++ b/docs/md/AI/llm/goodbye-cursor-hello-windsurf.md
@@ -0,0 +1,148 @@
+# Goodbye cursor👋🏻，Hello Windsurf！
+
+## 0 前言
+
+回想你用技术时真正感受到魔力的那刻：
+
+- 第一次向ChatGPT提问？
+- 第一次用智能手机触摸屏？
+- 第一次在Google搜索某件具体事并得到完美的资源？
+
+当与技术的互动简单、无缝、直观，但在表面之下显然有非常强大的事情发生时，就会发生魔力。
+
+过去几年里，以Codeium名义推出具有真正价值的AI产品，同时也悄悄迭代这概念——对于使用AI的软件工程师来说，魔力是什么样子的？开发者如何在保持流畅的同时仍然认识到技术的力量？
+
+**答案是[Windsurf Editor]，2024-11-13正式发布。**
+
+让你始终处于flow状态 第一个代理集成开发环境。在 Windsurf 编辑器中，开发人员的工作与AI真正融为一体，让编码体验如魔法般神奇。Windsurf Editor 专为AI与人类的合作方式而设计。 
+
+## 1 啥是AI Flow？
+
+从现有AI使用范式开始。Copilots伟大是因为它们与开发者——人——的协作性——人始终在循环中。话虽如此，为了保持人在循环中：
+
+- copilots通常被限制在短期范围内的任务
+- 代理之所以伟大，是因为AI可以独立迭代以完成更大的任务
+
+权衡是，你失去了协作方面，这就是为什么我们还没有看到代理IDE。一个IDE将是小题大做。Copilots和代理都是强大的，但通常被视为互补，因为它们的优势和劣势确实互补。
+
+任何魔力都有一些直觉的火花。我们的火花来自于一个简单问题——如AI拥有两个世界中最好的部分会咋？若AI既能协作又能独立？嗯，这是使人类特别的一面。与这种AI合作可能会感觉像魔法。
+
+**通过大量研究，我们建立了这种系统的基石，称为AI flows。AI flows允许开发者和AI真正心灵融合，结合了copilots和代理的最佳部分。**
+
+这是火花。不是AI copilots，不是AI agents，而是AI flows。现在，我们需要构建神奇的体验，一个新的表面，可以本地暴露这个火花。
+
+Windsurf Editor 由AI驱动，既能像副驾驶一样与你协作，又能像代理一样独立完成复杂任务。AI的每一步都与您完全同步。
+
+AI flows可实时了解人类行为，实现真正人机合一。 确保AI始终了解您的工作环境，并在您转换任务时立即做出调整，这样它就可提供帮助，而无需让您加快速度或打断您的注意力。Flows 从根本上说是一种全新的AI工作方式。
+
+### 人类的工作方式
+
+2022 年之前，人类与键盘同步工作，代码开发完全由人工完成。 每一行代码都是人类输入的直接结果：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/11/a641faa4c61ec050ab248dec57ef154d.png)
+
+### Copilots 的工作原理
+
+2022 年，LLM 风靡全球，Copilots 应运而生，帮助人类完成既定任务。 如果你开始输入一行字，它就会建议你完成。 或者，如果你提出一个问题，就会收到一个答案。
+
+![](/Users/javaedge/Downloads/IDEAProjects/java-edge-master/assets/image-20241123200452441.png)
+
+### 代理是如何工作的
+
+2024 年初，代理的概念被介绍给全世界，它可以通过访问工具和高级推理能力自主完成整个工作流程。 然而，早期的迭代导致了不合理的等待时间和需要花费更多时间审查的不合格输出。
+
+![](/Users/javaedge/Downloads/IDEAProjects/java-edge-master/assets/image-20241123202348100.png)
+
+### Flows 如何工作
+
+2024 年 11 月，我们推出名为 Flows 的与AI合作的新方式。 这项创新将开发人员的操作与AI实时同步，实现了无缝、持续的协作，AI可以适应开发人员的工作，而无需了解工作范围。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/11/1cc12bf756299bcf96aba6bee5fa0416.png)
+
+Flows - 人类与AI的工作方式：
+
+```
+Flows = Agents + Copilots
+```
+
+### 代码比清晨的咖啡更顺畅
+
+我们构建了一个推理引擎，使开发人员和AI之间能够进行无缝、实时的协作，完美地同步工作。
+
+![image-20241123202911522](/Users/javaedge/Downloads/IDEAProjects/java-edge-master/assets/image-20241123202911522.png)
+
+## 2 Cascade
+
+谈到flows、magic和power，名字“Windsurf”吸引了我们。帆板运动完美地捕捉了人类、机器和自然在一项看似不费力但需要巨大能量的活动中的结合。我们决定使用**“Windsurf”**作为这个新表面的身份，一个全新的编辑器，[Windsurf Editor]。
+
+然后，水的类比不断涌现，从核心flow——[Cascade]开始。引入 Chat Cascade 的流程演进是使用AI编码的最强大方法。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/11/e6d4d8e24189d6eab32b27c56b9a90cc.png)
+
+**Cascade是Chat的flow演变，你发现Cascade在侧边栏而非Chat中**：
+
+- 表面看，它像一个熟悉的对话表面。这是魔法的“直观”部分
+- 一旦你用它，你会注意到“力量”部分——对你现有代码库的深层推理的综合（知识），访问大量工具及对你独立于调用AI所采取行动的全知
+
+使Cascade强大的不仅是知识、工具和人类行为的广度，还有每个维度的深度：
+
+- 知识：基于多年研究成果，我们建立了最先进的[上下文感知]系统，可解析和语义理解复杂的代码库，与您的所有 SCM 集成，对您的代码库建立无与伦比的了解，为您提供个性化建议，从而使代码接受度提高 38%。如不擅长这个，就不会有幸与摩根大通、戴尔、Anduril和Zillow等最大和技术最复杂的公司合作。
+
+- 工具：Cascade工具包括编辑、添加文件、grep、列出目录中的文件，甚至代码执行。还带有专有工具，如Riptide，这是支撑我们[Cortex研究突破]的技术。它是一个基于LLM的搜索工具，可几s内扫描数百万行代码，准确率比最先进的基于嵌入的系统高出3倍，同时高度优化了大量计算的使用
+
+- 人类行为：你可在许多不同粒度上捕获这些信息，但很容易要么信息太少，要么太多。要么你错过决定用户意图的核心行为，要么你有很多噪音。我们不会透露魔法的配方，但我们在检查点、信息压缩等方面做了很多，以使Cascade像人与AI之间的无限联合意识流。
+
+若Cascade是Chat的flow演变，那[Autocomplete]呢？你可能用过Autocomplete的flow演变——Supercomplete！预测下一个意图，而不仅是光标位置的下一个文本，只有flows和推理人类行为的能力才能实现。
+
+虽然flows是Windsurf Editor背后的动机，但Cascade并非你第一天就能访问的唯一AI能力。Windsurf Editor是围绕我们的总体AI引擎构建的，以助你写代码，无论Cascade还是文本编辑器。当你用文本编辑器，你将获得所有你已从Codeium扩展中喜爱的功能。
+
+可启用快速的Autocomplete模式，并获得快速且具有上下文感知的Autocomplete建议，以完成你的想法。还包括Supercomplete，该模态可预测与你下一个意图相对应的编辑，提示你进行多光标编辑，让你保持在flow中。Command有全新UX，使执行大修改、完整文件生成和后续操作更加容易和快速。甚至将Command带入了终端，这样你就再也不用Google那个随机的终端命令了。这些只是Windsurf Editor中融入的AI功能的一小部分。
+终端中的Command
+
+[The Windsurf Editor]旨在让你保持flow状态。即时、宝贵的AI开发者协助，你想要的地方，你想要的时候。Cascade 的代理功能将人工智能与人类之间的协作提升到了一个新的水平，使其成为复杂编码工作流程的终极合作伙伴。
+
+## 3 战术
+
+谈到魔法，我们有足够的自我意识，知道我们迄今为止成功的一个原因是我们对技术和用户现实都非常坦率。
+
+我们没有开始构建编辑器，直到我们意识到[flows]和[Cascade]的魔法。
+
+话虽如此，我们也对自己诚实，我们不必完全从头开始构建编辑器来暴露这种魔法，所以我们分叉了Visual Studio Code。我们完全意识到关于人们分叉VS Code创建“AI IDEs”的梗，但是再说一次，如果扩展可以最大化我们愿景的潜力，我们就不会构建Windsurf Editor。我们一直是一个以扩展为先的公司，仍然认识到人们真的喜欢他们拥有的编辑器，特别是在我们的企业客户基础中。所以，我们的Codeium扩展不会消失，我们将继续改进它们，发挥它们的最大能力。甚至一些flow能力，如Supercomplete，也可以在扩展中实现，所以我们会构建它们！Windsurf Editor的唯一区别是我们现在有一个表面，我们可以真正无限制地暴露魔法，因为它的演变。
+
+下一个战术部分是
+
+### 成本
+
+我们的基础设施专业知识一直是我们Codeium扩展中许多受欢迎方面的秘诀，从疯狂的低延迟到慷慨的免费层（由于我们的行业领先的服务成本，这不是一个财务上不负责任的选项）。但即使对我们来说，以全部潜力提供这种魔法也是一个有意义的运营成本跳跃。所以虽然Windsurf Editor本身和许多Cascade能力将是免费的，但长期来看，全部魔法只会在付费计划中提供。话虽如此，**接下来的一周，我们为任何使用Windsurf Editor的个人免费提供两周的完整体验。**
+
+对企业客户，我们迫不及待想让你访问Windsurf Editor，但就像我们构建的每件事物一样，希望确保一切都在规模化之前稳定。
+
+## 4 规划
+
+在工程团队内部进行了投票——你对这次发布更兴奋，还是对我们将在“第一波”更新中很快发货的[Windsurf Editor]？后者几乎是一致的决定。为啥呢？
+
+我们计划让[Cascade]访问更多知识——扩展推理，不仅是代码库，还有现有的工单、文档、Slack消息，你说了算！如果有一个知识库对开发者有用，它就对Cascade有用。这将允许Cascade在更大更复杂的知识库上执行更令人印象深刻的任务。
+
+还计划给Cascade更多的强大工具。如果我们使用开发者行为来理解语义上哪些文件彼此相关，即使在句法上没有代码路径或信号表明它们会连接呢？例如，我们可以了解某些前端代码在某些后端代码修改时会发生变化，甚至可能是一个用于部署的yaml文件。这种聚类将是一个强大的工具来检索相关信息。
+
+我们将开始利用flows的时间线表示，通过预测开发者未来想要做的不同分支，根据我们迄今为止观察和迭代的行为。通过预测更多的意图，我们将创建一个flow版本的Command功能。这些意图可以作为一个新的Cascade的可选选择，但我们还有其他想法，用于这种主动能力的新颖用户体验。
+
+我们开始拼凑如果Windsurf Editor本身是人类之间的协作表面，如果Cascade是AI参与日常协作的地方，那会是什么样子。第一次，我们有一个足够智能的“机器”，它将为成为对话的一部分增加价值，并从中受益。
+
+当然，我们如何继续将flows扩展到软件开发的更多关键工作表面？如果AI与你在文档、工作计划、代码审查等方面保持同步，那么AI的价值将简单地复合。
+
+**这次发布只是开始。**
+
+## 5 总结
+
+我们不介意你称Windsurf编辑器为第一个代理IDE，第一个原生表面，让开发者与AI协作，或简单地说——**明天的编辑器。而今天，**我们只是希望你能再次有机会体验技术中的魔法。
+
+参考：
+
+- https://docs.codeium.com/windsurf/getting-started
+- https://codeium.com/blog/context-aware-everything-more-advanced-realtime-context-than-github-copilot
+- https://codeium.com/windsurf
+- https://codeium.com/blog/codeium-dream-bigger
+- https://codeium.com/autocomplete
+- https://codeium.com/supercomplete
+- https://codeium.com/cascade
\ No newline at end of file
diff --git a/docs/md/AI/llm/navigating-llm-deployment-tips-tricks-and-techniques.md b/docs/md/AI/llm/navigating-llm-deployment-tips-tricks-and-techniques.md
new file mode 100644
index 000000000..4bd87bec7
--- /dev/null
+++ b/docs/md/AI/llm/navigating-llm-deployment-tips-tricks-and-techniques.md
@@ -0,0 +1,149 @@
+# LLM部署，你必须要知道的几个技巧！
+
+## 0 前言
+
+今天我会首先解释为什么 LLM 的部署很难，因为许多人可能并不理解其中的复杂性。接着，我会分享七个提高 LLM 部署效果的技巧和方法。
+
+## 1 为啥 LLM 部署困难？
+
+“最近在忙啥？”
+
+“我一直在让 LLM 服务变得更简单。”
+
+“LLM 部署难吗？不是直接调用 OpenAI API 就行？”
+
+“某种程度上是这样。”因为提到 LLM，大多数人只会想到 OpenAI，调用 API 确实简单。她为什么要谈这些内容？调用 API 谁不会？但实际上，访问 LLM 的方式不止一种。可用托管的API如 OpenAI、Cohere、Anthropic 和 AI21 Labs 等。他们已为你完成托管和部署，你只需调它们。虽然这确实减少你的工作量，但仍存在复杂性，如减少幻觉输出。不过，他们已经完成很多繁重任务。很多场景，你可能更倾向自托管，如调用 Mistral或托管 Llama 或其他模型。这意味着你在自己的环境中托管它，无论VPC还是PC。
+
+### 那为啥还自托管？
+
+很多原因：
+
+- 降低大规模部署成本。如只做概念验证，基于 OpenAI API 模型成本确实低。但如大规模部署，自托管最终成本更低。因为只需解决自己的业务问题，可用更小模型，而 OpenAI 必须托管一个能解决编程和写作莎士比亚问题的大模型，因此需要更大的模型。大规模部署时，自托管成本会低得多
+- 性能提升。当你用特定任务的LLM或对其微调，使其专注你的任务，通常得到更好性能
+- 大多数客户选择自托管的原因：隐私和安全。如你处受监管行业，如需遵循 GDPR 或满足合规团队的要求，你可能也需自托管
+
+如果这几点不重要，就用 API 够了。
+
+### 企业选择开源的主要原因
+
+包括控制权、定制化和成本。最重要的是控制权。拥有 AI 独立性至关重要，如当 OpenAI 再次解雇 CEO，你仍可访问自己的模型，尤其是当你构建重要的业务应用时。如果你正在考虑自托管，你绝对不是孤军奋战，大多数企业都在努力建立自托管能力。
+
+对冲基金的一员说：“隐私对我的用例很重要，因此自托管是有意义的。”然后他可能会问：“自托管真的有那么难吗？”我经常听到类似的话，这让我非常恼火。答案是：确实更难。你不能忽视那些你看不到的复杂性。当你调用基于 API 的模型时，你受益于他们的工程师在构建推理和服务基础设施方面所做的所有努力。实际上，像 OpenAI 这样的公司有 50 到 100 人的团队在管理这些基础设施。包括模型压缩、Kubernetes、批处理服务器、函数调用、JSON 生成、运行时引擎等。当你使用 API 模型时，这些你都不需要操心，但当你自托管时，这些问题突然变成了你的责任。
+
+他可能会说：“但我经常部署机器学习模型，比如 XGBoost 或线性回归模型。部署这些 LLM 会有多难？”我们的回答是：“你知道 L 代表什么吗？”部署这些模型要困难得多。为什么呢？LLM 中的第一个 L 代表“大”（Large）。我记得我们刚成立公司时，认为一个拥有 1 亿参数的 BERT 模型已经算大了。现在，一个拥有 70 亿参数的模型被认为是小型模型，但它仍然有 14GB 的大小，这绝对不小。
+
+第二个原因是 GPU。与 CPU 相比，GPU 更难处理，它们也更昂贵，因此高效利用 GPU 十分重要。如果你对 CPU 的利用率不高，可能问题不大，因为它们成本低得多。但对于 GPU，成本、延迟和性能之间的权衡非常明显，这是以前可能没有遇到过的。
+
+第三个原因是，这个领域发展非常快。我们现在用于部署、优化和服务模型的技术，有一半在一年前还不存在。还有一个值得一提的问题是编排问题。通常，对于这些大语言模型应用，你需要协调多个不同的模型。例如，RAG（检索增强生成）就是一个典型的例子。你需要协调一个嵌入模型和一个生成模型。如果是最先进的 RAG，你可能还需要多个解析模型，比如图像模型和表格模型，此外还需要一个重排序模型。最终，你可能会用到五六个不同的模型。这会让人感到非常困惑。此外，部署应用还有其他常见难点，比如扩展性和可观察性。
+
+## 2 咋让 LLM 部署更轻松？
+
+分享一些让 LLM 部署更轻松的技巧。虽然仍会很痛苦，但不会那么糟糕。
+
+### **1. 知道你的部署边界**
+
+构建应用程序时，应解你的部署边界。通常，人们在构建出一个自认为可行的应用程序后，才开始考虑部署边界。我认为，你应该先花时间思考你的需求，这会让后续一切变得更简单。如考虑你的：
+
+- 延迟需求是什么？
+- 预计负载是多少？
+- 应用程序是顶多只有三个用户，还是像 DoorDash 一样要服务数百万用户？
+- 有什么硬件资源可用？
+- 需要在本地部署，还是可用云实例？如是云实例，需要什么类型实例？
+
+所有这些问题都要提前规划。你可能无法知道精确需求，所以最好列出范围。如：“只要延迟低于 1 秒就可以接受。”或“只要高于某个值也行。”。还有一些问题如：我是否需要保证输出是 JSON 格式？是否需要保证输出符合特定的正则表达式规则？这些都值得提前思考。
+
+### **2. 始终进行量化**
+
+提前规划好这些需求，那后续所有决策都容易得多。始终对模型进行量化。量化本质是一种模型压缩技术，它将LLM的权重精度降低到你想要的任何形式。4-bit 是我最喜欢的量化，从 FP32（32位浮点数）开始。因为它在准确性和压缩比之间达到极佳平衡。你可以看到这张图表，我们有一个准确性与模型位数的关系图，也就是模型的大小。
+
+假设原始模型是 FP16（16位浮点数），其实它通常是 32 位的。红线表示它的准确性。当我们压缩模型时，比如从 FP16 降低到 4-bit，固定资源下，使用量化模型的性能实际上要好于未量化的模型。通过这张图表我们可以得出结论，对于固定资源，量化模型通常能够在准确性和资源利用率之间取得更好的平衡。
+
+我们从基础设施开始，倒推需求。假设我们可用 L40S GPU，它有 48GB 显存。因为我们知道可用的资源，可以根据现有的模型倒推需求。如是 Llama 13B（130亿参数）模型，它需要 26GB 显存，没问题，可运行。但如是当前最先进 Mixtral 模型，它无法直接运行。然而，一个经 4-bit 量化的 Mixtral 模型可运行，这就很棒了。通过这种方式，就知道哪些模型可用来实验。
+
+那个关于 Tim Dettmers 的图表也告诉我们，4-bit 量化模型在性能上可能更优。假设 Llama 模型和 Mixtral 模型体积一样，4-bit 模型通常会保留原来模型的高精度，同时大大减小了模型体积。我们通过基础设施倒推，找到能适配资源的量化模型，这很可能是当前性能最优的解决方案。
+
+### **3. 花时间优化推理**
+
+建议只花一点时间是因为，部署这些模型时，你最初想到的策略往往是完全错误的。虽然你不需要花大量时间思考这个问题，但稍微投入一些时间，可以使 GPU 利用率提升几个数量级。
+
+举个例子，关于批处理策略。批处理是指多个请求同时处理。部署这些模型时，GPU 利用率是最宝贵的资源。因为 GPU 很昂贵，所以最大化其利用率非常重要。
+
+如果我不使用批处理，那么 GPU 的利用率大概是这样的，非常糟糕。一个常见的错误做法是使用动态批处理，这种方法适用于非生成式 AI 应用，比如你之前可能用过的系统。动态批处理的原理是等待一小段时间，收集在这段时间内到达的请求，然后一起处理。在生成式模型中，这种方法会导致 GPU 利用率下降。开始时利用率很高，但随后会下降，因为用户会因较长的生成时间被卡在队列中。
+
+动态批处理虽然是常见做法，但通常效果不好。如果你花点时间思考这个问题，可以采用持续批处理（Continuous Batching）。这是我们使用的一种方法，也是当前生成式模型的最先进批处理技术。它允许新到的请求中断正在处理的请求，以保持 GPU 利用率始终处于高水平。这样不仅减少了排队时间，还大幅提升了资源利用效率。这张 GPU 利用率图表是我们几周前的状态。相比动态批处理，持续批处理在 GPU 成本上可以带来一个数量级的提升。这完全不影响模型准确性，但大大提高了利用率。
+
+对于非常大的模型，单个 GPU 无法满足推理需求。例如，Llama 70B、Mixtral 或 Jamba 等模型非常庞大。通常需要将它们分布在多个 GPU 上进行推理。这要求你能够设计一种多 GPU 推理的方法。最常见的方法（例如 Hugging Face 的 Accelerate 推理库所使用的方式）是按层级划分模型。如果模型占用 90GB，可以分配 30GB 给每个 GPU，共使用三个 GPU。然而，这种方法的缺点是每次只有一个 GPU 处于活跃状态，导致资源浪费，因为后续 GPU 需要等待前一个 GPU 完成任务。
+
+这种方式存在局限性，例如在 Hugging Face Accelerate 库中。我们认为更优的方法是 **Tensor Parallel**。这种方式将模型按“长度”分割，使每个 GPU 能同时运行每一层，从而大幅提升推理速度，并支持任意大小的模型。所有 GPU 同时运行，因此避免了资源浪费。例如，在一个模型中，可以实现 GPU 利用率提升 3 倍，再加上其他优化，可以显著提升资源效率。
+
+---
+
+### **4. 整合基础设施**
+
+目前为止，我的建议包括：考虑部署需求、量化、推理优化。第四个建议是整合基础设施。生成式 AI 的计算成本非常高，因此集中的基础设施管理能带来很大优势。传统企业的机器学习团队往往以孤岛形式存在，导致基础设施整合效率低下。通过集中的 MLOps 团队（如 Ian 所领导的团队），可实现一次性部署并由单一团队进行维护，这让应用开发团队专注于构建应用。
+
+举个例子，一个中央计算基础设施可以提供访问模型（如 Llama 70、Mixtral 和 Gemma 7B）的权限，并由中央团队定期更新模型（例如从 Llama 2 升级到 Llama 7）。各个应用开发团队可以个性化模型，例如添加 **LoRA**（轻量化适配器）或 **RAG**（结合专有数据的检索增强生成）。中央团队负责维护基础设施，而分散的开发团队仅需调用这些模型构建应用。这种方法不仅提高了 GPU 的利用率，还为组织提供类似 OpenAI 的体验，但使用的是私有模型。
+
+关键点包括：确保推理服务器具备可扩展性、支持 LoRA 适配器以实现微调。如果做好这些工作，可以显著提升 GPU 利用率。GPU 的利用率非常重要，甚至可以说是仅次于家人和朋友的存在。
+
+---
+
+**案例研究：RNL**
+
+一个美国企业 RNL 拥有四个不同的生成式 AI 应用，每个应用使用独立 GPU。这种方式导致了 GPU 利用率低下，因为不是所有应用始终满负荷运行。我们帮助他们将所有应用资源整合到一个推理服务器中，使各团队通过共享资源构建应用。这种方式将所需 GPU 数量减少了一半，同时也能更高效地管理生成式和非生成式任务。
+
+---
+
+### **5. 构建时考虑模型替换周期**
+
+建议的第五点是，假设在 12 个月内需要替换模型。随着 LLM 的快速发展，仅通过切换模型即可获得性能提升。例如，一个客户去年使用 Llama 1 开发了首个应用程序，在一年内更换了四次模型。
+
+每周他们都会说，这个新模型出来了。你们支持吗？我会说，是的，但为什么这是第六次更改了？让我们回想一下一年前最先进的技术是什么。一年前，也许那时Llama已经发布了，但如果在那之前，可能是T5系列。T5模型是当时最好的开源模型。我们所见证的是开源大语言模型生态系统的惊人爆发。这一切都始于Llama，然后是Llama 2，接着许多企业在此基础上构建。
+
+例如，Mistral 70B实际上是用与Llama相同的架构构建的。我们有来自阿联酋的Falcon。我们有Mistral的Mixtral。你们有很多，而且它们还在不断涌现。实际上，如果你查看Hugging Face，这是所有这些模型存储的地方，如果你查看他们的开源模型排行榜，顶级模型几乎每周都在变化。最新和最伟大的模型不断出现。这些模型将会不断变得更好。这是所有模型的性能，无论是开源还是非开源，你可以看到许可证，专有的或非专有的。开源模型正在慢慢地占据排行榜。我们开始接近开源和非开源之间的平等。现在，开源模型大约在GPT-3.5左右。那是我们所有人都为之惊叹的原始ChatGPT。
+
+我的预期是，我们将在未来一年内达到GPT-4的质量。这意味着你真的不应该将自己与单一模型或单一供应商绑定。回到我之前向你们展示的a16z报告，大多数企业都在使用多个模型供应商。他们正在以一种可互操作的方式构建他们的推理栈，如果OpenAI出现故障，我可以轻松地将其替换为Llama模型。或者，如果现在Claude比GPT-4更好，我可以很容易地替换它们。以这种可互操作性为念进行构建真的很重要。我认为OpenAI给我们的最伟大的事情不一定是他们的模型，尽管它们真的很棒，但他们实际上违反直觉地民主化了AI领域，不是因为他们开源了他们的模型，因为他们真的没有，而是因为他们为行业提供了API的统一性。如果你以OpenAI API为念进行构建，那么你就可以捕捉到很多价值，并且能够轻松地替换模型。
+
+这对构建方式意味着什么？以API和容器为先的开发使生活变得更轻松。这是相当标准的事情。抽象真的很好，所以不要花时间为你的特定模型构建自定义基础设施。你很可能在12个月内不会使用它。如果你要构建，尝试构建更通用的基础设施。我们总是说，在当前阶段，我们仍在许多组织中证明AI的价值，工程师应该花时间构建出色的应用体验，而不是纠结于基础设施。因为现在，对于大多数企业来说，我们很幸运有足够的预算去尝试这些生成式AI的东西。
+
+我们需要快速证明价值。我们倾向于说，不要使用只支持Llama的框架，因为这只会给你带来更多麻烦。无论你选择什么架构或基础设施，确保当Llama 3、4、5、Mixtral、Mistral出现时，它们将帮助你采用它。我可以回到我之前谈到的案例研究。我们以这种方式构建，显然，用Mixtral替换Llama 3非常容易，当Llama 3出现时。例如，如果出现了更好的Embedder，就像几周前出现的非常好的Embedder，我们也可以很容易地替换它。
+
+### **6. GPU看起来真的很贵，无论如何都要使用它们**
+
+GPU看起来真的很贵。无论如何都要使用它们。GPU是如此惊人。它们非常适合生成式AI和生成式AI工作负载。生成式AI涉及大量并行计算，这恰好是GPU非常擅长的事情。你可能会看价格标签，觉得它比CPU贵100倍。是的，确实如此，但如果你正确使用它并从中获得你需要的利用率，那么最终处理的订单数量将会多得多，而且每个请求的成本将会便宜得多。
+
+### **7. 尽可能用小型模型**
+
+当你可以的时候，使用小型模型。GPT-4是王者，但你不会让王者洗碗。洗碗是什么：GPT-4是了不起的。它是一项真正卓越的技术，但使它如此出色的是它在能力上非常广泛。我可以使用GPT-4模型写情书，你可以用它成为一个更好的程序员，我们使用的是完全相同的模型。这很疯狂。那个模型有很多能力，因此它真的非常大。它是一个巨大的模型，而且推理起来非常昂贵。我们发现，你最好使用GPT-4来处理那些开源模型还无法处理的真正困难的事情，然后使用较小的模型来处理那些更容易的事情。通过这样做，你可以大幅降低成本和延迟。当我们谈到你之前拥有的延迟预算或资源预算时，如果你只在真正需要的时候使用GPT-4，你可以最大限度地利用资源预算。
+
+三个常见的例子是RAG Fusion。这是当你的查询被大型语言模型编辑后，然后所有查询都进行搜索，然后结果进行排名以提高搜索质量。例如，你可以通过不使用GPT-4而获得很好的结果，只在必要时使用GPT-4。例如，使用RAG，你可以只使用一个生成模型来重新排名，所以只是在最后检查Embedder说相关的东西是否真的相关。小型模型，特别是针对函数调用的微调模型非常好。函数调用的一个非常常见的用例是，如果需要我的模型输出类似JSON或regex的东西，我基本上有两种方法可以做到这一点。要么我可以微调一个更小的模型，要么我可以给我的小模型添加控制器。控制器真的很酷。控制器本质上是，如果我自托管模型，我可以禁止我的模型说出任何会破坏JSON模式或我不想要的regex模式的标记。像这样的事情，实际上大多数企业用例，你不一定需要使用那些基于API的模型，你可以立即获得成本和延迟的好处。
+
+## 3 总结
+
+确定你的部署边界，然后反向工作。因为你知道你的部署边界，你知道你应该选择的模型，当你将其量化下来时，就是那个大小。花时间思考优化推理，这可以真正地产生多个数量级的差异。生成式AI受益于基础设施的整合，所以尽量避免让每个团队负责他们的部署，因为很可能会出错。假设你将在12个月内替换你的模型进行构建。GPU看起来很贵，但它们是你最好的选择。当你可以的时候，你会使用小型模型。然后我们对Russell说这些，然后他说，“这太有帮助了。我非常兴奋地使用你的提示部署我的关键任务LLM应用。”然后我们说，“没问题，如果你有任何问题，请让我们知道”。
+
+## 4 问答
+
+Q：你说过要为灵活性而构建。频繁更换模型的用例是什么？我们在自定义微调和自定义数据上花费的时间和精力将不得不重复？在频繁更换模型的情况下，你有什么建议吗？
+
+A：你什么时候想要频繁更换模型？一直都是。随LLM改进速度，几乎总是可以仅通过更换模型就获得更好性能。你可能需要对提示进行一些调整，但通常，一对一的切换是可行的。例如，如果我的应用构建在GPT-3.5上，我将其替换为GPT-4，即使我使用相同的提示，我的模型性能可能会提高，这是一件非常低努力的事情。这与更换所需的工程努力如何协调？如果这是一个月的长过程，如果没有显著改进，那么你就不应该进行那个切换。我建议尝试以一种方式构建，使其不是一个月的长过程，实际上可以在几天内完成，因为那样几乎总是值得的。
+
+这与微调如何协调？我有一个辛辣而热门的观点，即对于大多数用例，你不需要微调。微调在几年前的深度学习中非常流行。随模型越来越好，它们也更擅长遵循你的指示。你通常不需要为许多用例进行微调，可用RAG、提示工程和函数调用等方法。这就是我倾向于说的。如果你正在寻找你的第一个LLM用例，谈论更换模型，一个非常好的第一个LLM用例就是尝试替换你的NLP管道。许多企业都有现成的NLP管道。如果你可以将它们替换为LLMs，通常，你会获得多个点的准确性提升。
+
+Q：你认为企业级硬件和消费者最大硬件在本地硬件上的区别是什么，因为我选择了消费者最大硬件，因为你的内存可以高达6000兆传输，PCI通道更快。
+
+A：因为像他这样的人已经拿走了所有的A100s，当我们进行内部开发时，我们实际上使用的是4090s，这是消费者硬件。它们更容易获得，也比获得数据中心硬件便宜得多。这就是我们用于开发的东西。我们实际上没有使用消费者级硬件进行大规模推理，尽管没有理由它不会工作。
+
+如果它适合你的工作负载。我们也使用它。我们认为它们非常好。它们也便宜得多，因为它们作为消费者级而不是数据中心级出售。
+
+Q：你说GPU是一个整体，也是最重要的。我有点惊讶，但也许我的问题会解释。我用只有CPU的小虚拟机做了一些概念验证，我每秒几次请求就得到了相当好的结果。我没有问自己关于可扩展性的问题。我在想我们应该在多少请求时切换到GPU？
+
+A：实际上，也许我在GPU方面有点过于强烈，因为我们也在CPU上部署过。如果延迟足够好，这通常是人们首先抱怨的问题，是延迟，那么CPU可能没问题。只是当你在寻找规模经济并且当你在寻找扩展时，它们几乎总是每个请求更贵。如果你的请求数量合理地低，延迟也足够好，那么你可以继续使用它。我认为我们的第一个推理服务器的概念验证是在CPU上完成的。你也会知道的另一件事是，你将限制你可以使用的模型的大小。例如，如果你正在做一个70亿量化的，你可能也可以继续使用CPU。我认为如果你从一张白纸开始，GPU更好。如果你的起点是你已经有一个充满CPU的大型数据中心，而且你否则不会使用它们，那么仍然值得尝试是否可以利用它们。
+
+Q：我有一个关于通常使用的API的问题，当然，OpenAI的API通常也被应用程序使用。我也知道很多人真的不喜欢OpenAI的API。你看到其他API了吗？因为很多人只是在模仿它们，或者他们只是使用它，但没有人真的喜欢它。
+
+A：当你说他们不喜欢它时，是他们不喜欢API结构，还是不喜欢模型？
+
+Q：这是关于API结构的。这是关于文档的。这是关于状态的，关于你无法完全理解的很多事情。
+
+A：我们也真的不喜欢它，所以我们编写了自己的API，称为我们的推理服务器，然后我们有一个与OpenAI兼容的层，因为大多数人使用那种结构。你可以查看我们的文档，看看你是否更喜欢它。我认为，因为它是第一个真正爆发的，它是整个行业在API结构上汇聚的地方。
\ No newline at end of file
diff --git a/docs/md/AI/llm/only-ai-flow-can-do.md b/docs/md/AI/llm/only-ai-flow-can-do.md
new file mode 100644
index 000000000..856c8337b
--- /dev/null
+++ b/docs/md/AI/llm/only-ai-flow-can-do.md
@@ -0,0 +1,340 @@
+# Only AI Flow Can Do！
+
+## 0 大纲
+
+- 作为骨灰级程序员，咋用 AI flow 提高编码效率
+- 零代码基础，如何使用 AI 辅助编程工具实现自己的想法
+- 盘点常用的 AI 辅助编程工具和使用场景
+- 如何选择适合自己的 AI 辅助编程工具
+
+如今的 AI flow 系列软件包括：Cursor、Bolt、Windsurf、v0、通义灵码......
+
+## 1 编码咋提效？
+
+AI flow已和我日常工作学习和创作无缝融合，使用 AI flow 写代码，体验非常流畅，编程效率大大提升。
+
+### 1.1 代码补全
+
+Tab一下，代码自动补全，各厂家有训练自己的智能补全模型，在项目工程感知上下文，给出智能代码补全建议。苦了那些只能在云桌面开发的同学，毕竟私有部署太昂贵！
+
+以前可以叫我 cv 侠，现在请叫我 `Tab`侠。
+
+### 1.2 Debug && Fixbug
+
+AI flow 作为各行业都有资深经验的编程大师，助你 Debug 和 Fix 代码错误。遇到报错了：
+
+- 以前：复制错误信息，打开浏览器被迫定向到 CSDN 或者 stackoverflow，海底捞针找解决方案，并反反复复颠三倒四地改代码
+
+- 现在，在提示错误的位置，点击 Debug 或 Fix 按钮，就会结合项目上下文，给出错因和可行解决方案。甚至给你写出修复后代码，按照 AI flow 的建议修改，或者在给出的修复代码上点击 Apply，就可以快速找到和修复问题
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/8c7ae3ddf48031cb950298c7ed546407.png)
+
+
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/d60937b3d53829070f14744eafb40207.png)
+
+有了 AI flow，相当于有了24h技术顾问，随时帮你自动查问题、分析问题、写代码修复问题。让你更专注架构设计。再也不用担心出现偶发的 bug 啦！
+
+### 1.3 实时对话 && 联网搜索
+
+对中国宝宝更友好的的ChatGPT能力和AI search应用。
+
+随时在 AI flow 编辑器右侧打开对话框，激情四射聊任何话题！
+
+在输入框输入 `@web` 即可联网检索，具备 AI 搜索产品标准的 RAG 能力：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/88018ea19f193c89375ef234a586e762.png)
+
+再也不用订阅ChatGPT！
+
+### 1.4 写提示词
+
+想写提示词控制 AI 生成内容，而又不太擅长提示词工程，就能让 AI flow 帮你写提示词。
+
+### 1.5 写页面
+
+做 Web 项目开发，我们经常需要写前端页面。我最近一年习惯用 NextJS 框架做全栈开发，页面组件用 React 写，使用 TailwindCSS 写样式，UI 组件库用的是 Shadcn/UI。
+
+使用 AI flow 前的登录页面：
+
+- 在 UI 组件库找到可以引入的组件
+- 或自己写 HTML + TailwindCSS 实现需要的组件。样式要调的美观，耗时良久。
+
+而用 AI flow，一句话描述我的需求快速得到满足需求的登录组件。
+
+### 1.6 截图生成组件
+
+看到某网站的某组件不错，想将其样式和逻辑复制到个人项目。只需截图要抄的组件，让它仿照写出。
+
+这比以前Copy别人网站的样式，通过审查元素查看 HTML、CSS源码，效率高太多。
+
+### 1.7 写常用的代码逻辑 / 函数
+
+以前从0开始抄写一个个功能函数，使用 AI flow 只需一句话描述功能需求 / 入参和出参就能快速生成所需函数。还有人会去刷leetcode吗天天？？
+
+### 1.8 代码重构
+
+技术架构更新时，经常要重构代码。
+
+比如以前将老系统从 php 迁移到 java，自己重构一个项目的所有数据库操作代码，需要大量人天资源。
+
+而用 AI flow，一句话描述需求，让它用新的数据库客户端去重构所有的数据库操作逻辑即可，等它重构完，我需要检查一遍是否有重构不当的代码，让 AI flow 按我的风格继续改写。
+
+只要人工确认过一次重构，剩余的数据读写代码，都会参考第一次重构的风格，快速完成。
+
+唉！也难怪即使有很多需要维护的老系统，如今企业还是不招人了！
+
+### 1.9 国际化
+
+做出海应用，就得支持多语言。
+
+如NextJS框架多语言方案用 next-intl，只需在项目的 messages 目录下放置语言的 json 文件。
+
+以前，要先写好 en.json 内容，再复制到 ChatGPT，让它翻译成其他语言 json 文件，如 zh.json / ja.json 等，再把翻译好的 json 文件都放置到 messages 目录。
+
+每次新增 / 修改 / 删除要支持多语言的内容，要先更新 en.json 的内容，再按上面流程更新其他语言文件的内容。之前组内负责国际化的同事每天痛不欲生，我试用期还没结束，他就离职了！
+
+有了AI flow，还是先更新 en.json 内容，然后到其他语言文件中，一个Tab，快速补全，自动填充翻译好的内容。
+
+## 2 快捷键
+
+### 2.1 Tab
+
+升级pro版，解锁无限制 Tab 智能补全。
+
+### 2.2 Command + L
+
+代码看到一半，想快速打开对话框咨询各种问题。
+
+### 2.3 Command + K
+
+在文件中唤起 Ctrl + K 的位置原地写代码，如果点 Apply 就会覆盖当前位置的代码。
+
+一般会在创建一个新的函数，或者重构某段逻辑的时候使用，原地修改代码，diff 效果更明显。
+
+### 2.4 Command + I
+
+唤起 AI flow Composer 窗口，输入需求，一次性创建 / 修改 / 删除多个文件件 / 文件。
+
+Composer 是划时代功能，真正开启“一句话让 AI 创建一个项目“的时代。零编码基础的人，也可以使用 AI flow Composer 快速创建项目结构，实现基本的代码逻辑，对于做一些 demo 类应用开发，非常有用。
+
+另一场景，如多语言适配，只需修改 en.json 一个文件的内容，通过 AI flow Composer 一次性修改所有语言的 json 文件！
+
+但涉及多个文件代码生成时，质量肯定比单文件生成要差，需人工提质。
+
+## 3 0基础，学IT，用AI实现每一个idea
+
+我们后端，都不懂前端，咋做一个完整导航出海站呢？
+
+### 3.1 Composer
+
+新建一个文件夹，作为 AI flow 工程目录。
+
+打开Composer窗口，描述需求：
+
+```
+请你生成一个独立IP展示网站，包含两个页面，首页显示我所有的自媒体社交平台，about 页面显示我的个人背景介绍。网站主题色使用羊皮纸黄色，要求兼容手机端访问。
+```
+
+一个回车下去！AI flow Composer 会根据你的需求生成一个项目结构，并生成基本的代码逻辑。等代码生成完，你只需要点 Accept all，生成的代码都应用到工程目录：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/98f849a18d7a84d163366ef058b81ef6.png)
+
+由于用的人实在太多，经常会不可用，重试即可让它继续完成任务！
+
+浏览器打开项目的入口文件：index.html预览：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/ac78a5c0c59b866ece7afd5cb9ad8f26.png)
+
+Composer 对话框继续细化需求，如 “一栏显示五个作品，配图使用真实的图片“，点 Submit 提交，AI flow Composer 会根据你的需求修改代码。
+
+repeat这过程：enter你的需求 -> Accept all 应用修改 -> 预览。直到网站让你顺眼了。
+
+只能感慨，怪不得前端失业了，怪不得招一个 java 就能全栈了，事实如此！
+
+Only AI Flow Can Do！
+
+因为使用 AI flow Composer 只是在PC完成一个项目，还要精通全球分布式部署：如把生成的代码打包上传服务器部署或用 Vercel / Cloudflare 云部署平台。
+
+### 3.2 使用 Bolt.new 构建产品
+
+完全不懂开发的也别急，还有Bolt.new，网页版的 AI 辅助编程工具：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/384009c51009d1dc0a97c5ecce04c86c.png)
+
+输入框描述需求，如：
+
+```bash
+创建一个课程主页，介绍课程交付的主页内容，列出课程资料，课程资料是一个图文列表，也放一些学员评价，让课程主页更加吸引人
+```
+
+看我一个回车！开始生成代码，在右侧把整个项目的代码结构都展示出来。
+
+左侧对话框继续细化需求，让它优化代码，同时在右侧 Preview 面板预览。
+
+一直优化到你满意，点击Deploy或Open in StackBlitz，代码即可部署上线，得到可公开访问的链接：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/278b1e938c8fb82ee16d455c7ced9b9f.png)
+
+打开它，就能看到你的项目：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/d2ab0f75569289ea06642ea42566b58e.png)
+
+
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/1637e55db2e4e0d43d912ed989aada9c.png)
+
+> 适合编程完全 0 基础选手，从0创建项目，简直无门槛，还支持云端部署功能，让你的产品直接被全球观众鉴赏！
+
+### 3.3 Claude 3.5 sonet构建单页应用
+
+在 Claude 描述需求，快速创建单页应用的代码，直接通过 Claude Artifact 面板预览，也可发布上线，获得一个可公开访问链接。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/6f4108e70560729871b1dc42c8072973.png)
+
+点击右下角即可发布：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/590d85b19dae22fe83cfb3a709e9d27a.png)
+
+> Claude，尤其是 sonnet 代码生成能力一直强项，很适合实现单页应用或组件。不支持项目级多层级文件能力。
+
+### 3.4 v0.dev 生成组件
+
+类似3.3的应用场景，还可用 v0.dev，Vercel 推出的一个网页版的 AI 辅助编程工具。内置Shadcn/UI基础组件库，所渲染的UI组件在审美方面遥遥领先，也支持和 figma 联动：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/3a0c081ff6d4db8b3b1e004412ab1d82.png)
+
+### 3.5 Pagen 生成 landscape
+
+为你的idea生成一个落地页：
+
+- 技术论坛演示
+- 给用户介绍产品服务
+
+0基础，仅需填写产品名称和描述，选择一个看得上的模板：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/4d58a17ee535d06d1f792c4fbc82d7b4.png)
+
+只需几秒生成landscape：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/74b95bbc798dab91809ca11dc5965fb1.png)
+
+## 4 实力大测评
+
+### 4.1 AI flow
+
+#### ① cursor
+
+第一个面世的AI flow产品，可完整实现项目的能力，自动调试 / 重构能力和知识库问答能力。
+
+1. 支持 VS Code 全部插件和配置。前端用户无缝上手
+2. 一个Tab就能全自动完成代码编写，甚至独立完成一个项目，让用户爽爆了
+
+时代洪水终究是淹没了前端的弟弟们。以后开发新项目，后端大佬们都能站在AI flow的肩膀开发完整 web 应用。
+
+#### ② Windsurf
+
+Codeium 推出，也是基于 VS Code 开发。
+
+相比 cursor，在上下文感知和记忆方面更强，对大型复杂项目开发重构支持更好，最致命的，更便宜！此刻 cursor 肯定感慨：既生瑜何生亮，天要亡我凯撒大帝！
+
+#### ③ Pear AI
+
+YC 投资的一个项目，基于 VS Code的开源项目：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/18256651237992ac1b24106987ca9ef1.png)
+
+### 4.2 编辑器 AI 扩展
+
+AI flow火前，就有很多项目基于 VS Code 做 AI 扩展，最知名的：
+
+#### ① Github Copilot
+
+最早的 AI 辅助编程插件。出身顶流，自带光环和各种 buff，如今看来可惜战略失误，已经明日黄花：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/8935c528ba2457f8c73fbe31e6f35e7d.png)
+
+#### ② Continue
+
+开源，可对接任意大模型：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/5892d748c20e3c776e359cd029b30258.png)
+
+#### ③ Cline
+
+开源的 VS Code 插件，无官网：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/06c17230c391ea30ca14199dd3c29e27.png)
+
+
+
+### 4.3 UI生成
+
+根据prompt或截图，生成前端组件，不用再手写结构和样式，如：
+
+- cursor
+- v0.dev
+- Claude
+- screenshot-to-code：开源产品，可以自行部署，只要上传截图，就能快速复刻UI组件
+
+### 4.4 全自动实现完整项目
+
+- cursor
+- Bolt.new
+
+想快速构建 AI 智能体：
+
+- Replit Agent
+
+![](https://mmbiz.qpic.cn/mmbiz_png/RwxY4xJSwr7v4I2bGibhBGQroJicnMODFXCkgJiargQCol4RHtRm3ZjMUxB5gsHKngImXKM2Fp78YzJZEkW5TYAyg/640?wx_fmt=png&from=appmsg&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1)
+
+- Wordware
+
+![](https://mmbiz.qpic.cn/mmbiz_png/RwxY4xJSwr7v4I2bGibhBGQroJicnMODFXPcsJGuHlHf8CQqal4T8ib5xT5MR6Ip9Z8D7iaSgzSEG3Rpks7RpFkTibw/640?wx_fmt=png&from=appmsg&tp=webp&wxfrom=5&wx_lazy=1&wx_co=1)
+
+
+
+## 5 选型
+
+### 5.1 场景
+
+高频编码：cursor / Windsurf等AI flow。
+
+偶尔写Demo验证idea或偶尔写个 UI 组件：Bolt.new / v0.dev / Claude 等网页工具。
+
+### 5.2 价格
+
+愿为优质生产力付费，可升级 AI flow 应用的 Pro 会员，解锁无限智能补全。
+
+不想按月付费的，可选择本地部署开源版 AI flow 应用，对接本地大模型，享受更高配置灵活度和更低使用成本。
+
+### 5.3 使用习惯
+
+- 习惯VS Code，无脑选 cursor或 Windsurf
+- 只会用 IDEA，懒得看其它软件，就装插件：Github Copilot，Continue，Cline 
+- 很少写代码，只是偶尔需要写个 Demo 验证想法，可选 Bolt.new 或 v0.dev。
+
+### 5.4 功能花样
+
+推荐综合使用，汇集各种场景：
+
+- 重点使用 AI flow 应用和 Bolt.new
+- 搭配 v0.dev、Claude
+
+## 6 总结
+
+AI 会完全取代程序员吗？No！
+
+人类最神奇的：
+
+- 想象力
+- 创造力
+- 对项目的架构设计
+- 对作品的审美
+- 对逻辑的抽象
+- 最复杂的人性
+
+AI都无法取代。AI 可从零到一，甚至到 90，但最关键的还是你的那最后十分。一个优秀且领域专业的软件设计师，不可能被 AI 取代。
+
+别太焦虑 AI 会不会淘汰自己，拥抱 AI，使用 AI，发挥提效，才是此刻你该做的。
+
diff --git a/docs/md/AI/llm/qwen-QwQ.md b/docs/md/AI/llm/qwen-QwQ.md
new file mode 100644
index 000000000..2774f6387
--- /dev/null
+++ b/docs/md/AI/llm/qwen-QwQ.md
@@ -0,0 +1,237 @@
+# 千问QwQ，推理界“新王”！
+
+## 0 前言
+
+思考、质疑、理解，人类探索未知的永恒追求。探索之路，QwQ如一位怀抱无尽好奇的学徒，以思考和疑问照亮前路。QwQ深知自己一无所知，而这种认知正是其好奇心的源泉。探寻答案过程，始终保持自省，以理性之光审视每个假设，在不同思维维度中穿行，追寻更深层真理。
+
+但正如所有智慧的追求者，QwQ也有局限，它也只是漫长旅程的一个初步阶段——仍在学习如何行走于理性之路。思绪偶尔飘散，答案或许未尽完善，智慧仍在积淀。但这就是学习的美妙：既有能力又保持谦逊，既有知识又永远充满疑问。
+
+## 1 模型局限性
+
+QwQ-32B-Preview 是由 Qwen 团队开发的实验性研究模型，专注增强 AI 推理能力。作为预览版，它展现令人期待的分析能力，同时也存在局限：
+
+1. **语言切换问题**：模型可能在回答中混合使用不同语言，影响表达的连贯性。
+2. **推理循环**：在处理复杂逻辑问题时，模型偶尔会陷入递归推理模式，在相似思路中循环。这种行为虽然反映了模型试图全面分析的努力，但可能导致冗长而不够聚焦的回答。
+3. **安全性考虑**：尽管模型已具备基础安全管控，但仍需要进一步增强。它可能产生不恰当或存在偏见的回答，且与其他大型语言模型一样，可能受到对抗攻击的影响。我们强烈建议用户在生产环境中谨慎使用，并采取适当的安全防护措施。
+4. **能力差异**：QwQ-32B-Preview 在数学和编程领域表现出色，但在其他领域仍有提升空间。模型性能会随任务的复杂度和专业程度而波动。我们正通过持续优化，努力提升模型的综合能力。
+
+## 2 模型表现
+
+通过深入探索和无数试验发现：当模型有足够的时间思考、质疑和反思时，它对数学和编程的理解就会深化。就像学生通过认真地检查自己的工作并从错误中学习变得更加聪明一样，我们的模型也通过耐心和深思熟虑的分析获得了更深入的见解。这种细致的反思和自我质疑的过程使得模型能够取得解决复杂问题的突破性进展。我们的探索之旅揭示了模型在数学和编程领域解决一些最具挑战性的问题的卓越能力，包括：
+
+- GPQA：一个通过研究生级别问题评估高阶科学解题能力的评测集，旨在考察科学问题解决能力。
+- AIME：涵盖算术、代数、计数、几何、数论、概率等中学数学主题的综合评测，测试数学问题解决能力。
+- MATH-500：包含500个测试样本的MATH评测集，全面考察数学解题能力。
+- LiveCodeBench：评估真实编程场景中代码生成和问题解决能力的高难度评测集。
+
+![](https://qianwen-res.oss-cn-beijing.aliyuncs.com/assets/blog/qwq-32b-preview/QwQ-32B-Preview_result.png#center)
+
+### 具体表现
+
+1. GPQA：65.2%，展示了研究生水平的科学推理能力；
+2. AIME：50.0%，证明了强大的数学问题解决技能；
+3. MATH-500：90.6%，体现了在各类数学主题上的全面理解；
+4. LiveCodeBench：50.0%，验证了在实际编程场景中的出色表现。
+
+这些成果充分体现了QwQ在分析和问题解决能力方面的显著进步，尤其是在需要深度推理的技术领域。
+
+## 3 案例
+
+下列样例展示了QwQ深度自省的能力——质疑自身假设、进行深思熟虑的自我对话，并仔细审视其推理过程的每一步。
+
+### Example: Logical Reasoning
+
+#### User
+
+S先生、P先生、Q先生他们知道桌子的抽屉里有16张扑克牌：红桃A、Q、4 黑桃J、8、4、2、7、3 草花K、Q、5、4、6 方块A、5。约翰教授从这16张牌中挑出一张牌来，并把这张牌的点数告诉 P先生，把这张牌的花色告诉Q先生。这时，约翰教授问P先生和Q 先生：你们能从已知的点数或花色中推知这张牌是什么牌吗？于是，S先生听到如下的对话：
+
+P先生：我不知道这张牌。
+
+Q先生：我知道你不知道这张牌。
+
+P先生：现在我知道这张牌了。
+
+Q先生：我也知道了。
+
+请问：这张牌是什么牌？
+
+#### QwQ-32B-Preview
+
+这道题是逻辑推理题，涉及到信息的逐步披露和推理。题目中有一副16张扑克牌，分别是：
+
+- 红桃：A、Q、4
+- 黑桃：J、8、4、2、7、3
+- 草花：K、Q、5、4、6
+- 方块：A、5
+
+约翰教授选了一张牌，把点数告诉了P先生，把花色告诉了Q先生。然后通过他们的对话，我们要推断出是哪张牌。
+
+首先，让我们来梳理一下对话的内容：
+
+1. P先生说：“我不知道这张牌。”
+
+   - 这意味着点数是重复的，因为如果点数唯一，P先生就能确定是哪张牌。例如，如果点数是K，只有草花K，那P先生就能确定是草花K。但P先生说不知道，所以点数必须在多个花色中出现。看看哪些点数是重复的：
+   - A：红桃和方块
+   - Q：红桃和草花
+   - 4：红桃、黑桃和草花
+   - 5：草花和方块
+   - 其他点数都是唯一的在某个花色中。
+
+   所以，可能的点数是A、Q、4、5。
+
+2. Q先生说：“我知道你不知道这张牌。”
+
+   - 这句话有点 tricky。Q先生知道花色，而且他说他知道P先生不知道。这意味着，根据Q先生知道的花色，可以确定点数一定是重复的。因为如果花色中的点数是唯一的，那么P先生就能知道是哪张牌。但Q先生肯定地说他知道P先生不知道，所以花色中的点数必须是重复的。
+   - 让我们看看每个花色中的点数情况：
+     - 红桃：A、Q、4
+       - A：红桃和方块
+       - Q：红桃和草花
+       - 4：红桃、黑桃、草花
+       - 所以，红桃花色中的所有点数都是重复的。
+     - 黑桃：J、8、4、2、7、3
+       - 4：黑桃、红桃、草花
+       - 其他点数在黑桃中是唯一的。
+       - 但Q先生说他知道P先生不知道，所以花色中的所有点数都必须是重复的。但在黑桃中，除了4，其他点数都是唯一的。所以，如果花色是黑桃，且点数是J、8、2、7、3，那么P先生就能知道，这与Q先生的说法矛盾。因此，花色不能是黑桃。
+     - 草花：K、Q、5、4、6
+       - Q：草花和红桃
+       - 4：草花、红桃、黑桃
+       - 5：草花和方块
+       - K和6是唯一的。
+       - 所以，如果花色是草花，点数是K或6，P先生就能知道，这又与Q先生的说法矛盾。因此，花色不能是草花。
+     - 方块：A、5
+       - A：方块和红桃
+       - 5：方块和草花
+       - 所以，方块中的点数都是重复的。
+   - 综上所述，Q先生知道花色，且确定所有可能的点数都是重复的，所以花色只能是红桃或方块。
+
+3. P先生说：“现在我知道这张牌了。”
+
+   - P先生原来不知道，但现在知道了。这意味着，在Q先生发言后，P先生通过点数和花色的可能组合，确定了是哪张牌。
+   - 我们已经知道花色只能是红桃或方块，点数是A、Q、4、5。
+   - 但P先生现在知道牌了，说明点数加上花色的限制，使得只有唯一一个可能性。
+   - 让我们看看点数在红桃和方块中的分布：
+     - A：红桃和方块
+     - Q：只有红桃
+     - 4：红桃
+     - 5：方块
+   - 等一下，Q先生说花色只能是红桃或方块，但根据之前的分析，花色是红桃或方块。
+   - 但是，点数Q只有红桃，4只有红桃，A有红桃和方块，5只有方块。
+   - P先生原来不知道，说明点数是重复的，即A或5。
+   - 如果点数是Q或4，只有红桃，那么P先生知道点数后，结合花色是红桃，就能知道是哪张牌，这与P先生第一句“我不知道这张牌”矛盾。
+   - 所以，点数不能是Q或4，只能是A或5。
+   - 现在，P先生说他知道牌了，说明在A或5中，结合花色，只有唯一可能性。
+   - 但A在红桃和方块都有，5只有方块有。
+   - 等一下，如果点数是5，只有方块5，那么P先生知道点数是5，结合花色是方块，就可以确定是方块5。
+   - 如果点数是A，花色可以是红桃或方块，那么P先生还是不能确定是哪一张。
+   - 但是，P先生说现在知道这张牌了，所以点数不能是A，因为A在红桃和方块都有，除非花色是方块，但P先生只有点数信息。
+   - 等一下，也许我需要更仔细地思考。
+   - Q先生说花色是红桃或方块，因为只有这些花色的点数都是重复的。
+   - P先生知道点数，现在他说知道了，说明在花色是红桃或方块的限制下，点数唯一确定了牌。
+   - 对于点数A，花色可以是红桃或方块，所以P先生不能确定是哪一张。
+   - 对于点数5，只有方块5，所以P先生知道是方块5。
+   - 因此，只有当点数是5时，P先生才能确定是方块5。
+   - 所以，牌是方块5。
+
+4. Q先生说：“我也知道了。”
+
+   - Q先生原来只知道花色，但不知道是哪张牌，现在他也知道了。
+   - 如果花色是方块，点数是A或5。
+   - 但P先生刚才已经确定是方块5，所以Q先生现在也知道了是方块5。
+   - 如果花色是红桃，点数是A、Q、4。
+   - 但是，根据之前的推理，点数Q和4只有红桃，点数A有红桃和方块。
+   - 但P先生原来不知道，所以点数不能是Q或4，只能是A。
+   - 但是，如果花色是红桃，点数是A，P先生不能确定是红桃A还是方块A。
+   - 但P先生说现在知道了，所以只有当点数是5，花色是方块时，P先生才能确定。
+   - 因此，Q先生现在也确定是方块5。
+
+综上所述，这张牌是方块5。
+
+**最终答案**
+
+方块5方块5
+
+### Example: Math
+
+#### User
+
+有个人想买几套餐具，到了店里发现，自己的钱可以买21把叉子和21个勺子，也够买28个小刀，但是，他想三样东西都买，而且要配成一套，并且把钱刚好花完，如果你是这个人，你会怎么买呢？
+
+#### QwQ-32B-Preview
+
+这个问题挺有意思的。我得好好想想。题目说，我有多少钱可以买21把叉子和21个勺子，或者可以买28个小刀。但是我想三样都买，而且要配成一套，还要把钱正好花完。我要怎么安排呢？
+
+首先，我需要理解一下这里的“一套”是什么意思。
+
+我想应该是买一把叉子、一个勺子和一个小刀作为一个组合，也就是一套包括这三种餐具各一件。对吧？
+
+所以，我的目标是买若干套这样的餐具，每套包含一把叉子、一个勺子和一个小刀，而且要把所有的钱都花完。
+
+但是，题目中给出的信息是，我的钱可以买21把叉子和21个勺子，或者可以买28个小刀。
+
+这说明，叉子和勺子的价格是相同的，因为用同样的钱可以买到相同数量的叉子和勺子，而小刀的价格不同，因为同样的钱可以买更多的小刀。
+
+让我设一下变量，方便计算。
+
+假设叉子的价格是x，勺子的价格也是x，小刀的价格是y。
+
+那么，根据题意：21x + 21x = 42x，这是我的总预算。
+
+另外，这个总预算也可以买28个小刀，也就是28y。
+
+所以，42x = 28y。从这个等式，我可以得出x和y之间的关系。
+
+42x = 28y两边都除以14，得到：3x = 2y
+
+所以，y = (3/2)x
+
+好了，现在我知道小刀的价格是叉子价格的1.5倍。
+
+现在，我想要买若干套餐具，每套包括一把叉子、一个勺子和一个小刀，而且要把钱正好花完。
+
+设我买n套，那么总成本是：n(x + x + y) = n(2x + y)
+
+但是，y = (3/2)x，所以代入得：n(2x + (3/2)x) = n((7/2)x)
+
+所以，总成本是n*(7/2)x
+
+而我的总预算是42x，所以：n*(7/2)x = 42x
+
+两边都除以x（假设x不为零），得到：n*(7/2) = 42
+
+然后，解n：n = 42 / (7/2) = 42 * (2/7) = 12
+
+所以，我可以买12套餐具，每套包含一把叉子、一个勺子和一个小刀，而且把钱正好花完。
+
+但是，我感觉这个答案有点简单，可能哪里想错了。让我再检查一下。
+
+首先，根据题意，钱可以买21叉子和21勺子，或者28小刀。
+
+我设叉子和勺子各为x，小刀为y，然后得到42x = 28y，从而y = (3/2)x
+
+然后，每套餐具是x + x + y = 2x + (3/2)x = (7/2)x
+
+总预算42x，除以每套的成本(7/2)x，得到12套。看起来逻辑是对的。
+
+但是，也许还有其他考虑。
+
+比如，是否必须买整数套？
+
+还是可以单独购买餐具？
+
+题目说要配成一套，并且把钱刚好花完。
+
+所以，应该是买整数套，而且钱要正好花完。
+
+我的计算中，n=12，是整数，符合要求。
+
+或者，可能有其他组合，比如不完全配成套，但题目明确说要配成一套，并且把钱花完，所以应该按照套来买。
+
+所以，我认为答案是买12套餐具，每套包括一把叉子、一个勺子和一个小刀。
+
+**最终答案**
+
+12
+
+## 4 探索之路的反思
+
+LLM的推理过程是一个复杂多面课题，研究团队在多个领域进行了深入的探索。从 Process Reward Model 到 LLM Critique，从多步推理到强化学习，我们一步步地推进着对智能的理解。虽然我们尚未明确最终的目标，但每一步的努力都使我们更接近真理、更接近智能。我们坚信，通过不懈的努力和探索，奇迹终将发生。
\ No newline at end of file
diff --git a/docs/md/biz-arch/data-gateway-a-platform-for-growing-and-protecting-the-data-tier.md b/docs/md/biz-arch/data-gateway-a-platform-for-growing-and-protecting-the-data-tier.md
new file mode 100644
index 000000000..11febc222
--- /dev/null
+++ b/docs/md/biz-arch/data-gateway-a-platform-for-growing-and-protecting-the-data-tier.md
@@ -0,0 +1,256 @@
+# Netflix数据网关背后的设计奥秘！
+
+Netflix的在线数据存储团队构建了一个名为数据网关（Data Gateway）的平台，使我们的数据存储工程师能够提供强大的数据抽象，保护Netflix应用开发人员免受复杂分布式数据库和不兼容API变更的影响。在这篇开篇帖子中，我们将介绍这个平台，作为系列文章的第一部分，展示我们如何使用这个平台提高应用开发人员每天使用的数据创建、访问和维护的抽象层次。
+
+# 动机
+
+在Netflix，我们采用并为数据层的大量开源（OSS）技术和数据库做出了贡献，包括[Apache Cassandra](https://cassandra.apache.org/)、[EVCache](https://github.com/Netflix/EVCache)（[memcached](https://memcached.org/)）、[OpenSearch](https://opensearch.org/）等。传统上，在线数据平台运营这些数据存储，并通过客户端库提供它们的OSS API。例如，我们运营Apache Cassandra集群，并为开发人员提供基于Thrift或Cassandra查询语言（CQL）协议的客户端库。这种策略使得数据平台能够利用OSS，因为这意味着较少的工程师可以为更多的用户运营更多类型的数据库。然而，虽然这促进了快速扩张，但将应用程序与Netflix不控制的多种API耦合在一起，从长远来看，维护成本显著增加。
+
+大多数数据库都有庞大的API表面积和很少的保护措施，这导致了一些使用上的反模式，需要高级知识来避免，可能需要数年才能被发现。例如，开发人员必须避免将太多数据写入一行或一个字段，而每个数据存储的限制都在变化。随着Netflix工程组织的增长和用例的激增，工程师们在减轻数据库滥用和重新设计应用程序的负担上遇到了更多的问题。这也增加了产品中断的风险，因为大多数关键应用程序都依赖于数据库服务，而数据库迁移本质上是危险的。
+
+此外，某些用例需要结合不同的数据库架构，以实现具有可扩展性、可用性和一致性能的所需API。随着时间的推移，我们发现Netflix的开发人员一次又一次地实现相同的模式——例如，在键值查找中添加缓存——换句话说，就是“重新发明轮子”。
+
+最后，我们必须将Netflix的标准服务发现、远程过程调用弹性技术、认证和授权系统集成到每一个OSS数据库中，以便Netflix应用程序能够使用它们。将每一个单独的数据库和每个数据库协议与这些系统集成是具有挑战性的，因为每个实现都是不同的，必须由不同的专家（例如Memcached专家、Cassandra专家等）维护。
+
+# 介绍数据网关
+
+Netflix的数据网关是一个为解决这些问题而构建的平台，它使得Netflix能够轻松构建和管理稳定的在线数据访问层（DAL）。它通过提供定制的API使用标准的IPC协议，如gRPC和HTTP，简化和保护数据访问，抽象背后的分布式数据库的复杂性，防止它们的使用反模式，同时增强安全性、可靠性和可扩展性。
+
+# 组件概览
+
+数据网关位于应用程序和数据库之间，使Netflix能够提供用户友好、安全和可靠的数据持久性服务。该平台旨在：
+
+**用户友好：**托管数据访问层，为Netflix的常见使用模式提供熟悉的gRPC或HTTP API，例如键值或时间序列。
+
+**安全：**将mTLS、连接管理、认证和授权委托给高性能的服务网格作为通用解决方案。
+
+**可靠：**将OSS数据存储的API表面积减少到只有它们的安全可扩展子集，防止反模式，并提供弹性[技术](https://www.infoq.com/presentations/netflix-stateful-cache/)的间接层，包括断路器、后压和负载卸载。
+
+![img](https://miro.medium.com/v2/resize:fit:875/0*hNeXq0ZpuYlI9YXr)
+
+数据网关实例
+
+如您所见，数据网关的数据平面实例由以下组成：
+
+- **EC2实例：**标准云计算Linux虚拟机，由Netflix性能团队调整为高性能和低延迟。
+- **数据网关代理：**边车进程，协调专门构建的容器镜像，并在健康时管理服务注册（即发现）。
+- **容器运行时：**标准OCI容器运行时，运行、监控、重启和连接代理和DAL容器。
+- **Envoy代理：**行业标准的服务网格容器作为反向代理。
+- **数据抽象层（DAL）：**作为容器部署的应用程序代码，托管专门构建的HTTP或gRPC数据访问服务，如键值。
+- **声明式配置：**简洁的声明式配置提供目标集群和数据平面实例状态。
+
+应用程序客户端通过标准的Netflix发现服务或AWS负载均衡器（例如ALB/NLB）连接到这些网关。Envoy终止TLS，授权每个连接，然后将请求转发到适当的DAL容器，这些容器使用数据库特定协议与数据库通信以完成每个查询。
+
+# 配置和声明式交付
+
+声明式配置通过数据网关代理在实例上驱动部署，也在整个舰队中驱动。我们将声明式配置分为两类：运行时和部署。
+
+## 运行时配置
+
+单个实例目标状态的配置称为“运行时”配置。此配置包括所需的数据抽象容器的组合、它们的环境和与代理的网络连接，以形成一个数据平面实例。以下是一个运行时配置的示例：
+
+```
+# 配置代理以接受协议
+proxy_config:
+  public_listeners:
+    secure_grpc: {mode: grpc, tls_creds: metatron, authz: gandalf, path: 8980}
+
+# 配置实现协议的DAL容器
+container_dals:
+  cql:
+    container_listeners: {secure_grpc: 8980}
+    image: "dgw-kv"
+  thrift:
+    container_listeners: {secure_grpc: 8980}
+    image: "dgw-kv"
+    env:
+      STORAGE_ENGINE: "thrift"
+
+# 配置协议的高级布线
+wiring:
+  thrift: {mode: shadow, target: cql}
+```
+
+这指定了两个名为`cql`和`thrift`的键值DAL容器，从`dgw-kv`镜像的部署特定版本创建，以及一个代理监听主机端口`8980`的外部互TLS（mTLS通过[metatron](https://www.usenix.org/conference/enigma2016/conference-program/presentation/payne)）连接。这个协议被命名为`secure_grpc`，这些连接应该使用mTLS进行身份验证，使用Netflix的Gandalf授权系统进行授权，并将每个请求转发到容器内部监听`secure_grpc`的DAL进程`8980`端口。最后，布线部分指定我们希望`thrift`调用阴影到`cql`容器。这在下面的图表中可视化：
+
+![img](https://miro.medium.com/v2/resize:fit:875/0*1y4WFUGWe-TX-CJj)
+
+## **部署配置（愿望）**
+
+虽然运行时配置限于单个实例，我们还必须配置这些实例的愿望部署。部署愿望声明性地描述了数据网关的部署属性。以下是一个部署配置的示例：
+
+```
+deploy_desires:
+  # 访问模式和容量是什么
+  capacity:
+    model_name: org.netflix.key-value
+    query_pattern:
+      access_pattern: latency
+      estimated_read_per_second:  {low: 2000, mid: 20000, high: 200000}
+      estimated_write_per_second: {low: 2000, mid: 20000, high: 200000}
+    data_shape:
+      estimated_state_size_gib:   {low:   20, mid: 200,   high: 2000}
+      reserved_instance_app_mem_gib: 20
+  # 这个部署对Netflix有多重要
+  service_tier: 0
+  # 应该部署哪个版本的软件
+  version_set:
+      artifacts:
+        dals/dgw-kv:  {kind: branch, value: main}
+        # 运行时配置也是一个容器！
+        configs/main: {kind: branch, sha: ${DGW_CONFIG_VERSION}}
+  # 我们应该在哪里部署，包括多个集群
+  locations:
+    - account: prod
+      regions: [us-east-2, us-east-1, eu-west-1, us-west-2]
+    - account: prod
+      regions: [us-east-1]
+      stack: leader
+  # 谁拥有（负责）这个部署
+  owners:
+    - {type: google-group, value: our-cool-team@netflix.com}
+    - {type: pager, value: our-cool-pagerduty-service}
+  # 谁消费（使用）这个部署，以及什么角色？
+  consumers:
+    - {type: account-app, value: prod-api, group: read-write}
+    - {type: account-app, value: studio_prod-ui, group: read-only}
+```
+
+这个配置指定了高层次的愿望：[容量](https://github.com/Netflix-Skunkworks/service-capacity-modeling)需求和工作负载上下文，服务重要性，软件组合包括镜像和运行时配置的版本，部署位置包括区域和账户，以及访问控制。服务层是一个简洁的上下文片段，作为0到3+之间的数值提供，指示重要性，并影响车队管理、容量规划和警报。
+
+我们使用部署愿望来为每个分片提供硬件和软件，例如，使用RPS和数据大小的期望容量作为输入到我们的自动化[容量规划器](https://www.youtube.com/watch?v=Lf6B1PxIvAs)，它将这个愿望编译为价格最优的EC2实例选择以及期望的ASG缩放策略。我们还使用部署愿望来通知舰队的持续部署，同时实现更安全的阶段性推出（即，首先部署较不重要的层），工件固定和其他关键功能。
+
+我们称一组集群为“分片”，因为它们为有状态服务提供[故障隔离](https://www.infoq.com/presentations/netflix-stateful-cache/)边界。在Netflix，分片部署或单租户架构对于在线数据服务是首选的，因为它们最小化了行为不当应用程序的影响范围，并保护更广泛的Netflix产品免受嘈杂邻居的影响。到2024年，数据网关平台声明性地管理着数千个分片的舰队，用于数十种不同的数据抽象。
+
+## **数据网关代理协调专门构建的组件**
+
+每个数据网关的核心是我们在Netflix EC2 VM上放置的代理，它从简洁的配置启动，管理所需的容器，并将代理连接起来，最终向用户公开数据抽象的组合。
+
+如果您熟悉docker-compose，数据网关在哲学上是类似的，只是集成了一流的网格[代理](https://www.envoyproxy.io/)和一个持续运行的代理，不断[推动](https://ieeexplore.ieee.org/document/9377621)[[pdf](https://jolynch.github.io/pdf/practical-self-healing-databases.pdf)]实例朝着目标配置和状态。我们集成多个组件以提供网关：
+
+- **可靠的系统组件：**EC2 VM、containerd、数据网关代理、有效压缩的软件镜像。
+- **进程间通信：**可插入的注册到服务注册表，mTLS、认证、授权、连接管理以及外部和内部实例网络。
+- **监控：**完整的系统健康检查，自动修复死亡或失败的容器。
+- **配置和软件：**软件和配置的版本集，以及基于环境的配置。
+
+您可能会问，“为什么不使用Kubernetes”？确实，Kubernetes[ pods](https://kubernetes.io/docs/concepts/workloads/pods/)加上[istio](https://istio.io/)是一个更通用的计算平台，但也是一个复杂的解决方案，用于解决我们的相对简单的问题。在Netflix，计算平台团队有很好的单租户EC2实例部署，并且在此模式下性能隔离和工具非常好。如果我们偏离这条铺好的道路，我们的团队将负责运营Kubernetes和Istio。我们没有兴趣采用和维护这样一个复杂的多租户调度器和容器解决方案来解决我们的相对简单的组件组合问题，这些组件共位于一个主机上。
+
+简单地说，Kubernetes并没有解决我们的许多实际问题，例如允许我们独立于pod启动和停止容器，它更复杂，并为我们的基础设施带来了许多我们不愿意在骨干数据层中的依赖。数据网关平台旨在只有三个外部依赖：一个Linux VM（EC2）、一个健壮的调度器（ASG）和一个blob存储系统（S3）。这种表面积的减少对于一个将为Netflix部署所有基础数据访问层的骨干基础设施组件来说非常有吸引力——由一个小团队维护。
+
+# 案例研究：键值服务
+
+在Netflix，我们将键值服务（KV）作为DAL部署在数据网关平台上。键值是基于数据网关构建的`HashMap[String, SortedMap[Bytes, Bytes]]`映射映射数据模型和查询API，具有每个命名空间的一致性和持久性控制，[抽象](https://www.youtube.com/watch?v=sQ-_jFgOBng&t=880s)了数据存储的细节。键值被Netflix的数百个团队用于为全活跃的全球应用程序提供在线数据持久性。
+
+![img](https://miro.medium.com/v2/resize:fit:875/0*DOPP14gy-M6wijOi)
+
+**键值服务数据网关**
+
+键值DAL运行一个Java Spring Boot应用程序，为键值API暴露gRPC和HTTP接口。这个应用程序组合了各种存储引擎，并在上面实现了诸如对冲、旁路缓存、透明大数据分块、自适应分页、通过资源限制器的断路器等特性。
+
+键值DAL镜像是使用[JIB](https://github.com/GoogleContainerTools/jib)构建的。Netflix的标准应用程序框架是Spring Boot，但数据网关平台与任何OCI兼容的镜像兼容，无论应用程序编程语言或客户端操作系统如何。DAL镜像在CI（持续集成）期间安全地上传到S3工件存储，并进行校验和以检测供应链篡改。
+
+键值使用运行时配置实现环境特定配置。例如：
+
+```
+proxy_config:
+  public_listeners:
+    secure_grpc: {authz: gandalf, mode: grpc, path: "8980", tls_creds: metatron}
+    secure_http: {authz: gandalf, mode: http, path: "8443", tls_creds: metatron}
+
+container_dals:
+  kv:
+    # 可插拔的启动命令
+    container_cmd: /apps/dgw-kv/start.sh
+    container_listeners: {http: "8080", secure_grpc: "8980", secure_http: "8443"}
+    # 配置堆和其他属性
+    env:
+      MEMORY: 8000m
+      spring.app.property: property_value
+    # 定义“健康”用于启动检查
+    healthcheck:
+      test:
+        - CMD-SHELL
+        - /usr/bin/curl -f -s --connect-timeout 0.500 --max-time 2 http://envoy:8080/admin/health
+    image: "dgw-kv"
+
+# 配置Netflix发现目标
+registrations:
+  - address: shard.dgwkvgrpc,shard.dgwkv
+    mode: nflx-discovery
+```
+
+代理运行一个名为`kv`的容器，由`container_dals.kv`对象配置，包括镜像名称、环境变量、容器健康检查命令和要公开的容器端口。
+
+代理将为`public_listeners`中的每个条目配置一个Envoy主机侦听器，绑定在所有地址（`0.0.0.0` ipv4或`::` ipv6）。这些侦听器通过名称转发到容器侦听器，例如`secure_grpc`指定从主机端口`::8980`路由到DAL容器端口`8980`。代理确保没有主机端口冲突。代理最后确定使用`registrations`配置在服务发现中注册哪个数据网关分片。
+
+容器级别的运行时配置与应用程序细节（如监听的端口或健康检查端点）无关。它与多种数据网关应用程序兼容，并实现了更便宜的推出，通过将快速变化的配置与应用程序代码库解耦。
+
+# 案例研究：安全RDS
+
+安全RDS使用数据网关平台实现了一个简单的透传架构，以保护到PostgreSQL和MySQL的L4连接。这个架构在Envoy进程中终止mTLS连接，然后将底层L4流代理到后端AWS RDS集群。这通过Netflix的标准mTLS认证和授权系统保护客户端访问，并依赖于后端AWS服务器TLS。
+
+客户端安装一个前向代理边车进程，该进程发现数据网关并在客户端的主机端口`localhost:5432`（PostgreSQL）上侦听。当客户端使用标准RDBMs客户端（如JDBC）连接到前向代理时，前向代理使用客户端应用程序的metatron TLS证书通过mTLS连接到数据网关端口`5432`。在数据网关服务器上，连接针对客户端的身份进行授权。如果允许，客户端应用程序通过L4 mTLS隧道从其出站代理连接，通过数据网关剥离mTLS，然后通过RDS终止连接，使用标准服务器端TLS。
+
+![img](https://miro.medium.com/v2/resize:fit:875/0*ephV9EV7ij-Q-dR0)
+
+安全RDS数据网关
+
+这种架构使我们能够无缝地使用Netflix的认证和授权铺好路径，为*任何*数据库协议提供安全保障，我们已经为AWS RDS、Open Search、CockroachDB、Neptune等使用了它。此外，我们还计划使用这种技术来保护其他现成的数据库，而无需修补这些数据库。它还使用户名/密码认证变得多余，只要数据库集群是单租户的，因为认证由Netflix的Metatron mTLS处理，授权由Netflix的Gandalf系统处理。我们还可以将现有的用户名/密码认证数据库纳入这个平台，通过Netflix的秘密系统安全地加密凭据，使用分片的数据访问控制策略。
+
+安全RDS运行时配置指定没有容器DALs，而是配置反向代理路由到`network_dals.rds.listeners.secure_postgres`下的RDS实例和一个网络DAL目标：
+
+```
+proxy_config:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   
+  public_listeners:                                                                                                                                                                                                                                                                    
+    secure_postgres: {mode: tcp, path: "5432", tls_creds: metatron, authz: gandalf} 
+
+# RDS Gateways run no DAL containers
+container_dals: {}        
+                                                                                                                                                                                                                                                             
+network_dals:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
+  rds:                                                                                                                                                                                                                                                                                 
+    listeners:                                                                                                                                                                                                                                                                         
+      secure_postgres: postgresql://rds-db.ih34rtn3tflix.us-east-1.rds.amazonaws.com:5432                                                                                                                                                                                                                                                                                                                                                                                                                                       
+    mode: logical_dns 
+```
+
+# 案例研究：无缝数据迁移
+
+工程师需要出于各种原因迁移数据存储之间的数据，我们之前已经[介绍](https://www.youtube.com/watch?v=3bjnm1SXLlo&t=122s)过。现代数据存储针对特定的使用模式和数据模型而设计，因此当使用模式发生变化时，数据存储技术也会发生变化。数据库迁移通常是必不可少的，因为安全漏洞、弃用的API、过时的软件或需要增强性能/功能等因素。无论是转移数据以减轻嘈杂邻居问题还是提供新功能，这些迁移在无法进行就地升级时，在维护系统完整性和效率方面发挥着关键作用。为了使这些过程对开发人员无缝，数据网关平台提供了一个流量阴影层，以复制数据并在不同的存储引擎之间性能测试查询负载。有了数据网关，我们可以[管理](https://www.youtube.com/watch?v=3bjnm1SXLlo&t=408s)整个迁移生命周期：
+
+![img](https://miro.medium.com/v2/resize:fit:875/0*QPZjqrdCswU4Wt1o) 
+
+数据网关通过在数据平面实例中部署两个DAL容器来支持流量阴影，一个作为连接到现有数据存储的“主”容器，另一个作为连接到新数据存储的“次”容器。我们配置反向代理将实时流量路由到主容器，并将“阴影”（换句话说，复制）流量路由到次容器。在从主容器到次容器回填数据后，我们然后提升次容器以接收主流量，从而完成数据迁移。以下是一个运行时配置的示例，其中`thrift`作为主DAL，`cql`作为次DAL：
+
+```yaml
+proxy_config:
+  public_listeners:
+    secure_grpc: { mode: grpc, path: 8980 }
+
+container_dals:
+  cql:
+    container_listeners:
+      secure_grpc: 8980
+  thrift:
+    container_listeners:
+      secure_grpc: 8980
+
+wiring:
+  thrift: { mode: shadow, target: cql }
+```
+
+
+我们使用这个平台提供的数据迁移能力[迁移](https://youtu.be/3bjnm1SXLlo?t=2078)了数百个已弃用的Apache Cassandra 2数据库到新的主要版本3。由于Cassandra 3对Thrift存储引擎有向后不兼容的更改，因此无法安全地执行就地更新，因此我们必须迁移数百个应用程序和Cassandra集群。我们首先将应用程序从直接Cassandra访问迁移到数据网关代理到他们现有的thrift数据的键值服务，然后通过阴影流量和回填将用户数据从Cassandra 2迁移到Cassandra 3。
+
+使用相同的基础设施组件集中数据迁移是一个重要的杠杆点，因为它使我们这些专家能够自动化这个过程，节省了数千个工程小时，并减少了数据损坏的风险。
+
+# 结论和未来工作
+
+数据网关证明了Netflix对我们在线数据层的技术革新和运营卓越的承诺。它不仅解决了即时的运营挑战，而且为未来的运营数据存储的进步铺平了道路，以满足Netflix不断增长的业务需求，从我们不断增长的SVOD业务到新的业务线，如广告、游戏和直播。
+
+在后续的文章中，我们计划分享更多关于我们如何使用这个平台快速开发、部署和维护为我们的开发人员提供高级数据抽象的细节，例如：
+
+- 在任意L4/L7数据库前统一认证和授权
+- gRPC *键值*服务，为我们的开发人员抽象出不断演变的键值存储引擎（Cassandra、EVCache、Netflix构建的其他自定义存储）数千种不同的用例。
+- gRPC *时间序列*服务，组合多个存储引擎以实现大规模摄取、保留策略以及搜索和检索。
+- gRPC *实体*服务，提供灵活的CRUD+QE（查询和事件）接口，融合CockroachDB、键值、Kafka和Elasticsearch
\ No newline at end of file
diff --git a/docs/md/biz-arch/enhancing-netflix-reliability-with-service-level-prioritized-load-shedding.md b/docs/md/biz-arch/enhancing-netflix-reliability-with-service-level-prioritized-load-shedding.md
new file mode 100644
index 000000000..e31d8c723
--- /dev/null
+++ b/docs/md/biz-arch/enhancing-netflix-reliability-with-service-level-prioritized-load-shedding.md
@@ -0,0 +1,230 @@
+# 增强 Netflix 可靠性的服务级优先级负载卸载
+
+## 0 引言
+
+在 2020 年 11 月，我们在博客文章 [通过优先级负载丢弃保持 Netflix 的可靠性](https://netflixtechblog.com/keeping-netflix-reliable-using-prioritized-load-shedding-6cc827b02f94) 中引入了在 API 网关层进行优先级负载丢弃的概念。本文探讨如何将这一策略扩展到单个服务层，特别是在视频流控制平面和数据平面中，以进一步提升用户体验和系统弹性。
+
+## 1 Netflix 负载丢弃的演进
+
+最初的优先级负载丢弃方法是在 Zuul API 网关层实现的。该系统能够有效管理不同类型的网络流量，确保关键的播放请求优先于不太关键的遥测流量。
+
+在此基础上，我们认识到需要在架构的更深层次——具体到服务层——应用类似的优先级逻辑，在同一服务中对不同类型的请求赋予不同的优先级。在服务层以及边缘 API 网关同时应用这些技术的优势包括：
+
+1. 服务团队可以自主掌控其优先级逻辑，并应用更细粒度的优先级控制。
+2. 可用于后台对后台的通信，例如不通过边缘 API 网关的服务之间的通信。
+3. 服务可以通过将不同请求类型整合到一个集群中并在必要时丢弃低优先级请求，而不是为失败隔离维护单独的集群，从而更高效地使用云资源。
+
+## 2 服务级优先级负载丢弃的引入
+
+PlayAPI 是视频流控制平面上的一个关键后台服务，负责处理设备发起的播放清单和许可证请求，这些请求是启动播放所必需的。我们根据关键程度将这些请求分为两类：
+
+1. **用户发起请求（关键）：** 这些请求在用户点击播放时发出，直接影响用户开始观看节目或电影的能力。
+2. **预取请求（非关键）：** 这些请求是在用户浏览内容时为了优化潜在延迟而乐观地发出的。如果用户选择观看特定标题，预取失败不会导致播放失败，但会略微增加从点击播放到视频显示在屏幕上的延迟。
+
+![](https://miro.medium.com/v2/resize:fit:2000/0*2KByIB47RWng5UNH)
+
+*用户浏览内容时 Netflix 在 Chrome 上向 PlayAPI 发出的预取请求*
+
+### 2.1 问题
+
+为了应对流量高峰、高后端延迟或后端服务扩展不足的情况，PlayAPI 过去使用并发限制器来限制请求，这会同时减少用户发起请求和预取请求的可用性。这种方法存在以下问题：
+
+1. 预取流量高峰降低了用户发起请求的可用性。
+2. 当系统有足够的能力处理所有用户发起请求时，后端延迟增加会同时降低用户发起请求和预取请求的可用性。
+
+将关键请求和非关键请求分片到单独的集群是一个选项，这可以解决问题 1，并在两种请求类型之间提供故障隔离，但其计算成本更高。分片的另一个缺点是增加了一些操作开销——工程师需要确保 CI/CD、自动扩展、指标和警报针对新集群正确配置。
+
+![](https://miro.medium.com/v2/resize:fit:742/0*pNfPHfPFe_k8r-YC)
+
+***选项 1*** *— 无隔离*
+
+![](https://miro.medium.com/v2/resize:fit:1400/0*BqZJayMkzt5-ZIHB)
+
+***选项 2*** *— 隔离但计算成本更高*
+
+### 2.2 我们的解决方案
+
+我们在 PlayAPI 中实现了一个并发限制器，该限制器在不物理分片两个请求处理程序的情况下优先处理用户发起请求。这种机制使用了开源 [Netflix/concurrency-limits](https://github.com/Netflix/concurrency-limits) Java 库的分区功能。我们在限制器中创建了两个分区：
+
+- **用户发起分区：** 保证 100% 的吞吐量。
+- **预取分区：** 仅使用多余的容量。
+
+![img](https://miro.medium.com/v2/resize:fit:822/0*BS1KXcwsikLJ4Zok)
+
+***选项 3*** *— 单集群优先级负载丢弃提供应用级隔离且计算成本更低。每个实例处理两种请求类型，并具有一个动态调整大小的分区，确保预取请求仅使用多余容量。必要时，用户发起请求可以“借用”预取容量。*
+
+分区限制器被配置为一个预处理 [Servlet Filter](https://github.com/Netflix/concurrency-limits/blob/master/concurrency-limits-servlet/src/main/java/com/netflix/concurrency/limits/servlet/ConcurrencyLimitServletFilter.java)，它通过设备发送的 HTTP 头确定请求的关键性，从而避免了读取和解析被拒绝请求的请求体的需要。这确保了限制器本身不会成为瓶颈，并且可以有效拒绝请求，同时使用最少的 CPU。例如，该过滤器可以初始化如下：
+
+```java
+Filter filter = new ConcurrencyLimitServletFilter(
+        new ServletLimiterBuilder()
+                .named("playapi")
+                .partitionByHeader("X-Netflix.Request-Name")
+                .partition("user-initiated", 1.0)
+                .partition("pre-fetch", 0.0)
+                .build());
+```
+
+需要注意的是，在稳定状态下，没有限流，优先级对预取请求的处理没有任何影响。优先级机制仅在服务器达到并发限制并需要拒绝请求时启动。
+
+### 2.3 测试
+
+为了验证我们的负载削减是否按预期工作，我们使用了故障注入测试，在预取调用中注入了2秒的延迟，这些调用的典型p99延迟小于200毫秒。故障被注入到一个基线实例中，该实例有常规的负载削减，还有一个金丝雀实例中，有优先级的负载削减。PlayAPI调用的一些内部服务使用单独的集群来处理用户发起的和预取请求，并使预取集群运行得更热。这个测试案例模拟了一个预取集群对于下游服务正在经历高延迟的场景。
+
+![](https://miro.medium.com/v2/resize:fit:2000/0*oU-FvJW2BCw5Z158)
+
+*基线 — 没有优先级负载削减。预取和用户发起的都看到了可用性的同等下降*
+
+
+
+![](https://miro.medium.com/v2/resize:fit:2000/0*hcY1lYOP4CVxn-LS)
+
+*金丝雀 — 有优先级负载削减。只有预取可用性下降，而用户发起的可用性保持在100%*
+
+没有优先级负载削减的情况下，当注入延迟时，用户发起的和预取的可用性都会下降。然而，在添加了优先级负载削减之后，用户发起的请求保持了100%的可用性，只有预取请求被节流。
+
+我们已经准备好将这个功能推广到生产环境，并看看它在实际中的表现如何！
+
+### 2.4 现实世界的应用和结果
+
+Netflix的工程师努力保持我们的系统可用，在我们部署优先级负载削减几个月后，Netflix发生了一次基础设施故障，影响了我们许多用户的流媒体播放。一旦故障被修复，我们从Android设备上看到了每秒预取请求的12倍激增，这可能是因为积累了大量的排队请求。
+
+![](https://miro.medium.com/v2/resize:fit:1400/0*0AdiUnX8fdinJTNR)
+
+*Android预取RPS的激增*
+
+这可能会导致第二次故障，因为我们的系统没有扩展到能够处理这种流量激增。PlayAPI中的优先级负载削减在这里有帮助吗？
+
+是的！虽然预取请求的可用性下降到了20%，但由于优先级负载削减，用户发起的请求的可用性保持在99.4%以上。
+
+![](https://miro.medium.com/v2/resize:fit:1400/0*gVNG6nlvDevP-53B)
+
+*预取和用户发起的请求的可用性*
+
+在某个时刻，我们节流了超过50%的所有请求，但用户发起的请求的可用性继续保持在99.4%以上。
+
+## 3 通用服务工作优先级
+
+基于这种方法的成功，我们创建了一个内部库，使服务能够根据可插拔的利用率度量执行优先级负载削减，具有多个优先级级别。
+
+与需要处理大量具有不同优先级的请求的API网关不同，大多数微服务通常只接收具有少数几个不同优先级的请求。为了在不同服务之间保持一致性，我们引入了四个预定义的优先级桶，受到[Linux tc-prio级别](https://linux.die.net/man/8/tc-prio)的启发：
+
+- **CRITICAL**：影响核心功能 — 如果我们没有完全失败，这些永远不会被削减。
+- **DEGRADED**：影响用户体验 — 随着负载的增加，这些将逐步被削减。
+- **BEST_EFFORT**：不影响用户 — 这些将以最大努力的方式响应，并可能在正常操作中逐步被削减。
+- **BULK**：后台工作，预计这些将定期被削减。
+
+服务可以选择上游客户端的优先级*或*通过检查各种请求属性（如HTTP头或请求体）将传入请求映射到这些优先级桶之一，以实现更精确的控制。以下是服务如何将请求映射到优先级桶的一个示例：
+
+```java
+ResourceLimiterRequestPriorityProvider requestPriorityProvider() {
+    return contextProvider -> {
+        if (contextProvider.getRequest().isCritical()) {
+              return PriorityBucket.CRITICAL;
+          } else if (contextProvider.getRequest().isHighPriority()) {
+              return PriorityBucket.DEGRADED;
+          } else if (contextProvider.getRequest().isMediumPriority()) {
+              return PriorityBucket.BEST_EFFORT;
+          } else {
+              return PriorityBucket.BULK;
+          }
+        };
+    }
+```
+
+### 3.1 通用基于CPU的负载削减
+
+Netflix的大多数服务都在CPU利用率上自动扩展，因此它是系统负载的自然度量，可以与优先级负载削减框架结合使用。一旦请求被映射到优先级桶，服务可以根据CPU利用率决定何时从特定桶中削减流量。为了维持自动扩展所需的信号，优先级削减只有在达到目标CPU利用率后才开始削减负载，并且随着系统负载的增加，更多关键流量将逐步被削减，以维持用户体验。
+
+例如，如果一个集群针对自动扩展的目标是60%的CPU利用率，它可以被配置为在CPU利用率超过这个阈值时开始削减请求。当流量激增导致集群的CPU利用率显著超过这个阈值时，它将逐步削减低优先级流量以节省资源供高优先级流量使用。这种方法还允许更多的时间为自动扩展添加更多实例到集群。一旦添加了更多实例，CPU利用率将下降，低优先级流量将恢复正常服务。
+
+![](https://miro.medium.com/v2/resize:fit:1274/0*sdKTOYaSQ_tEjE8r)
+
+ 
+
+*基于CPU利用率的不同优先级桶的请求被负载削减的百分比*
+
+### 3.2 基于CPU的负载削减实验
+
+我们进行了一系列实验，向一个服务发送大量请求，该服务通常以45%的CPU为目标进行自动扩展，但为了防止其扩展，以便在极端负载条件下监控CPU负载削减。实例被配置为在60%的CPU后削减非关键流量，在80%的CPU后削减关键流量。
+
+随着RPS超过自动扩展量的6倍，服务能够首先削减非关键请求，然后削减关键请求。在整个过程中，延迟保持在合理的限制内，成功的RPS吞吐量保持稳定。
+
+![](https://miro.medium.com/v2/resize:fit:1400/0*Wr6bJzQVf3dV4clf)
+
+ *使用合成流量的基于CPU的负载削减的实验行为.*
+
+![](https://miro.medium.com/v2/resize:fit:1400/0*DZCzE_AAi2cJXRRr)
+
+*即使RPS超过了自动扩展目标的6倍，P99延迟在整个实验中也保持在合理的范围内.*
+
+### 3.3 负载削减的反模式
+
+#### **反模式1 — 不削减**
+
+在上述图表中，限制器很好地保持了成功请求的低延迟。如果没有在这里削减，我们将看到所有请求的延迟增加，而不是一些可以重试的请求的快速失败。此外，这可能导致死亡螺旋，其中一个实例变得不健康，导致其他实例负载增加，导致所有实例在自动扩展启动之前变得不健康。
+
+![](https://miro.medium.com/v2/resize:fit:1360/0*Bp5AKoNtQOfHaExB)
+
+ 
+
+![](https://miro.medium.com/v2/resize:fit:1360/0*WPvKjlopcBGixDGB)
+
+ 
+
+*没有负载削减：在没有负载削减的情况下，增加的延迟可能会降低所有请求的质量，而不是拒绝一些可以重试的请求，并且可能使实例不健康*
+
+#### **反模式2 — 充血性失败**
+
+另一个需要注意的反模式是充血性失败或过于激进的削减。如果负载削减是由于流量增加，成功的RPS在负载削减后不应该下降。以下是充血性失败的一个例子：
+
+![](https://miro.medium.com/v2/resize:fit:1400/0*gPGs2BJ1Oxu9O7TK)
+
+ 
+
+*充血性失败：在16:57之后，服务开始拒绝大多数请求，并且无法维持在负载削减启动之前成功的240 RPS。这可以在固定并发限制器中看到，或者当负载削减消耗太多CPU阻止其他工作被完成时*
+
+我们可以看到，在上述的**基于CPU的负载削减实验**部分，我们的负载削减实现避免了这两种反模式，通过保持低延迟并在负载削减期间维持与之前一样多的成功RPS。
+
+## 4 通用基于IO的负载削减
+
+一些服务不是CPU限制的，而是由于后端服务或数据存储在超载时通过增加延迟施加反向压力，它们是IO限制的。对于这些服务，我们重用了优先级负载削减技术，但我们引入了新的利用率度量来输入到削减逻辑中。我们最初的实现支持两种基于延迟的削减形式，除了标准的自适应并发限制器（本身是平均延迟的度量）：
+
+1. 服务可以指定每个端点的目标和最大延迟，允许服务在服务异常缓慢时削减，无论后端如何。
+2. 在[Data Gateway](https://netflixtechblog.medium.com/data-gateway-a-platform-for-growing-and-protecting-the-data-tier-f1ed8db8f5c6)上运行的Netflix存储服务返回观察到的存储目标和最大延迟SLO利用率，允许服务在它们超载分配的存储容量时削减。
+
+这些利用率度量提供了早期警告迹象，表明服务正在向后端生成过多的负载，并允许它在压倒后端之前削减低优先级工作。这些技术与仅并发限制相比的主要优势是它们需要的调整更少，因为我们的服务已经必须维持严格的延迟服务水平目标（SLOs），例如p50 < 10ms和p100 < 500ms。因此，将这些现有的SLOs重新表述为利用率使我们能够及早削减低优先级工作，以防止对高优先级工作产生进一步的延迟影响。同时，系统*将接受尽可能多的工作*，同时维持SLO。
+
+为了创建这些利用率度量，我们计算有多少请求处理*慢于*我们的目标和最大延迟目标，并发出未能满足这些延迟目标的请求的百分比。例如，我们的KeyValue存储服务为每个命名空间提供了10ms的目标和500ms的最大延迟，所有客户端都接收到每个数据命名空间的利用率度量，以输入到它们的优先级负载削减中。这些度量看起来像：
+
+```java
+utilization(namespace) = {
+  overall = 12
+  latency = {
+    slo_target = 12,
+    slo_max = 0
+  }
+  system = {
+    storage = 17,
+    compute = 10,
+  }
+}
+```
+
+在这种情况下，12%的请求慢于10ms目标，0%慢于500ms最大延迟（超时），17%的分配存储被利用。不同的用例在它们的优先级削减中咨询不同的利用率，例如，每天写入数据的批次可能在系统存储利用率接近容量时被削减，因为写入更多数据会造成进一步的不稳定。
+
+一个延迟利用率有用的示例是我们的一个关键文件源服务，它接受在AWS云中新文件的写入，并作为这些文件的源（为Open Connect CDN基础设施提供读取服务）。写入是最关键的，服务永远不应该削减，但当后端数据存储超载时，逐步削减对CDN较不关键的文件的读取是合理的，因为它可以重试这些读取，它们不影响产品体验。
+
+为了实现这个目标，源服务配置了一个基于KeyValue延迟的限制器，当数据存储报告的目标延迟利用率超过40%时，开始削减对CDN较不关键的文件的读取。然后我们通过生成超过50Gbps的读取流量来压力测试系统，其中一些是针对高优先级文件的，一些是针对低优先级文件的：
+
+![](https://miro.medium.com/v2/resize:fit:2000/0*HI2zGO_MOxD-X1cG)
+
+ 
+
+![](https://miro.medium.com/v2/resize:fit:2000/0*AZnhEhtrsp9MEJFA)
+
+在这个测试中，有一定数量的关键写入和大量对低优先级和高优先级文件的读取。在左上角的图表中，我们增加到每秒2000次读取的~4MiB文件，直到我们可以在右上角的图表中超过50Gbps触发后端存储的超载。当这种情况发生时，右上角的图表显示，即使在显著负载下，源*只*削减低优先级读取工作以保留高优先级写入和读取。在此之前，当我们达到断裂点时，关键写入*和*读取会与低优先级读取一起失败。在这个测试期间，文件服务的CPU负载是名义上的（<10%），所以在这种情况下，只有基于IO的限制器能够保护系统。还需要注意的是，只要后端数据存储继续以低延迟接受它，源将服务更多的流量，防止我们过去与并发限制遇到的问题，它们要么在实际上没有问题时过早削减，要么在我们已经进入充血性失败时太晚削减。
+
+## 5 总结
+
+服务级别的优先级负载削减的实施已被证明是在保持高可用性和为Netflix客户提供卓越用户体验方面迈出的重要一步，即使在意外的系统压力下也是如此。
\ No newline at end of file
diff --git "a/docs/md/biz-arch/\351\253\230\346\200\247\350\203\275\346\216\222\345\220\215\347\263\273\347\273\237\347\232\204\346\240\270\345\277\203\346\236\266\346\236\204\345\216\237\347\220\206\357\274\214\346\236\266\346\236\204\345\270\210\345\277\205\347\234\213\357\274\201.md" "b/docs/md/biz-arch/\351\253\230\346\200\247\350\203\275\346\216\222\345\220\215\347\263\273\347\273\237\347\232\204\346\240\270\345\277\203\346\236\266\346\236\204\345\216\237\347\220\206\357\274\214\346\236\266\346\236\204\345\270\210\345\277\205\347\234\213\357\274\201.md"
new file mode 100644
index 000000000..733513b4c
--- /dev/null
+++ "b/docs/md/biz-arch/\351\253\230\346\200\247\350\203\275\346\216\222\345\220\215\347\263\273\347\273\237\347\232\204\346\240\270\345\277\203\346\236\266\346\236\204\345\216\237\347\220\206\357\274\214\346\236\266\346\236\204\345\270\210\345\277\205\347\234\213\357\274\201.md"
@@ -0,0 +1,125 @@
+# 高性能排名系统的核心架构原理，架构师必看！
+
+# 简介
+
+Booking.com 利用复杂的排名系统优化每位用户的搜索结果。该系统采用先进的机器学习算法，并充分利用海量数据，包括用户行为、偏好和历史交互记录，为用户量身定制酒店列表和旅行推荐。
+
+本文将带您深入了解支撑多个垂直领域（如住宿、航班等）个性化排名的排名平台架构。
+
+# 排名平台在更广泛生态系统中的位置
+
+以下图表展示了排名平台在更广泛生态系统中的位置概览。为简化说明，图中将多个系统合并为单个模块或省略，只突出了排名平台的作用。
+
+![生态系统概览](https://miro.medium.com/v2/resize:fit:875/1*y7lxlROYNNObGnw7vp-hQQ.jpeg)
+
+一个典型的搜索流程如下：用户通过设备或浏览器发起调用，该调用会经过前端系统（包括微前端和网关），然后到达搜索协调器。核心搜索引擎负责协调搜索流程，并生成用于搜索结果页面和地图的物业列表。这一任务需要与可用性搜索引擎交互，该引擎负责追踪 Booking.com 上 [数千万](https://www.booking.com/content/about.en-gb.html?aid=356980) 物业的可用性数据。由于数据量庞大，可用性搜索引擎采用分片机制以高效处理复杂查询。协调器负责在可用性系统中分配工作负载并汇总结果。
+
+排名平台位于可用性搜索引擎之后，利用机器学习模型对符合搜索条件的物业进行评分。
+
+# 排名平台概览
+
+在深入探讨排名平台的机器学习模型推断之前，我们先简要了解模型创建和部署相关的一些关键组件和工作流程。
+
+**模型创建与部署：总体视图**
+
+![机器学习生态系统概览](https://miro.medium.com/v2/resize:fit:875/1*nu73f61hIeBn3X5kkBOhFA.jpeg)
+
+数据从不同来源（如 OLTP 表、Kafka 流）收集并存储在数据仓库中。机器学习科学家基于这些数据进行探索、预处理、特征工程，并选择合适的算法进行模型训练。在完成模型训练和超参数优化后，科学家会对模型进行离线测试，测试通过后部署以提供实际服务。
+
+模型的特征主要分为以下几类：
+
+1. 静态特征
+2. 动态特征
+    \- 缓慢变化的特征
+    \- 实时特征
+
+静态特征基于历史数据计算一次，在模型训练或推断过程中保持不变。为了保证数据的时效性，这些特征需定期重新计算（如每日、每周或每月）。典型示例包括住宿位置、设施和房型等。
+
+动态特征则随着新数据的出现快速更新。例如当前房价和房间的实时可用性。
+
+图中展示的特征工程部分清晰区分了这两类特征。批量特征是预先计算并存储在特征库中，其更新通过计划的工作流完成；实时特征则基于数据流实时计算并发送至特征库。
+
+任何需要使用机器学习功能的应用程序都通过机器学习平台调用已部署的模型。
+
+## 排名生态系统的扩展视图
+
+在住宿领域，为大量用户对数百万物业进行排名是一个极具挑战的技术任务，需要复杂的算法和强大的计算能力。系统必须高效处理众多变量（如用户偏好、历史行为、物业属性以及实时数据如价格与可用性），并在毫秒级时间内提供个性化推荐，确保推荐结果的相关性和准确性。这种复杂性强调了强大的服务基础设施的重要性，如下图所示。这是之前生态系统图的扩展版本。
+
+![ML 生态系统的扩展版本](https://miro.medium.com/v2/resize:fit:875/1*e6aD1SrxcsZAwnAWI2pM-Q.jpeg)
+
+如图所示，可用性搜索引擎与排名平台的交互分为两次：
+
+1. 从工作器分片处调用，为所有检索到的物业评分。
+2. 在协调器合并各分片的结果后，再次调用以调整最终排序。
+
+排名平台为每个垂直领域或用例（如住宿排名、航班排名、住宿推荐等）提供专门服务。为了简化说明，图中仅保留了住宿排名服务，隐藏了其他服务。此外，排名平台广泛采用持续实验（如交叉排序和 A/B 测试）优化搜索结果。
+
+模型推断由机器学习平台处理，该平台负责跟踪模型、特征及其表现。由于排名的规模庞大，机器学习平台中有一个专用集群服务所有排名相关的机器学习模型，从而确保资源隔离和性能稳定。
+
+# 住宿排名服务设置
+
+以下部分将探讨排名服务的设置以及其关键组件。
+
+![img](https://miro.medium.com/v2/resize:fit:875/1*SMln9f9TGJUYAWc3JSSxrQ.jpeg)
+
+如上图所示，住宿排名服务部署在三个独立的 Kubernetes 集群中。每个集群包含数百个 Pod，用于处理搜索流量。右侧的图表展示了单个 Pod 内的关键组件。除了主要的 Java 服务之外，还有多个基础设施容器共同运行。Java 服务通过 Nginx 接收请求，从分布式缓存中检索特征后调用机器学习平台。分布式缓存在满足严格延迟要求方面至关重要（后文将详细讨论）。
+
+深入分析 Java 服务后，可发现以下组件：
+
+- **Dropwizard Resources**：API 接口端点。
+- **Feature Collector**：从搜索上下文中收集特征，并从分布式缓存中检索静态特征。
+- **Experiment Tracker**：追踪正在运行的实验及其变体模型，确保不同变体生成的结果正确交错。
+- **Model Executor**：将请求分块处理，调用机器学习平台并汇总并行调用的评分结果。
+
+![排名服务内的组件](https://miro.medium.com/v2/resize:fit:875/1*V52zGVoovnQymbKS5YII6w.jpeg)
+
+# 技术挑战
+
+在大规模运营排名系统时，会面临以下技术挑战：
+
+## 位于关键路径中
+
+排名系统位于关键路径，因此需在 99.9% 的情况下（p999）在不到一秒内返回结果。这要求对复杂模型的操作进行深入优化，以满足严格的性能要求。
+
+## 扇出问题
+
+排名系统位于可用性搜索引擎的工作器或分片之后，因此 API 调用数量随着工作器数量的增加而成倍增长。
+
+例如，如果搜索协调器每秒接收 K 个请求，而可用性搜索引擎有 N 个工作器，则排名服务每秒需处理 N * K 个请求。
+
+## 极其多变的负载大小
+
+根据某一地区内物业的密度和搜索范围的大小，待排名的物业数量可能从几十到数千不等。为应对这一挑战，排名服务会将负载拆分为可管理的小块，再向机器学习平台请求推断。这种方法虽能保证推断延迟的稳定性，但也引入了以下复杂性：
+
+- 需要有效管理并行调用以防止内存泄漏。
+- 加剧垃圾回收机制问题。
+- 增加机器学习平台的负载。
+
+# 如何解决这些挑战
+
+## 静态评分回退
+
+当服务因某些原因无法在规定时间内生成评分结果时，系统会回退到物业的静态评分。这些评分是预先计算的，存储于可用性搜索引擎中，并定期更新。尽管这些评分缺乏个性化，但在系统故障时，仍能为用户提供相关性较高的排名结果。
+
+## 多阶段排名
+
+多阶段排名通过将排名过程分解为多个阶段，每个阶段基于不同的标准或参数，从而实现更精确和细化的最终排名。这种方法使系统能够在不同阶段运行复杂程度、个性化水平及性能要求各异的模型。
+
+## 性能优化
+
+我们建立了全面的监控体系以评估各组件性能并持续优化。此外，通过在生产环境中维护镜像设置，处理影子流量，可以运行仅限生产环境的基准测试。
+
+## 模型推断优化
+
+机器学习平台持续优化模型推断以加速运行过程。具体优化技术包括：
+
+- **模型量化**：减少模型复杂性，提高推断速度。
+- **模型剪枝**：删除冗余模型权重以降低计算开销。
+- **硬件加速**：利用专用硬件（如 GPU 或 TPU）提升性能。
+- **推断框架**：采用专门设计的推断框架以优化资源使用。
+
+这些技术在保持模型准确性的同时，显著降低了推断的延迟、内存使用和计算资源消耗。
+
+# 结论
+
+排名平台在 Booking.com 搜索架构的生态系统中占据核心地位。它通过复杂的机器学习模型和排名算法，为用户提供高度个性化的搜索结果。随着技术的不断演进和用户需求的增长，排名平台将继续推动创新，确保为全球用户带来相关性更高、更个性化的搜索体验。
\ No newline at end of file
diff --git a/docs/md/career/mastering-architecture-diagrams.md b/docs/md/career/mastering-architecture-diagrams.md
new file mode 100644
index 000000000..40b420f33
--- /dev/null
+++ b/docs/md/career/mastering-architecture-diagrams.md
@@ -0,0 +1,139 @@
+# 为什么你的架构图总被吐槽？顶尖数据架构师这样绘制！
+
+## 0 前言
+
+如何制作有影响力的技术演示文稿和图表，以精确和故事性的方式有效传达复杂的想法。
+
+上周末，我和一位好友聊起了科技领域的最新动态。虽然他的专业背景不是计算机科学，但他对科技和最新动态非常感兴趣。从新发布的 iPhone 到最新的开放人工智能 o1 模型，我们无所不谈。他随口问我 GPT 是如何工作的，我试着解释，假装自己是专家：)
+
+无论我怎么努力，都无法向他解释清楚。我可以清楚地看到，我正在失去他的注意力，因为他开始专注于他的微信消息。于是我决定画一张图，毕竟俗话说 "一图胜千言"。我打开了 Excalidraw，这是我常用的绘图工具，其超酷的界面能让图表看起来像手绘的一样，我试着用图表向他解释 GPT 架构和 LLM 的工作原理。我很快吸引了他的注意力，他带着丰富的信息（和一堆创业想法离开了；）。
+这让我想到，为什么不把这个想法写进我的下一篇博客呢？
+
+## 1 一图胜千言！
+
+你是否曾发现自己需要快速创建一个架构图来表达对某个概念的理解，或者创建一个有影响力的电梯演讲，但却没有足够的时间来整理思路或选择一个突出的模板，而不是在幻灯片中充斥大量文字？又或者，你脑中有一些原始想法，只是想创建一个思维导图，以便日后参考？
+
+
+你并不孤单！当然，可能有人工智能工具可以提供帮助，但一个出色的演示需要的不仅仅是人工智能！它需要人类的创造力和个人风格。图表也是如此。用图表表达想法的方法数不胜数，但只有最有影响力的才能真正脱颖而出！下面是我在制作演示文稿时遇到的一个极具冲击力的图表：
+
+百视达 DVD 商店显示关闭：
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*aIphz6yz5t4I-v4_Y_b0rQ.jpeg)
+
+对那些不熟悉这个标志的人来说，它属于 Blockbuster，一家曾经在美国很有名气的 DVD 连锁店。每当有新的电影或游戏 DVD 发行时，人们都会蜂拥而至。你可能想知道，这个标志是怎么回事，它与这个话题有什么关系？好吧，如果你还不清楚的话，Blockbuster 已经关闭了大部分门店，现在只剩下俄勒冈州本德的一家。这就说明了一点，好的视觉效果会在受众心中产生持久的影响！
+
+说的够多了！以下是一些我常用的图表制作工具。
+
+### 1 使用 Lucid 绘制思维导图
+
+Lucid 是一款高度直观的基于浏览器的工具，我用它来创建思维导图。它易于浏览，并为 UML 图表、思维导图、流程图等各种用例提供了开箱即用的模板。下面是我在为本博客集思广益时创建的思维导图示例。
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*7Pc-0d9rkAV-vqnXnikVtA.png)
+
+使用 Lucid 创建的思维导图示
+
+###  2 用于手绘图表的 Excalidraw
+
+我经常使用 Excalidraw 绘制概念草图，或者在向别人解释概念时使用。该工具非常直观，提供各种易于使用的功能和插件，可以添加难以手动绘制的形状，如云提供商的架构图标。下面是一个快速示例，展示了图表的外观。
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*ow6_I7NhZwof_mj8bfesbA.png)
+
+使用 Excalidraw 绘制的简单图像
+
+###  3 Draw.io 用于架构图和设计云工作流程
+
+与 Lucid 一样，Draw.io 也提供了一个用于创建流程图的简单网络界面。我经常用它来绘制 AWS 架构图。Draw.io 开箱即提供各种云提供商图标和模板，可以轻松地将它们纳入架构设计中。虽然 Lucid 提供了类似的功能，但我个人更喜欢 Draw.io--这纯粹是个人选择。
+
+###  4 PPT 中的架构图
+
+大多数时候，我在 draw.io 中绘制图表，然后导出为 png 或 jpeg 格式，再导入 PPT。不过，有时这样嵌入的图像分辨率不高，所以我很可能最终还是要在 PPT 本身中构建一些内容。对于云提供商，如果有的话，我会使用他们提供的模板。例如，AWS 在这里提供了模板。我相信其他云提供商可能也有类似的模板。
+
+如果我在不深入研究云服务的情况下构建一个逻辑架构，我很可能会使用 Powerpoint 中的 "形状 "菜单来构建这个架构。
+
+## 2 架构图的设计原则
+
+在绘制技术架构图时，我们需要牢记确保图表清晰、有效并具有视觉吸引力。以下是我通常遵循的一些设计原则：
+
+### 2.1 目的和受众
+
+- 确定目标：了解图表的目的--是用于规划、沟通还是技术验证。可以是高层业务架构、详细系统架构或云基础设施图。
+- 了解你的受众：根据图表的查看对象来调整复杂程度和细节。高管可能更喜欢高层次的视觉效果，而开发人员可能需要更细化的技术细节。
+
+### 2.2 简明
+
+- 避免过于复杂：在传达必要细节的同时，图表应尽可能简单。杂乱无章的图表和过多的动画会让受众感到困惑。
+- 层次和结构：使用逻辑分组和清晰的层次来展示各组件之间的互动。突出最关键的系统和依赖关系。
+- 清晰的标签：确保每个组件、服务或连接都有清晰的标签，并在整个过程中使用一致的术语。
+
+### 2.3 标准化
+
+- 使用既定图标和符号：遵循行业标准图标（如 AWS、Azure 或 GCP 图标）和命名约定，使图表直观易懂。
+- 风格一致：保持图表字体大小、颜色和形状一致。这有助于创建统一和专业的外观。
+
+### 2.4 数据流与连接
+
+- 显示关系和流程：使用箭头、线条或连接器来显示数据、服务或操作的流程。确保数据流的方向直观易懂。
+- 明确边界：对于分布式系统或微服务，应清楚地勾勒出服务边界和网络层。这可确保查看者能够区分内部和外部组件。
+
+最近，我看到了这张出色的架构图，它既直观又易于理解。请注意动画是如何巧妙而周到地使用的，既提高了清晰度，又不会分散注意力。
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/0*vJPqQaBeF8WzSz-u)
+
+图片来源：www.cloudairy.com
+
+注意：架构图应随着系统的发展而发展，因此要对其进行版本控制和更新。寻求反馈并不断改进，以确保你的图表随着时间的推移保持准确性和实用性。
+
+## 3 如何制作有影响力的演示文稿
+
+拥有合适的工具固然重要，但知道如何有效地使用它们才是真正的关键。精心设计的演示不仅仅是视觉效果。它需要以一种能让听众产生共鸣的方式来组织你的信息。就像一部优秀的电影一样，演示文稿需要强有力的叙事。以下是我通常使用的幻灯片结构：
+
+### 3.1 **Title Slide**
+
+重点突出你的关键想法，制作一个引人注目的标题！这是你搭建舞台并给人留下深刻第一印象的机会，因此一个经过深思熟虑的标题可以产生立竿见影的效果。 
+
+### 3.2 快速简历（可选）
+
+如果你是在会议上演讲，或者听众对你并不熟悉，那么加入一张简短的个人简历幻灯片会很有帮助。我喜欢在幻灯片中加入一个有趣的事实来打破僵局，从一开始就建立起可信度。
+
+### 3.3 议程
+
+对演讲内容的快速概述。这可以为听众提供一个路线图，让他们了解接下来要讲的内容，还可以帮助你专注于自己的主题，同时缓解演讲前的紧张情绪。
+
+### 3.4 问题陈述
+
+用一两句话但不要更多，清楚地阐述问题陈述！最好还能配上一张图片！引人入胜、行之有效的演示具有挑战性，尤其是在平衡清晰度、简洁性和视觉吸引力方面。很多人都会掉进幻灯片文字过多的陷阱，导致听众无法参与其中。如比较这两张幻灯片的设计：
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*z9wit4aCge6c9zHB8gvKeg.png)
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*dkVeTYd2QDUWEvwoE6FU3A.png)
+
+两张幻灯片可能包含相似的内容，但哪一张更具有视觉吸引力呢？我们的目标是通过叙述引导受众，保持他们的参与度，并使你的关键点易于理解。
+
+### 3.5 架构图
+
+对于这一步，我会使用前面提到的工具之一。关键是避免在图表中加入过多的技术细节或文字。要保持简洁准确，因为这些图表通常用于解决业务问题或实施技术解决方案，清晰准确至关重要。
+
+### 3.6 解决方案
+
+既然你已经做好了铺垫并提出了问题，现在就是你大显身手的时候了。清楚地介绍你的解决方案，确保它与你概述的问题相关联。
+
+### 3.7 总结
+
+总结所涉及的所有内容，重申解决方案，并提出最后的想法或主要收获。
+
+### 3.8 行动号召
+
+在结束时为受众提供可操作的下一步措施，无论是订阅时事通讯、完成研讨会，还是其他任何能促进参与的措施。
+
+注：虽然动画可以增加价值，但要注意不要过度。此外，使用演讲者注释来记录你的所有谈话要点，而不会使幻灯片本身显得杂乱无章。
+
+作为参考，这是我最近准备的关于加州大学伯克利分校[Masters in Data Science](https://ischoolonline.berkeley.edu/data-science/)课程的 [presentation](https://docs.google.com/presentation/d/1k9FBq4JxAMXDfon4MG1ucWEzJzzanydRsut7eHVdj7E/edit?usp=sharing)，其中涵盖了我上面讨论的幻灯片设计的一些方面。它可能没有涵盖所有方面，但你会明白其中的含义。
+
+## 4 结论
+
+因此，制作有影响力的演示文稿和架构图不仅仅是拼凑幻灯片或画框，更重要的是制作出能引起受众共鸣的叙述。发挥想象力，创造性地表达自己！
+
+无论是解释技术架构还是介绍解决方案，你的幻灯片都应该强化你的信息，而不是压倒它。有了深思熟虑的设计和清晰的结构，你就能引导受众了解你的故事，留下深刻的印象！
+
+
+请记住，一个出色的演示不仅能提供信息，还能激发行动！
\ No newline at end of file
diff --git a/docs/md/design/measuring-technical-debt.md b/docs/md/design/measuring-technical-debt.md
new file mode 100644
index 000000000..3d9f8ef82
--- /dev/null
+++ b/docs/md/design/measuring-technical-debt.md
@@ -0,0 +1,92 @@
+# 技术债正在悄悄拖垮你的团队！
+
+## 0 前言
+
+软件开发的核心在于应对变化。在软件的生命周期中，目标是能够在合理的时间内实施必要的更改。不管这些更改是技术性的，比如紧急安全升级，还是业务需求所驱动的，比如开发新功能以在目标市场中更具竞争力——能否快速应对变化是成败的关键。
+
+是什么让我们慢下来？通常，这是因为让某个功能能够运行并不等于让它在长期内具备良好的可维护性（参考 [Google 软件工程实践](https://abseil.io/resources/swe-book/html/ch01.html)）。第一个可运行版本通常是快速而粗糙的，而让其具备可修改性则需要额外的努力。这引出了“技术债务”的隐喻（参考 [Ward 的解释](http://wiki.c2.com/?WardExplainsDebtMetaphor)）。开发人员选择暂时不投资于代码的可变更性，而是承受技术债务，以便更快完成任务。之后，每次修改代码都需要支付额外的“利息”，直到技术债务彻底清偿。
+
+## 1 啥是技术债？
+
+技术债务是指当前软件状态与最适合于轻松实现更改的目标状态之间的差距。在某些情况下，积累技术债务可能是值得的——例如，为了满足一个硬性截止日期，否则整个项目可能停滞不前。但从长远来看，采取措施来控制和减少技术债务无疑是明智的（参考 [Fowler 的文章](https://martinfowler.com/articles/is-quality-worth-cost.html)）。
+
+对于寿命预计以年为单位的软件来说，是否偿还技术债务并不是问题。问题在于如何识别、衡量和管理它。
+
+技术债务可能有不同的来源。例如，团队可能对技术债务引发的问题缺乏认识；或者，尽管意识到问题存在，但误以为永远没有时间解决。这与工程文化密切相关。随着时间推移，问题只会越来越严重（参考 [破窗理论](https://en.wikipedia.org/wiki/Broken_windows_theory)）。另一种情况是，团队在权衡利弊后，有意积累技术债务。第三种情况则是因为我们无法事先掌握所有信息，需求可能变化，而开发过程中会逐步学习。这种债务即使对于最优秀的团队来说也不可避免（参考 [Fowler 的技术债务象限](https://martinfowler.com/bliki/TechnicalDebtQuadrant.html)）。
+
+技术债务的棘手之处在于，它通过不断做出小的妥协而逐渐积累。为了短期的便利和简单而牺牲长期的结果，被称为“温水煮青蛙隐喻”。换句话说，问题会逐渐积累，直到灾难发生为止。我们如何防止这种情况的发生？
+
+应对技术债务的最佳防御措施是从一开始就使其可见。然后，我们可以通过设立适当的健康指标，并尽早采取纠正措施来主动管理它。
+
+另一方面，如果我们的系统已经因为技术债务濒临崩溃，那就需要采取更激进的“清理”措施——在为时已晚之前。在这种情况下，建议建立多个改进指标，并使用它们来跟踪这些措施的进展。
+
+## 2 WTFs 每分钟
+
+一个广泛认可的观点是，代码质量的唯一有效衡量指标是**每分钟 WTF 次数**（参考 [Martin 的《代码整洁之道》](https://learning.oreilly.com/library/view/clean-code-a/9780136083238/intro.xhtml#:-:text=Introduction)）。或许可以开发一款设备，专门用来统计 WTF 次数，这或许会成为一个不错的创业点子？
+
+当然，这个指标既主观又依赖于开发者的技术水平及团队的工程文化。根据[破窗理论](https://en.wikipedia.org/wiki/Broken_windows_theory)，糟糕的代码越多，就越会鼓励开发人员继续制造技术债务。
+
+## 3 代码异味的数量
+
+Martin Fowler 和 Kent Beck 引入了“[代码异味](https://martinfowler.com/bliki/CodeSmell.html)”这一概念，帮助开发者识别代码中可能存在问题的地方。Fowler 的《[重构](https://learning.oreilly.com/library/view/refactoring-improving-the/9780134757681/ch03.xhtml#ch03lev1sec1)》一书列举了 24 个代码异味示例。Uncle Bob 的《代码整洁之道》中也包含了许多代码异味和启发式规则（参考《[代码整洁之道》第17章](https://learning.oreilly.com/library/view/clean-code-a/9780136083238/chapter17.xhtml#:-:text=Smells and Heuristics)）。一些代码异味，如重复代码和过长函数，可以通过静态分析工具（如 [SonarQube](https://docs.sonarqube.org/9.6/user-guide/concepts/#:~:text=Code smell,errors as they make changes.)）轻松检测。然而，许多代码异味无法通过静态工具轻松发现。这也是为什么需要像“每分钟 WTF 次数”这样的另一个指标。
+
+## 4 自动化测试覆盖率
+
+尽管早在[《Google 软件工程实践》](https://abseil.io/resources/swe-book/html/ch11.html#:~:text=We have a name for,changes across the entire codebase.)、《代码整洁之道》](https://learning.oreilly.com/library/view/clean-coder-the/9780132542913/ch01.xhtml#:-:text=Am I suggesting,be tested. Period.) 等书中提到过自动化测试的重要性，最近的研究（例如《[Accelerate](https://learning.oreilly.com/library/view/accelerate/9781457191435/)》和 [DORA 研究](https://dora.dev/)）表明，测试自动化与软件生产力之间存在统计上的正相关。这表明，提高自动化测试覆盖率通常可以显著提升团队的生产力。
+
+![](https://miro.medium.com/v2/resize:fit:875/0*C9VcJJnfiqUrsYkQ)
+
+可以通过许多工具（例如 [JaCoCo](https://www.eclemma.org/jacoco/#:~:text=JaCoCo is a free code,existing libraries for many years.)）来追踪这个指标。但如同许多其他指标一样，它也容易被“造假”，比如编写大量实际上并未测试任何内容的测试。因此，结合其他努力来提升团队技能，并阐明编写自测试代码的好处是非常重要的——比如 Google 推行的[厕所上的测试](https://testing.googleblog.com/2007/01/introducing-testing-on-toilet.html)。
+
+当测试自动化覆盖率较低成为限制团队进步的因素时，这一指标尤为有效。例如，我的团队曾发现某个遗留组件的测试自动化覆盖率非常低（仅约50%）。因此，我们将提高该覆盖率作为优先事项。通过持续监控指标、在团队回顾会议上讨论进展，我们在一年内将单元测试覆盖率提升至80%，并且不再视其为限制因素。现在，我们将其作为代码库健康的一个重要指标。
+
+## 5 文档覆盖率
+
+文档不足可能对团队效率产生负面影响。因此，我们可以采用一个与文档覆盖率相关的指标：
+
+**文档覆盖率**：系统中文档覆盖部分占总系统的百分比。
+
+如何使用这个指标？在文档不足被视为制约因素的团队中，可以优先改善这一问题。我们列出所有组件，并评估每个组件当前的文档覆盖情况。每周更新指标，并监控改进进展。
+
+## 6 用在弃用组件上的精力
+
+在一些情况下，为了支持新的组件，我们需要弃用旧组件，但在一段时间内仍然不得不保留这些组件。例如，有些客户端需要时间完成迁移。在此期间，我们仍可能需要对这些弃用组件进行工作，比如修复漏洞。由于这些弃用组件最终会被移除，这种工作实际上是一种浪费。问题是，团队往往会“忘记”这些弃用组件，继续对它们提供支持。随着时间推移，这些工作会不断积累，甚至可能成为团队的主要限制因素之一。因此，跟踪弃用组件并尽早废止它们是非常重要的。
+
+可以采用以下指标：
+
+- **弃用组件工作的比例** = 用在弃用组件上的时间 / 总时间
+- **弃用组件工作的比例** = 与弃用组件相关的任务数 / 总任务数
+- **弃用变更比例** = 弃用组件的变更数 / 总变更数
+
+如何使用这些指标？例如，我的团队负责一个覆盖 200 多个国家的住宿合作伙伴门户中与发票相关的财务内容。去年，我们开发了一个新的发票展示页面，并在几乎所有国家推出。然而，由于一些国家有特定逻辑，我们决定暂时保留旧页面以便后续迁移。这一决定让我们可以更快地获得新页面的反馈。然而，这也导致我们在几个月内需要支持多个版本的页面。尽管旧页面的支持工作量不大，但累积效应可能会显著增加负担。在这种情况下，我们将这一指标作为改进和健康监控的重要工具。
+
+## 7 用于修复用户发现缺陷的工作量
+
+软件中的缺陷显然会减缓功能开发的进度。因此，这些缺陷可以被视为技术债务的一部分。
+
+我们可以使用以下指标来量化相关工作量：
+
+- **%修复缺陷的工作量** = 修复缺陷所花的时间 / 总时间
+- **%修复缺陷的工作量** = 缺陷数量 / 总任务数量
+
+## 8 漏洞的数量
+
+在 [OWASP Top Ten](https://owasp.org/www-project-top-ten/) 网络应用安全风险列表中，“漏洞和过时组件”被列为其中之一。这些问题可能导致紧急计划外工作，来修复漏洞和应对后果。因此，漏洞可以被视为技术债务的一部分。
+
+我们可以使用工具 [Dependency-Check](https://owasp.org/www-project-dependency-check/) 来检查项目中的依赖项。将该工具集成到 CI/CD 流水线中是广泛认可的最佳实践。这种方法可以帮助我们尽早发现并修复漏洞或过时组件，从而减少技术债务带来的潜在影响。
+
+## 9 清偿技术债务所需的估计工作量
+
+有些导致团队效率降低的问题无法通过静态分析工具轻松追踪。例如，共享数据库架构或其他复杂的架构问题，通常难以用工具直接衡量。每个团队都会面临其独特的技术债务挑战，因此解决方法也会有所不同。
+
+最简单的衡量方式可能是估算清偿技术债务所需的工作量。然而，这种估算需要团队具备足够的技能和经验，例如掌握设计模式、重构技巧、自测试代码的编写，甚至是架构最佳实践（如松耦合架构）等。通过结合这些能力，我们可以更准确地评估并应对技术债务。
+
+## 10 关键总结
+
+- 技术债务是指当前软件状态与最适合轻松实现更改的目标状态之间的差距。
+- 在几乎所有情况下，保持技术债务处于较低水平是非常重要的。如果忽视它，每次修改代码时都会付出额外的努力。
+- 技术债务的来源包括：(i) 团队对其危害缺乏认识；(ii) 在权衡利弊后有意选择积累技术债务；(iii) 由于信息不完整，随着开发过程中的学习和需求变化不可避免地产生的债务。
+- 技术债务往往通过无数次小的妥协逐渐积累，最终可能导致严重后果。
+- 最好的实践是从一开始就让技术债务变得可见，并通过设置健康指标进行监控，在早期采取纠正措施。
+- 如果发现技术债务已经威胁到系统的正常运行，则需要采取更加激进的清理措施。在这种情况下，可以通过设立改进指标并定期跟踪进展来评估和调整清理策略。
+- 各团队可以使用多种指标来衡量技术债务的健康状况和改进效果，例如 WTFs 每分钟、代码异味数量、漏洞数量、测试覆盖率、文档覆盖率，以及用于弃用组件、计划外工作、修复缺陷的工作量和清偿技术债务的估算工作量。这些指标并非唯一选择，团队可以根据自身需求设计更合适的指标。
\ No newline at end of file
diff --git "a/docs/md/design/\346\236\266\346\236\204\345\270\210\346\225\231\344\275\240kill\347\245\226\344\274\240\347\237\263\345\261\261\344\273\243\347\240\201\351\207\215\345\244\215&\345\244\247\351\207\217ifelse.md" "b/docs/md/design/\346\236\266\346\236\204\345\270\210\346\225\231\344\275\240kill\347\245\226\344\274\240\347\237\263\345\261\261\344\273\243\347\240\201\351\207\215\345\244\215&\345\244\247\351\207\217ifelse.md"
new file mode 100644
index 000000000..28c7d2472
--- /dev/null
+++ "b/docs/md/design/\346\236\266\346\236\204\345\270\210\346\225\231\344\275\240kill\347\245\226\344\274\240\347\237\263\345\261\261\344\273\243\347\240\201\351\207\215\345\244\215&\345\244\247\351\207\217ifelse.md"
@@ -0,0 +1,428 @@
+# 架构师教你kill祖传石山代码重复&大量ifelse
+
+本文就教你如何优雅消除重复代码并改变你对业务代码没技术含量的观念。
+
+## 1 crud 工程师之“痛”
+
+很多 crud 工程师抱怨业务开发没有技术含量，什么设计模式、高并发都用不到，就是堆CRUD。每次面试被问到“讲讲常用设计模式？”，都只能把单例讲到精通，其他设计模式即使听过也只会简单说说，因为根本没实际用过。
+对于反射、注解，也只是知道在框架中用的很多，但自己又不写框架，更不知道该如何使用。
+
+- 设计模式是世界级软件大师在大型项目的经验所得，是被证实利于维护大型项目的。
+- 反射、注解、泛型等高级特性在框架被大量使用，是因为框架往往需要以同一套算法应对不同数据结构，而这些特性可以帮助减少重复代码，也是利于维护。
+
+提升项目的可维护性是每个 coder 必须注意的，非常重要的一个手段就是减少代码重复，因为重复过多会导致：
+
+- 容易修改一处忘记修改另一处，造成Bug
+- 有一些代码并非完全重复，而是相似度高，修改这些类似的代码容易改（cv）错，把原本有区别的地方改成一样
+
+## 2 工厂+模板方法模式
+
+消除多if和重复代码！
+
+### 2.1 需求
+
+开发购物车下单，对不同用户不同处理：
+
+- 普通用户需要收取运费，运费是商品价格的10%，无商品折扣
+- VIP用户同样需要收取商品价格10%的快递费，但购买两件以上相同商品时，第三件开始享受一定折扣
+- 内部用户可以免运费，无商品折扣
+
+实现三种类型的购物车业务逻辑，把入参Map对象（K：商品ID，V：商品数量），转换为出参购物车类型Cart。
+
+###  2.2 菜鸟实现
+
+- 购物车
+  ![](https://img-blog.csdnimg.cn/20201025224823758.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_1,color_FFFFFF,t_70#pic_center)
+
+- 购物车中的商品
+  ![](https://img-blog.csdnimg.cn/20201025225037879.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_1,color_FFFFFF,t_70#pic_center)
+
+### 2.2.1 普通用户
+
+![](https://img-blog.csdnimg.cn/20201025230743632.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_1,color_FFFFFF,t_70#pic_center)
+
+
+### 2.2.2 VIP用户
+
+VIP用户能享受同类商品多买的折扣。只需额外处理多买折扣部分。
+![](https://img-blog.csdnimg.cn/20201025231001596.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_1,color_FFFFFF,t_70#pic_center)
+
+### 2.2.3 内部用户
+
+免运费、无折扣，只处理商品折扣和运费时的逻辑差异。
+![](https://img-blog.csdnimg.cn/20201025231120780.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_1,color_FFFFFF,t_70#pic_center)
+
+**三种购物车超过一半代码重复。**
+虽然不同类型用户计算运费和优惠的方式不同，但整个购物车的初始化、统计总价、总运费、总优惠和支付价格逻辑都一样。
+
+**代码重复本身不可怕，可怕的是漏改或改错**。
+比如，写VIP用户购物车的同学发现商品总价计算有Bug，不应该是把所有Item的price加在一起，而是应该把所有Item的`price*quantity`相加。
+他可能只修VIP用户购物车的代码，漏了普通用户、内部用户的购物车中重复逻辑实现的相同Bug。
+
+有三个购物车，就需根据不同用户类型使用不同购物车。
+
+- 使用多if实现不同类型用户调用不同购物车process
+- ![](https://img-blog.csdnimg.cn/20201025231313298.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_1,color_FFFFFF,t_70#pic_center)
+
+就只能不断增加更多的购物车类，写重复的购物车逻辑、写更多if逻辑吗？
+当然不是，**相同的代码应该只在一处出现**！
+
+### 2.3 重构秘技 - 模板方法模式
+
+可以把重复逻辑定义在抽象类，三个购物车只要分别实现不同部分的逻辑。
+这其实就是**模板方法模式**。
+在父类中实现购物车处理的流程模板，然后把需要特殊处理的留抽象方法定义，让子类去实现。由于父类逻辑无法单独工作，因此需要定义为抽象类。
+
+如下代码所示，AbstractCart抽象类实现了购物车通用的逻辑，额外定义了两个抽象方法让子类去实现。其中，processCouponPrice方法用于计算商品折扣，processDeliveryPrice方法用于计算运费。
+![](https://img-blog.csdnimg.cn/20201025231522267.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_1,color_FFFFFF,t_70#pic_center)
+
+
+有抽象类，三个子类的实现就简单了。
+
+- 普通用户的购物车NormalUserCart，实现0优惠和10%运费
+  ![](https://img-blog.csdnimg.cn/2020102523161665.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_1,color_FFFFFF,t_70#pic_center)
+
+- VIP用户的购物车VipUserCart，直接继承NormalUserCart，只需修改多买优惠策略
+  ![](https://img-blog.csdnimg.cn/20201025231840673.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_1,color_FFFFFF,t_70#pic_center)
+
+- 内部用户购物车InternalUserCart最简单，直接设置0运费、0折扣
+  ![](https://img-blog.csdnimg.cn/20201025231929708.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_1,color_FFFFFF,t_70#pic_center)
+
+### 抽象类和三个子类的实现关系图
+
+![](https://img-blog.csdnimg.cn/20201025205252522.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_1,color_FFFFFF,t_70#pic_center)
+
+### 2.4 重构秘技之工厂模式 - 消除多if
+
+既然三个购物车都叫`XXXUserCart`，可将用户类型字符串拼接`UserCart`构成购物车Bean的名称，然后利用IoC容器，通过Bean的名称直接获取到AbstractCart，调用其process方法即可实现通用。
+
+这就是工厂模式，借助Spring容器实现：
+![](https://img-blog.csdnimg.cn/20201025232047710.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_1,color_FFFFFF,t_70#pic_center)
+
+若有新用户类型、用户逻辑，只要新增一个XXXUserCart类继承AbstractCart，实现特殊的优惠和运费处理逻辑即可。
+
+工厂+模板方法模式，消除了重复代码，还避免修改既有代码。这就是设计模式中的OCP：对修改关闭，对扩展开放。
+
+## 3 注解+反射消除重复代码
+
+### 3.1 需求
+
+银行提供了一些API接口，对参数的序列化不使用JSON，而需要我们把参数依次拼在一起构成一个大字符串。
+
+- 按照银行提供的API文档的顺序，把所有参数构成定长的数据，然后拼接在一起作为整个字符串
+- 因为每种参数都有固定长度，未达到长度时需填充：
+  - 字符串类型的参数不满长度部分需要以下划线右填充，也就是字符串内容靠左
+  - 数字类型的参数不满长度部分以0左填充，也就是实际数字靠右
+  - 货币类型的表示需要把金额向下舍入2位到分，以分为单位，作为数字类型同样进行左填充。
+    对所有参数做MD5操作作为签名（为了方便理解，Demo中不涉及加盐处理）。
+
+比如，创建用户方法和支付方法的定义是这样的：
+
+![](https://img-blog.csdnimg.cn/20201025211145124.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_16,color_FFFFFF,t_70#pic_center)
+
+![](https://img-blog.csdnimg.cn/20201025211155432.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_16,color_FFFFFF,t_70#pic_center)
+
+### 3.2 菜鸟实现
+
+直接根据接口定义实现填充、加签名、请求调用：
+
+```java
+public class BankService {
+
+    // 创建用户
+    public static String createUser(String name, String identity, String mobile, int age) throws IOException {
+        StringBuilder stringBuilder = new StringBuilder();
+        // 字符串靠左，多余的地方填充_
+        stringBuilder.append(String.format("%-10s", name).replace(' ', '_'));
+        stringBuilder.append(String.format("%-18s", identity).replace(' ', '_'));
+        // 数字靠右，多余的地方用0填充
+        stringBuilder.append(String.format("%05d", age));
+        // 字符串靠左
+        stringBuilder.append(String.format("%-11s", mobile).replace(' ', '_'));
+        // MD5签名
+        stringBuilder.append(DigestUtils.md2Hex(stringBuilder.toString()));
+        return Request.Post("http://localhost:45678/reflection/bank/createUser")
+                .bodyString(stringBuilder.toString(), ContentType.APPLICATION_JSON)
+                .execute().returnContent().asString();
+    }
+    
+    // 支付
+    public static String pay(long userId, BigDecimal amount) {
+        StringBuilder sb = new StringBuilder();
+        // 数字靠右
+        sb.append(String.format("%020d", userId));
+        // 金额向下舍入2位到分，以分为单位，作为数字靠右，多余的地方用0填充
+        sb.append(String.format("%010d", amount.setScale(2, RoundingMode.DOWN).multiply(new BigDecimal("100")).longValue()));
+        // MD5签名
+        sb.append(DigestUtils.md2Hex(stringBuilder.toString()));
+        return Request.Post("http://localhost:45678/reflection/bank/pay")
+                .bodyString(sb.toString(), ContentType.APPLICATION_JSON)
+                .execute().returnContent().asString();
+    }
+}
+```
+
+这段代码的重复粒度更细：
+
+- 三种标准数据类型的处理逻辑有重复
+- 处理流程中字符串拼接、加签和发请求的逻辑，在所有方法重复
+- 实际方法的入参的参数类型和顺序，不一定和接口要求一致，容易出错
+- 代码层面针对每一个参数硬编码，无法清晰地进行核对，如果参数达到几十个、上百个，出错的概率极大。
+
+### 3.3 重构之自定义注解&反射
+
+针对银行请求的所有逻辑均使用一套代码实现，不会出现任何重复。
+
+要实现接口逻辑和逻辑实现的剥离，首先要以POJO类定义所有的接口参数。
+
+- 创建用户API的参数
+
+```java
+@Data
+public class CreateUserAPI {
+    private String name;
+    private String identity;
+    private String mobile;
+    private int age;
+}
+```
+
+有了接口参数定义，就能自定义注解，为接口和所有参数增加一些元数据。如定义一个接口API的注解BankAPI，包含接口URL地址和接口说明
+
+```java
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+@Documented
+@Inherited
+public @interface BankAPI {
+    String desc() default "";
+
+    String url() default "";
+}
+```
+
+再自定义注解`@BankAPIField`，描述接口的每一个字段规范，包含参数的次序、类型和长度三个属性：
+
+```java
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+@Documented
+@Inherited
+public @interface BankAPIField {
+
+    /**
+     * 参数的次序
+     * @return
+     */
+    int order() default -1;
+
+    /**
+     * 长度
+     * @return
+     */
+    int length() default -1;
+
+    /**
+     * 类型
+     * @return
+     */
+    String type() default "";
+}
+```
+
+定义`CreateUserAPI`描述创建用户接口的信息，为接口增加@BankAPI，来补充接口的URL和描述等元数据；为每个字段增加@BankAPIField，来补充参数的顺序、类型和长度等元数据：
+
+```java
+@BankAPI(url = "/bank/createUser", desc = "创建用户接口")
+@Data
+public class CreateUserAPI extends AbstractAPI {
+    @BankAPIField(order = 1, type = "S", length = 10)
+    private String name;
+    @BankAPIField(order = 2, type = "S", length = 18)
+    private String identity;
+    @BankAPIField(order = 4, type = "S", length = 11)
+    private String mobile;
+    @BankAPIField(order = 3, type = "N", length = 5)
+    private int age;
+}
+```
+
+类似的PayAPI类：
+
+```java
+@BankAPI(url = "/bank/pay", desc = "支付接口")
+@Data
+public class PayAPI extends AbstractAPI {
+    @BankAPIField(order = 1, type = "N", length = 20)
+    private long userId;
+    @BankAPIField(order = 2, type = "M", length = 10)
+    private BigDecimal amount;
+}
+```
+
+他俩继承的AbstractAPI类是空实现，因为该例接口无公共数据。
+
+```java
+public abstract class AbstractAPI {
+
+}
+```
+
+通过这俩类，即可快速核对API清单表格。若核心翻译过程（把注解和接口API序列化为请求需要的字符串）没问题，只要注解和表格一致，API请求翻译就没问题。这就通过注解实现了对API参数的描述。
+
+下面看反射咋配合注解实现动态的接口参数组装：
+
+```java
+private static String remoteCall(AbstractAPI api) throws IOException {
+    // 从类上获得 @BankAPI，获其URL属性以远程调用
+    BankAPI bankAPI = api.getClass().getAnnotation(BankAPI.class);
+    bankAPI.url();
+    StringBuilder stringBuilder = new StringBuilder();
+    // 使用stream快速实现，并把字段按order属性排序，然后设置私有字段反射可访问
+    Arrays.stream(api.getClass().getDeclaredFields()) //获得所有字段
+	    	     // 过滤带 @BankAPIField 的字段
+            .filter(field -> field.isAnnotationPresent(BankAPIField.class))
+            // 根据注解的order属性，对字段排序
+            .sorted(Comparator.comparingInt(a -> a.getAnnotation(BankAPIField.class).order()))
+      			 // 设置可访问私有字段	
+            .peek(field -> field.setAccessible(true))
+            .forEach(field -> {
+            	// 实现了反射获取注解的值，然后根据BankAPIField拿到的参数类型，按照三种标准进行格式化，将所有参数的格式化逻辑集中在了这一处
+                // 获得注解
+                BankAPIField bankAPIField = field.getAnnotation(BankAPIField.class);
+                Object value = "";
+                try {
+                    // 反射获取字段值
+                    value = field.get(api);
+                } catch (IllegalAccessException e) {
+                    e.printStackTrace();
+                }
+                // 根据字段类型以正确的填充方式格式化字符串
+                switch (bankAPIField.type()) {
+                    case "S": {
+                        stringBuilder.append(String.format("%-" + bankAPIField.length() + "s", value.toString()).replace(' ', '_'));
+                        break;
+                    }
+                    case "N": {
+                        stringBuilder.append(String.format("%" + bankAPIField.length() + "s", value.toString()).replace(' ', '0'));
+                        break;
+                    }
+                    case "M": {
+                        if (!(value instanceof BigDecimal))
+                            throw new RuntimeException(String.format("{} 的 {} 必须是BigDecimal", api, field));
+                        stringBuilder.append(String.format("%0" + bankAPIField.length() + "d", ((BigDecimal) value).setScale(2, RoundingMode.DOWN).multiply(new BigDecimal("100")).longValue()));
+                        break;
+                    }
+                    default:
+                        break;
+                }
+            });
+    // 实现参数加签和请求调用
+    // 签名逻辑stringBuilder.append(DigestUtils.md2Hex(stringBuilder.toString()));
+    String param = stringBuilder.toString();
+    long begin = System.currentTimeMillis();
+    // 请求
+    String result = Request.Post("http://localhost:45678/reflection" + bankAPI.url())
+            .bodyString(param, ContentType.APPLICATION_JSON)
+            .execute().returnContent().asString();
+    return result;
+}
+```
+
+所有处理参数排序、填充、加签、请求调用的核心逻辑，都汇聚在`remoteCall`。有这方法，BankService每个接口实现就简单了：参数组装，再调用remoteCall。
+
+![](https://img-blog.csdnimg.cn/2020102523304434.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_1,color_FFFFFF,t_70#pic_center)
+
+涉及类结构性的通用处理，都可按照该模式减少重复代码：
+
+- 反射使我们在不知类结构时，按固定逻辑处理类成员
+- 注解给我们为这些成员补充元数据的能力，使我们利用反射实现通用逻辑时，可从外部获得更多关心的数据
+
+## 4  属性拷贝
+
+对于三层架构系统，层间解耦及每层对数据的不同需求，每层都会有自己的POJO实体。
+手动写这些实体之间的赋值代码，容易出错。对于复杂业务系统，实体有几十甚至几百个属性也很正常。比如ComplicatedOrderDTO，描述一个订单中几十个属性。如果转换为一个类似的DO，复制其中大部分的字段，然后把数据入库，势必需要进行很多属性映射赋值操作。就像这样，密密麻麻的代码是不是已经让你头晕了？
+
+```java
+ComplicatedOrderDTO orderDTO = new ComplicatedOrderDTO();
+ComplicatedOrderDO orderDO = new ComplicatedOrderDO();
+orderDO.setAcceptDate(orderDTO.getAcceptDate());
+orderDO.setAddress(orderDTO.getAddress());
+orderDO.setAddressId(orderDTO.getAddressId());
+orderDO.setCancelable(orderDTO.isCancelable());
+orderDO.setCommentable(orderDTO.isComplainable()); //属性错误
+orderDO.setComplainable(orderDTO.isCommentable()); //属性错误
+orderDO.setCancelable(orderDTO.isCancelable());
+orderDO.setCouponAmount(orderDTO.getCouponAmount());
+orderDO.setCouponId(orderDTO.getCouponId());
+orderDO.setCreateDate(orderDTO.getCreateDate());
+orderDO.setDirectCancelable(orderDTO.isDirectCancelable());
+orderDO.setDeliverDate(orderDTO.getDeliverDate());
+orderDO.setDeliverGroup(orderDTO.getDeliverGroup());
+orderDO.setDeliverGroupOrderStatus(orderDTO.getDeliverGroupOrderStatus());
+orderDO.setDeliverMethod(orderDTO.getDeliverMethod());
+orderDO.setDeliverPrice(orderDTO.getDeliverPrice());
+orderDO.setDeliveryManId(orderDTO.getDeliveryManId());
+orderDO.setDeliveryManMobile(orderDO.getDeliveryManMobile()); //对象错误
+orderDO.setDeliveryManName(orderDTO.getDeliveryManName());
+orderDO.setDistance(orderDTO.getDistance());
+orderDO.setExpectDate(orderDTO.getExpectDate());
+orderDO.setFirstDeal(orderDTO.isFirstDeal());
+orderDO.setHasPaid(orderDTO.isHasPaid());
+orderDO.setHeadPic(orderDTO.getHeadPic());
+orderDO.setLongitude(orderDTO.getLongitude());
+orderDO.setLatitude(orderDTO.getLongitude()); //属性赋值错误
+orderDO.setMerchantAddress(orderDTO.getMerchantAddress());
+orderDO.setMerchantHeadPic(orderDTO.getMerchantHeadPic());
+orderDO.setMerchantId(orderDTO.getMerchantId());
+orderDO.setMerchantAddress(orderDTO.getMerchantAddress());
+orderDO.setMerchantName(orderDTO.getMerchantName());
+orderDO.setMerchantPhone(orderDTO.getMerchantPhone());
+orderDO.setOrderNo(orderDTO.getOrderNo());
+orderDO.setOutDate(orderDTO.getOutDate());
+orderDO.setPayable(orderDTO.isPayable());
+orderDO.setPaymentAmount(orderDTO.getPaymentAmount());
+orderDO.setPaymentDate(orderDTO.getPaymentDate());
+orderDO.setPaymentMethod(orderDTO.getPaymentMethod());
+orderDO.setPaymentTimeLimit(orderDTO.getPaymentTimeLimit());
+orderDO.setPhone(orderDTO.getPhone());
+orderDO.setRefundable(orderDTO.isRefundable());
+orderDO.setRemark(orderDTO.getRemark());
+orderDO.setStatus(orderDTO.getStatus());
+orderDO.setTotalQuantity(orderDTO.getTotalQuantity());
+orderDO.setUpdateTime(orderDTO.getUpdateTime());
+orderDO.setName(orderDTO.getName());
+orderDO.setUid(orderDTO.getUid());
+```
+
+如果原始的DTO有100个字段，我们需要复制90个字段到DO中，保留10个不赋值，最后应该如何校验正确性呢？
+
+- 数数吗？即使数出有90行代码，也不一定正确，因为属性可能重复赋值
+- 有时字段名相近，比如complainable和commentable，容易搞反
+- 对两个目标字段重复赋值相同的来源字段
+- 明明要把DTO的值赋值到DO中，却在set的时候从DO自己取值，导致赋值无效
+
+使用类似`BeanUtils`这种Mapping工具来做Bean的转换，`copyProperties`方法还允许我们提供需要忽略的属性：
+
+![](https://img-blog.csdnimg.cn/20201025233148273.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_1,color_FFFFFF,t_70#pic_center)
+
+## 5 总结
+
+重复代码多了总有一天会出错。
+
+- 有多个并行的类实现相似的代码逻辑
+  考虑提取相同逻辑在父类中实现，差异逻辑通过抽象方法留给子类实现。使用类似的模板方法把相同的流程和逻辑固定成模板，保留差异的同时尽可能避免代码重复。同时，可以使用Spring的IoC特性注入相应的子类，来避免实例化子类时的大量if…else代码。
+
+- 使用硬编码的方式重复实现相同的数据处理算法
+  考虑把规则转换为自定义注解，作为元数据对类或对字段、方法进行描述，然后通过反射动态读取这些元数据、字段或调用方法，实现规则参数和规则定义的分离。也就是说，把变化的部分也就是规则的参数放入注解，规则的定义统一处理。
+
+- 业务代码中常见的DO、DTO、VO转换时大量字段的手动赋值，遇到有上百个属性的复杂类型，非常非常容易出错
+  不要手动进行赋值，考虑使用Bean映射工具进行。此外，还可以考虑采用单元测试对所有字段进行赋值正确性校验。
+
+代码重复度是评估一个项目质量的重要指标，如果一个项目几乎没有任何重复代码，那么它内部抽象一定非常好。重构时，首要任务是消除重复。
+
+参考：
+
+- 《重构》
+- 搞定代码重复的三个绝招
+- https://blog.csdn.net/qq_32447301/article/details/107774036
\ No newline at end of file
diff --git "a/docs/md/distdb/03-BASE \350\277\230\350\203\275\346\222\221\345\244\232\344\271\205\357\274\237\345\274\272\344\270\200\350\207\264\346\200\247\346\211\215\346\230\257\344\272\213\345\212\241\345\244\204\347\220\206\347\232\204\347\273\210\346\236\201\345\245\245\344\271\211\357\274\201.md" "b/docs/md/distdb/03-BASE \350\277\230\350\203\275\346\222\221\345\244\232\344\271\205\357\274\237\345\274\272\344\270\200\350\207\264\346\200\247\346\211\215\346\230\257\344\272\213\345\212\241\345\244\204\347\220\206\347\232\204\347\273\210\346\236\201\345\245\245\344\271\211\357\274\201.md"
new file mode 100644
index 000000000..ef3e7bac7
--- /dev/null
+++ "b/docs/md/distdb/03-BASE \350\277\230\350\203\275\346\222\221\345\244\232\344\271\205\357\274\237\345\274\272\344\270\200\350\207\264\346\200\247\346\211\215\346\230\257\344\272\213\345\212\241\345\244\204\347\220\206\347\232\204\347\273\210\346\236\201\345\245\245\344\271\211\357\274\201.md"	
@@ -0,0 +1,218 @@
+# 03-BASE 还能撑多久？强一致性才是事务处理的终极奥义！
+
+## 0 前言
+
+分布式数据库“强一致性”包括数据一致性、事务一致性两个方面。本文谈事务一致性。
+
+有人说ACID落伍，BASE为理论基础NoSQL才是主流。BASE是很宽泛定义，承诺有限。BASE意义只在放弃ACID的一些特性，从而更简单实现高性能和可用性，达到一个新平衡。但架构设计平衡往往是阶段性，随新技术突破，原平衡点也自然改变。不说分布式数据库，就连NoSQL也开始增加事务支持。ACID已是后浪。
+
+## 1 事务ACID
+
+数据库“事务”由多个操作构成的序列。1970年詹姆斯 · 格雷（Jim Gray）提出事务的ACID，将广义事务一致性具化到原子性、一致性、隔离性和持久性。他在*Transaction Processing Concepts and Techniques*的定义：
+
+> **Atomicity**: *Either all the changes from the transaction occur (writes, and messages sent), or none occur.* 原子性：事务中的所有变更要么全部发生，要么一个也不发生。
+
+> **Consistency**: *The transaction preserves the integrity of stored information.* 一致性：事务要保持数据的完整性。
+
+> **Isolation**: *Concurrently executing transactions see the stored information as if they were running serially (one after another).* 隔离性：多事务并行执行所得到的结果，与串行执行（一个接一个）完全相同。
+
+> **Durability**: *Once a transaction commits, the changes it made (writes and messages sent) survive any system failures.* 持久性：一旦事务提交，它对数据的改变将被永久保留，不应受到任何系统故障的影响。
+
+ACID对数据库的重要度不同：
+
+![](https://img-blog.csdnimg.cn/5bb441075ff34250ace2833d30890921.png)
+
+### 1.1 一致性
+
+存在感最低，可看作对 “事务”整体目标阐述。没提出任何具体需求，所以数据库中难寻针对性设计。
+
+### 1.2 持久性
+
+不仅是对数据库的基本要求。考究其定义，核心思想就是要应对系统故障。故障分为：
+
+1. 存储硬件无损、可恢复的故障。主要依托预写日志（Write Ahead Log，WAL）保证第一时间存储数据。WAL采用顺序写，保证数据库低延时响应。WAL是单体数据库成熟技术，NoSQL和分布式数据库都借鉴过去了
+2. 存储硬件损坏、不可恢复的故障。要用到日志复制技术，将本地日志及时同步到其他节点。实现方式有三种：
+   1. 单体数据库自带的同步或半同步：半同步具有一定容错能力，实践更多
+   2. 将日志存储到共享存储系统，后者通过冗余存储保证日志安全性，亚马逊Aurora就是，也称Share Storage
+   3. 基于Paxos/Raft共识算法同步日志数据，分布式数据库中广泛使用。无论采用哪种，都是保证在本地节点之外，至少有一份完整日志可用于数据恢复
+
+
+### 1.3 原子性
+
+数据库区别其他存储系统的重要标志。
+
+单体数据库时代，原子性问题已妥善解决，但向分布式架构转型，在引入不可靠网络因素后，原子性又成为挑战。
+
+分布式架构支持原子性不容易，所以不少NoSQL选择绕过这问题，聚焦到那些对原子性不敏感的细分场景。如Google BigTable都不支持跨行事务。但这种妥协也造成NoSQL通用性不好。
+
+本系列讨论分布式数据库是在分布式架构上实现的关系型数据库，就必须支持事务，先要支持原子性。原子性实现较复杂，目标却简单，和分成多级的隔离性不同，原子性只有支持、不支持。
+
+### 1.4 隔离性
+
+事务最复杂特性。隔离性分多个隔离级别，较低隔离级别就是在正确性妥协，将一些异常现象交给应用开发，从而获得更好性能。
+
+事务模型发展过程就是在隔离性和性能间不断寻找更优平衡点。事务核心就是隔离性。而不同产品在事务一致性上的差别，也完全体现在隔离性的实现等级。
+
+## 2 ANSI SQL-92（SQL-92）
+
+最早、最正式的对隔离级别的定义，定义的隔离级别和异常现象：
+
+![](https://img-blog.csdnimg.cn/b369d328ce8547a4ad9173913a375b55.png)
+
+虽然SQL-92得到广泛应用，不少数据库也遵照该标准命名自己的隔离级别，但它对异常现象的分析还是过于简单。1995年Jim Gray等发表论文“[A Critique of ANSI SQL Isolation Levels](https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/tr-95-51.pdf)”（以下简称Critique），对事务隔离性深入分析。Critique是数据库领域经典论文。
+
+## 3 Critique：更严谨的隔离级别
+
+### 3.1 幻读和写倾斜
+
+丰富细化SQL-92内容，定义六种隔离级别和八种异常现象。
+
+最关注快照隔离（Snapshot Isolation, SI）级。SQL-92可重复读（Repeatable Read, RR）与可串行化（Serializable）主要差别是幻读（Phantom）处理。似乎说解决幻读就是可串行化。但随Critique发表，快照隔离明确提出，这说法就不适用了，因为快照隔离能解决幻读，但：
+
+- 无法处理写倾斜（Write Skew）
+- 也不符合可串行化要求
+
+翻译原因，有时写倾斜也称写偏序。因此，使用最广泛的隔离级别：已提交读、可重复读、快照隔离、可串行化。
+
+幻读和写倾斜是通往最高隔离级别的两座大山。
+
+### 3.2 Critique的幻读
+
+事务T1特定查询条件获得一个结果集，事务T2插入新数据且符合T1刚执行的查询条件。T2提交成功后，T1再次执行同样查询，得到结果集增大。
+
+#### 幻读 V.S 不可重复读
+
+自然语义接近，都是在一个事务内用相同条件查询两次，但两次结果不一：
+
+- 不可重复读，第二次结果集相对第一次，有些记录被修改（Update）或删除（Delete）
+- 幻读是第二次结果集里出现第一次结果集没有的记录（Insert）。幻读是在第一次结果集的记录“间隙”中增加新记录。所以，MySQL将防幻读的锁命名为间隙锁（Gap Lock）。
+
+### 3.3 写倾斜
+
+跟幻读相比，写倾斜稍复杂。
+
+箱子里有三个白球和三个黑球，两个事务（T1,T2）并发修改，不知道对方的存在。T1要让6个球都变成白色；T2则希望6个球都变成黑色。
+
+![](https://static001.geekbang.org/resource/image/91/fa/91e75e61d921fb21cebfdba8879806fa.jpg)
+
+![](https://static001.geekbang.org/resource/image/dd/be/ddce93423da417ef495b2bbc7c3090be.jpg)
+
+你看，最终的执行结果是，盒子里仍然有三个黑球和三个白球。如果你还没有发现问题，可以看看下面我画的串行执行的效果图，比较一下有什么不同。
+
+![](https://static001.geekbang.org/resource/image/85/83/8502cf4cf0f6fe61db1692bd1a945883.jpg)
+
+如果先执行T1再执行T2，6个球都会变成黑色；调换T1与T2的顺序，则6个球都是白色。
+
+根据可串行化的定义，“多事务并行执行所得到的结果，与串行执行（一个接一个）完全相同”。比照两张图，很容易发现事务并行执行没有达到串行的同等效果，所以这是一种异常现象。也可以说，写倾斜是一种更不易察觉的更新丢失。
+
+为搞清Critique中六种隔离级别的强弱关系以及相互间的差距，我截取了原论文的一张配图。
+
+![](https://static001.geekbang.org/resource/image/0d/aa/0d81415e08f4507d5f3f3ff6f99a99aa.jpg)
+
+你可以看到“快照隔离”与“可重复读”在强度上并列，“已提交读”则弱于这两者。事实上，今天大多数数据库支持的隔离级别就在这三者之中。
+
+### 3.4 快照隔离 & MVCC
+
+“快照隔离”为啥被SQL-92漏掉？SQL-92主要考虑基于锁（Lock-base）的并发控制，而快照隔离实现基础是MVCC，当时MVCC应用不普遍。后来MVCC成为重要技术，一些教材将MVCC作为独立选择，与乐观并发控制和悲观并发控制并列。现代数据库中MVCC已成为底层技术，更高效实现乐观或悲观并发控制。有MVCC基础，快照隔离成为普遍存在的隔离级别。
+
+## 4 隔离性的产品
+
+为啥不支持最高级别可串行化？学术界很久没找到高效的并发控制技术。很多数据库声称“可串行化”，但只是形象工程，因为都采用两阶段封锁协议，性能无法满足生产要求。少数产品尝试已取得进展：
+
+- 第一个方向，真正串行化实现“可串行化”。多线程并发在性能上更优，但Redis和VoltDB确实通过串行化执行事务获得不错性能。考虑到VoltDB作为一款分布式数据库的复杂度，成功更难得。部分原因可能在于内存的大量使用，加速数据计算VoltDB以存储过程为逻辑载体的方式，也使事务有更多优化机会
+- 如第一个方向剑走偏锋，第二个方向就是硬桥硬马。在并发技术继续做。PostgreSQL在2008年提出Serializable Snapshot Isolation (SSI)，即可串行化。而后，兼容PostgreSQL生态的CockroachDB，也同样选择支持SSI，而且是唯一支持的隔离级别
+
+## 5 分布式数据库的强一致性
+
+数据一致性和事务一致性共同构成分布式数据库的强一致性。
+
+![](https://img-blog.csdnimg.cn/722589bf794d4b74b28aff32b1e452a3.png)
+
+论文“Highly Available Transactions: Virtues and Limitations”，[Jepsen网站的简化版](https://jepsen.io/consistency)。
+
+树状结构左右两分支体现事务一致性和数据一致性的各级别及强弱关系，根节点则体现分布式数据库的一致性来自两者的融合。图中使用不同颜色，这是区别不同的一致性级别所需付出的性能代价。
+
+分布式数据，最高级别一致性是严格串行化（Strict Serializable），Spanner的“外部数据一致性”可视为与 “Strict Serializable” 等效。但两条路径各自实现难度及性能上的损耗，少有分布式数据库在顶端汇合。即使强大的Spanner也提供有界旧一致性（Bounded Stale），以平衡性能和一致性之间的冲突。
+
+分布式数据库产品的“一致性”实现现状：
+
+![](https://img-blog.csdnimg.cn/3d40e45e23994380af1a608823e9b2c4.png)
+
+OceanBase 2.2版本增加对“可串行化”支持，但这是被Oracle重新定义的“可串行化”，在这级别OceanBase和Oracle一样都会写倾斜。所以，这不是我们标准的隔离级别，没体现在表格。
+
+## 6 总结
+
+1. 数据一致性关注的是单对象、单操作在多副本上的一致性，事务一致性则是关注多对象、多操作在单副本上的一致性，分布式数据库的一致性是数据一致性与事务一致性的融合。
+2. 广义上的事务一致性被细化为ACID四个方面，其中原子性的实现依赖于隔离性的并发控制技术和持久性的日志技术。
+3. 隔离性是事务的核心。降低隔离级别，其实就是在正确性上做妥协，将一些异常现象交给应用系统的开发人员去解决，从而获得更好的性能。所以，除“可串行化”以外的隔离级别，都有无法处理的异常现象。
+4. 研究人员将隔离级别分为六级，你需要重点关注其中四个，分别是已提交读、可重复读、快照隔离、可串行化。前三者是单体数据库或分布式数据库中普遍提供的，可串行化仅在少数产品中提供。
+
+严格意义上，分布式数据库的“强一致性”意味着严格串行化（Strict Serializable），目前我们熟知的产品中只有Spanner达到了这个标准，其同时也带来了性能上的巨大开销。如果我们稍稍放松标准，那么“数据一致性”达到因果一致性且“事务一致性”达到已提交读，即可认为是相对的“强一致性”。还有一点非常重要，分布式数据一致性并不是越高越好，还要与可用性、性能指标结合，否则就成了形象工程。
+
+## 7 FAQ
+
+事务持久性部分提到预写日志（WAL），它可以保证在系统发生故障时，数据也不会丢失。但是，如果写日志成功，而写数据表失败，又要如何处理呢？根据自己的经验，讲讲该如何设计这过程？
+
+如写日志成功，但写数据表失败，可采用回滚机制保证数据一致性。可在写数据表之前，先在日志中记录一个“撤销”操作，表示如果写数据表失败，需要回滚到之前的状态。如果写数据表成功，则在日志中记录一个“提交”操作，表示当前状态已经是有效状态。在系统发生故障需要恢复时，可以根据日志中的操作来恢复数据表的状态，保证数据的一致性。
+
+
+
+MySQL RR与RC都分：
+
+- 当前读
+
+  当前读才加锁
+
+- 快照读
+
+  都不加锁
+
+RR快照读可消除幻读，因为这是事务开始时的快照一致性读，而RC是语句快照一致性读。
+
+数据块未能及时落盘，重新启动数据库会进行实例恢复，从最后的检查点开始将redo进行前写和回滚，这样就能保证数据块与redo一致了，实例恢复后，数据库就可以对外访问。
+
+正常写入过程中WAL和内存中的数据也要保证一致，因为第一时间数据库通常是不会将数据表落盘的，内存中有数据即可对外服务。
+
+Q：快照隔离相当于比RR多解决了幻读，文章说是MVCC功能特性，但MVCC并不能解决幻读，真正解决幻读的是Gap Lock（MySQL）？而且RR也可用MVCC实现？
+
+A：不是说MVCC可解决幻读。MVCC是底层技术，在此基础更易实现快照隔离，而快照隔离是要解决幻读，否则就不是标准的快照隔离。
+
+Q：实际工程中幻读在啥时有问题？似乎绝大多数情况，一个事务看见其他事务的创建或删除记录都不是问题？
+
+A：幻读问题通常出现在高并发事务环境，尤其执行大量插入、更新或删除时。此时，一个事务可能看到其他事务已提交的更改，但提交自己的更改时，却发现一些新数据。
+
+假设有两个事务同时向一个订单表插数据：
+
+- 第一个事务插入了一条订单记录，但还没提交
+- 第二个事务也尝试插入一条订单记录，但由于第一个事务还没提交，所以第二个事务会被阻塞
+- 然后，第一个事务提交其订单记录，第二个事务就继续执行
+- 但此时第二个事务会发现多一条订单记录，这就是幻读
+
+为避免幻读，可用行级锁或MVCC等。
+
+![](https://img-blog.csdnimg.cn/ab698085bcc84ee9a5c68b789b6c6847.png)
+
+预写日志就是redo日志，若redo日志成功证明已落盘，此时数据可根据redo日志异步的刷回磁盘，写数据表失败应该就是后面异步写回出现问题，我们只需重演redo日志。
+
+既然说分布式数据库事务，也该说说分布式事务，毕竟定义了数据库是分片的，如事务涉及多个机器，就得上分布式事务。https://blog.csdn.net/weixin_43705457/article/details/105443927
+
+WAL意义在于写时机，一定是同步写入，WAL如果不能写成功，SQL提交一定是失败的。同时，与WAL相关的，数据库也要处理内存中的数据与WAL协同的问题，因为多数的数据库都是第一时间写入内存结构的，而后再根据不同策略落盘。
+
+
+
+ANSI SQL 92没考虑快照隔离的原因是MVCC技术的不广泛？为啥MVCC使用不广泛就不能考虑SI呢？这之间的推导关系能再阐述？
+一般事务操作流程是WAL+内存写。WAL是持久化的，即硬件无故障的话就不会丢失。如在内存写时崩溃，那数据库重启就要检查日志，如日志表明已提交，而真正数据还没写完，则要重放。需要一套机制来判断日志中的事务是否已提交等。
+
+Q：解决写倾斜主要就是加写锁，但这严重影响并发性能？
+
+A：是，传统方案是使用锁（S2PL）解决，但性能较差。还有其他悲观协议，如串行化图检测（SGT）。
+
+日志落盘后，即可根据日志进行数据表的重写，日志在，数据表就可根据最近的checkpoint恢复。
+
+SI隔离级别是MVCC，RR也可用MVCC，不过之前没有这种技术，都用2PL。SI主要通过Gap lock来解决RR的幻读？因为光一个MVCC是解决不了幻读的。
+
+MVCC是底层技术。Gap Lock只是MySQL的实现技术，也不是SI的唯一实现方式。
+
+Q：redo log何时刷盘？完全同步太慢，批处理又可能丢数据？
+
+A：redo log是接到客户端请求后立即落盘，同步方式包括异步复制，半同步复制和全复制，若对RPO有要求，选择半同步复制多些。
\ No newline at end of file
diff --git a/docs/md/seata/docker-install-configure-seata-server.md b/docs/md/seata/docker-install-configure-seata-server.md
new file mode 100644
index 000000000..57be8f7eb
--- /dev/null
+++ b/docs/md/seata/docker-install-configure-seata-server.md
@@ -0,0 +1,218 @@
+# Docker安装配置Seata-Server
+
+## 1 部署
+
+官方文档指引
+
+![](https://img-blog.csdnimg.cn/b596d0817d18413da0cc8444d7483c34.png)
+
+### 1.1 client
+
+每个业务数据库都要新建 undo_log 表。
+
+对 springboot 应用，执行 client - MySQL - AT，切tag=1.5.2：
+
+https://github.com/seata/seata/blob/v1.5.2/script/client/at/db/mysql.sql
+
+![](https://img-blog.csdnimg.cn/93eb6d40ecfb4a35a84c175549cf1970.png)
+
+### 1.2 server
+
+新建 seata-for-hire 数据库，执行 server - MySQL：
+
+https://github.com/seata/seata/blob/v1.5.2/script/server/db/mysql.sql
+
+## 2 Docker
+
+ 拉取镜像：
+
+```bash
+$ docker pull seataio/seata-server:1.5.2
+1.5.2: Pulling from seataio/seata-server
+e7c96db7181b: Already exists
+f910a506b6cb: Already exists
+b6abafe80f63: Pull complete
+f9a900a85ba4: Pull complete
+7d27a398a423: Pull complete
+8fdfdcebe751: Pull complete
+6df95cee0f43: Pull complete
+5b571cda842d: Pull complete
+Digest: sha256:90c7bae99eba72cdf42847b4812b2b03ade16eebfa33b87badd22a122542d647
+Status: Downloaded newer image for seataio/seata-server:1.5.2
+docker.io/seataio/seata-server:1.5.2
+```
+
+拷贝命令：
+
+![](https://img-blog.csdnimg.cn/208055ab64e14beeb6d69145563811ff.png)
+
+## 3 启动容器
+
+```bash
+$ docker run --name seata-server \
+-p 8091:8091 \
+-d seataio/seata-server:1.5.2
+8a83dd2dec376ad884cb83470e99ede3c91dfecb0d6d5d3f1f5dd747b4965d6c
+
+$ docker ps
+CONTAINER ID   IMAGE                        COMMAND                   CREATED          STATUS             PORTS                              NAMES
+xx   seataio/seata-server:1.5.2   "xx"   51 seconds ago   Up 48 seconds      7091/tcp, 0.0.0.0:8091->8091/tcp   seata-server
+```
+
+## 4 配置
+
+进入容器内部看配置文件：
+
+```bash
+$ docker exec -it seata-server sh
+/seata-server # ls -l
+total 16
+drwxr-xr-x    6 root     root          4096 Jan  1  1970 classes
+drwxr-xr-x    1 root     root          4096 Jan  1  1970 libs
+drwxr-xr-x    6 root     root          4096 Jan  1  1970 resources
+drwxr-xr-x    2 root     root          4096 Jun 20 07:07 sessionStore
+
+
+/seata-server # cd resources/
+/seata-server/resources # ls -l
+total 44
+drwxr-xr-x    3 root     root          4096 Jan  1  1970 META-INF
+-rw-r--r--    1 root     root          4471 Jan  1  1970 application.example.yml
+-rw-r--r--    1 root     root           960 Jan  1  1970 application.yml
+-rw-r--r--    1 root     root          2602 Jan  1  1970 logback-spring.xml
+```
+
+application.yml，要挂载它。退出容器，将刚才那个配置文件复制到宿主机：
+
+```bash
+$ docker cp seata-server:/seata-server/resources /Users/javaedge/Downloads/soft/seata/
+Successfully copied 64.5kB to /Users/javaedge/Downloads/soft/seata/
+```
+
+这就复制到我的宿主机了：
+
+![](https://img-blog.csdnimg.cn/8246f276ac384236baa1d4476ac3d9ca.png)
+
+注意 nacos（基于 PC 本地下载的 nacos 源码构建启动的） 的 ip：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/11/5ac9a61011e817858a6a1c7f8f717e62.png)
+
+修改新增这段配置：
+
+```yml
+server:
+  port: 7091
+
+spring:
+  application:
+    name: seata-server
+
+logging:
+  config: classpath:logback-spring.xml
+  file:
+    path: ${user.home}/logs/seata
+  extend:
+    logstash-appender:
+      destination: 127.0.0.1:4560
+    kafka-appender:
+      bootstrap-servers: 127.0.0.1:9092
+      topic: logback_to_logstash
+
+console:
+  user:
+    username: seata
+    password: seata
+
+seata:
+  config:
+    # support: nacos, consul, apollo, zk, etcd3
+    type: nacos
+    nacos:
+      server-addr: 172.17.0.2:8848
+      namespace:
+      group: SEATA_GROUP
+      username: nacos
+      password: nacos
+  registry:
+    # support: nacos, eureka, redis, zk, consul, etcd3, sofa
+    type: nacos
+    nacos:
+      application: seata-server
+      server-addr: 172.17.0.2:8848
+      group: SEATA_GROUP
+      namespace:
+      cluster: default
+      username: nacos
+      password: nacos
+  store:
+    # support: file 、 db 、 redis
+    mode: db
+    db:
+      datasource: druid
+      db-type: mysql
+      driver-class-name: com.mysql.jdbc.Driver
+      url: jdbc:mysql://127.0.0.1:3306/seata-for-hire?rewriteBatchedStatements=true
+      user: root
+      password: 123456
+      min-conn: 5
+      max-conn: 100
+      global-table: global_table
+      branch-table: branch_table
+      lock-table: lock_table
+      distributed-lock-table: distributed_lock
+      query-limit: 100
+      max-wait: 5000
+#  server:
+#    service-port: 8091 #If not configured, the default is '${server.port} + 1000'
+  security:
+    secretKey: SeataSecretKey0c382ef121d778043159209298fd40bf3850a017
+    tokenValidityInMilliseconds: 1800000
+    ignore:
+      urls: /,/**/*.css,/**/*.js,/**/*.html,/**/*.map,/**/*.svg,/**/*.png,/**/*.ico,/console-fe/public/**,/api/v1/auth/login
+```
+
+####  rewriteBatchedStatements
+
+默认 false。无论 'allowMultiQueries' 设置如何，驱动是否应使用多查询，以及在调用 'executeBatch()' 时，是否应对 INSERT 和 REPLACE 类型的预备语句进行改写，把它们变为多值子句语句？ 
+
+如果使用的是非预处理的简单声明，并且没有对输入数据进行妥善清理，这可能导致 SQL 注入。此外，对预备语句，如在使用 'PreparedStatement.set*Stream()' 时没有指定流长度，驱动将无法确定每批次的最优参数数量，并可能报错说生成的数据包过大。 对于仅包括 INSERT 或 REPLACE 语句的批次重写，'Statement.getGeneratedKeys()' 方法才有效果。 
+
+当同时用 "rewriteBatchedStatements=true"、"INSERT ... ON DUPLICATE KEY UPDATE" 对语句改写时，服务器对批量操作中所有受影响（或已找到）的行只会返回一个统一值，并且无法将之正确映射回最初的语句。此时，如果批量操作的总计数为零，驱动会为每一个批量语句返回 "0"；如果总计数大于零，则返回 'Statement.SUCCESS_NO_INFO'。
+
+| Default Value | false  |
+| :------------ | ------ |
+| Since Version | 3.1.13 |
+
+外部的配置文件修改完毕后，还要挂载，需要重建容器：
+
+```bash
+javaedge@JavaEdgedeMac-mini resources % docker stop seata-server
+seata-server
+
+javaedge@JavaEdgedeMac-mini resources % docker rm seata-server
+seata-server
+```
+
+启动容器：
+
+```bash
+javaedge@JavaEdgedeMac-mini resources % docker run --name seata-server \
+-p 8091:8091 \
+-p 7091:7091 \
+-v /Users/javaedge/Downloads/soft/seata/resources://seata-server/resources \
+-d seataio/seata-server:1.5.2
+455c1a2d108e4e533359bda66b6c7c909366e7536dfe4b5e451e97626743f2e4
+
+
+javaedge@JavaEdgedeMac-mini resources % docker ps
+CONTAINER ID   IMAGE                        COMMAND                   CREATED              STATUS              PORTS                                            NAMES
+d2555578d828   seataio/seata-server:1.5.2   "java -Djava.securit…"   About a minute ago   Up About a minute   0.0.0.0:7091->7091/tcp, 0.0.0.0:8091->8091/tcp   seata-server
+```
+
+查看容器内日志，启动成功：
+
+![](https://img-blog.csdnimg.cn/6ea1749e644c45fd825a0535f8a712e9.png)
+
+成功注册到 nacos：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/11/da231688fca5aa2a03623f76c829ea4e.png)
\ No newline at end of file
diff --git a/docs/md/serverless/serverless-is-a-scam.md b/docs/md/serverless/serverless-is-a-scam.md
new file mode 100644
index 000000000..a7e27971e
--- /dev/null
+++ b/docs/md/serverless/serverless-is-a-scam.md
@@ -0,0 +1,79 @@
+# Serverless不香了？深扒其背后的巨大骗局！
+
+Serverless解决方案正逐渐回归到服务器上。我最近在《Serverless悼词》（A Eulogy For Serverless）一文中讨论了这个问题。这篇文章的最初想法是我对另一篇关于微服务的文章的更新。但后来我开始写这篇文章时，就有了一些创意。最终的结果就是这篇观点多于事实的文章。
+
+
+
+我还以为这没什么。我的意思是，每个人都知道Serverless是个骗局，对吗？看来不是。所以我收到了很多负面评论。我还记得第一次出现这种情况时，有人发了三条错误的评论。其中一条是关于 SQLite 的，说什么真正的公司不会使用 SQLite。也许我不该参与其中，但我还是发表了评论，说 SQLite 可以很好地扩展到中等规模的任务。
+
+但另外两条评论则纯粹是在咆哮，说我不知道自己在说什么，而他们这些大坏蛋 Azure 程序员却知道Serverless是如何工作的。这让我想起了我上一篇文章《为什么微服务是Serverless的最佳选择》中的这一部分：
+
+> 提供如此多的服务还有另一个好处。如果我们把服务做得过于复杂，我们就可以通过提供培训实现双赢。而且，由于使用的是我们的商标，我们可以控制它的一切。
+
+> 事实上，我们还可以三倍增长，因为这也是免费广告。甚至是四倍，因为现在人们找的不是 "Go 程序员"、"Unix 程序员 "或".Net 程序员"，而是 "AWS 程序员"。这就好比我们自创了一门编程语言，但我们并没有这么做，而是偷窃了开源代码，并将其包装成专有软件包。这才是抢劫。
+
+我本该加上第四条：我们可以四面出击。因为现在你有一群 "AWS 高级程序员 "或 "Azure 高级程序员 "或 "GCP 高级程序员"，他们会为我们鼓吹，因为这简直就是他们的饭碗。这就像那些在比特币上花了一大笔钱的人，所以不管出于什么原因，他们都在黑别人的 YouTube 频道来推广比特币。但对我们来说，它是Serverless的。台词是什么？"当一个人的薪水取决于他对某件事情的理解程度时 很难让他理解这件事"在这里也是一样我想在山谷里，他们称之为 "飞轮"。
+
+我认为这是我在那篇文章上受到的所有反击的主要原因。如果你看一下评论，就会发现有很多攻击，但实质内容却很少。虽然不是所有的评论都是这样，但那篇文章中也有一些很好的论点。最突出的论点就是你获得了 DDoS 保护。
+
+## DDoS
+
+这里有一个关键的区别，你可以获得免费的 DDoS 保护。当你在新闻中听到有人如何缓解了巨大的 DDoS 攻击时，他们可能说的是付费产品。
+
+
+此外，通过 Cloudflare，您完全可以在不使用Serverless的情况下获得同样的 DDoS 保护。您只需打开他们的 "代理 "功能即可。这允许 Cloudflare 拦截 DDoS 攻击，类似于Serverless DDoS 保护产品。
+
+
+不过需要注意的是，我第一次打开代理功能时，出现了无限重定向循环。有一个简单的解决方法，只需将 SSL/TLS 加密模式从 "灵活 "切换到 "完全 "即可。这样就能完美运行，无需任何配置，只需单击即可实现全面的 DDoS 保护。
+
+## Complexity 复杂性
+
+这就是Serverless产品的另一个问题：它们太他妈复杂了。当谷歌让一个价值1350亿美元的养老基金化为乌有时，我曾写过一篇关于这个问题的文章。原因何在？配置中缺少一个字段。
+
+
+"但你说我绝不会那么做"哦，是吗？那你给我解释一下，为什么会有那么多人忘记更改默认的 S3 存储桶，导致用户的账单爆炸。这里面错得太多了。AWS 不应该向他们收取写入失败的费用，公司也不应该将大量可能是机密的数据写入某个随机的默认位置。
+
+
+因此，它不仅是配置方面的噩梦，也是安全方面的噩梦。如果你有一个 VPS，那么锁定它就非常简单了。互联网上到处都有这样做的教程，首先你要安装 fail2ban 并禁用 root 用户的密码登录。但在Serverless上呢？祝你好运。尤其是在使用微服务的情况下，Serverless公司非常喜欢微服务（他们为什么不喜欢呢？）因为微服务通过 HTTP/S 请求进行通信，所以你最好单独锁定每个微服务。你最好查看每个微服务，找出正确的命令组合来锁定它。这可是个大工程。现在你明白为什么有那么多人在鼓吹Serverless了吧：如果Serverless消失了，那么很多人都会失业。这是一个巨大的金字塔计划。
+
+## Uptime 正常运行时间
+
+
+但至少还有正常运行时间。对吧？好吧，自从我的 RSS 阅读器改用 VPS 后，就再也没有出过故障。也就是说，它从来没有自己宕机过。为了更新一些东西，我重启过几次。但时间通常都很短，不到一秒钟。而Serverless呢？
+
+
+你知道我说过Serverless太复杂了吗？从逻辑上讲，过于复杂的系统会比简单的系统更不可靠。就拿 Firebase 来说吧。在我使用它的时候，2023 年发生了一次涉及 Firebase Auth 的大规模故障。花了几个小时才解决，非常明显。其他服务也是如此。2023 年，AWS 在西海岸也发生了 EC2 故障。此外，Azure 也在 2023 年发生了自己的故障，不过这次故障似乎是由电源浪涌引起的，因此更容易理解。2023 年？
+
+正如我之前所说：
+
+> 我对这些 "9 "持高度怀疑态度，因为如果你的某个员工不小心弄掉了一个表什么的（以前也发生过），那就等于一大堆 "9 "没了。在我看来，云数据库面临的最大威胁是 "胖手指"，而不是自然灾害。
+
+
+另外，我想重申一下，我的预算 VPS 从未出过问题。我原本很担心，因为我之前那台笨拙的 puppeteer "服务器 "总是崩溃。但事实证明，PocketBase 和 Go 一直坚如磐石。100% 的正常运行时间。
+
+## Price 价格
+
+最后就是价格了。这个问题我已经说过很多次了，现在感觉自己就像个老唱片。Serverless之所以如此昂贵，是因为它实际上是一种垄断。我的意思是，如果你使用的是像Postgres这样的行业标准，那就不一定了，但在大多数情况下，如果你被锁定在例如AWS上，你就真的离不开它了。再加上巨额的数据出口费用。
+
+<iframe class="" src="https://cdn.embedly.com/widgets/media.html?type=text%2Fhtml&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;schema=twitter&amp;url=https%3A//x.com/ImSh4yy/status/1762575172576428241&amp;image=" allowfullscreen="" frameborder="0" height="281" width="500" style="box-sizing: border-box; border: 0px solid rgb(229, 231, 235); --tw-border-spacing-x: 0; --tw-border-spacing-y: 0; --tw-translate-x: 0; --tw-translate-y: 0; --tw-rotate: 0; --tw-skew-x: 0; --tw-skew-y: 0; --tw-scale-x: 1; --tw-scale-y: 1; --tw-pan-x: ; --tw-pan-y: ; --tw-pinch-zoom: ; --tw-scroll-snap-strictness: proximity; --tw-gradient-from-position: ; --tw-gradient-via-position: ; --tw-gradient-to-position: ; --tw-ordinal: ; --tw-slashed-zero: ; --tw-numeric-figure: ; --tw-numeric-spacing: ; --tw-numeric-fraction: ; --tw-ring-inset: ; --tw-ring-offset-width: 0px; --tw-ring-offset-color: #fff; --tw-ring-color: rgba(59,130,246,.5); --tw-ring-offset-shadow: 0 0 #0000; --tw-ring-shadow: 0 0 #0000; --tw-shadow: 0 0 #0000; --tw-shadow-colored: 0 0 #0000; --tw-blur: ; --tw-brightness: ; --tw-contrast: ; --tw-grayscale: ; --tw-hue-rotate: ; --tw-invert: ; --tw-saturate: ; --tw-sepia: ; --tw-drop-shadow: ; --tw-backdrop-blur: ; --tw-backdrop-brightness: ; --tw-backdrop-contrast: ; --tw-backdrop-grayscale: ; --tw-backdrop-hue-rotate: ; --tw-backdrop-invert: ; --tw-backdrop-opacity: ; --tw-backdrop-saturate: ; --tw-backdrop-sepia: ; display: block; vertical-align: middle; max-width: 100%; width: 680px; min-height: 240px;"></iframe>
+
+
+商业法则第一条：竞争是为傻瓜准备的。如果你想赚大钱，你就必须拥有垄断地位，而这些Serverless公司通过让离开变得如此痛苦，有效地做到了这一点。
+
+公司也在慢慢接受。你可能听说过 DHH 如何离开云，以及这将如何为他的公司节省 700 万美元。最近他说："我说的是 700 万美元吗？我是说 1000 万美元。
+
+您可能也听说过亚马逊的这个案例。虽然这并不是真的要离开 AWS，因为他们只是重构了一些东西，但这恰恰说明，如果实施不当，价格很容易失控。这很容易做到，因为如上所述，Serverless是如此复杂。在你认为自己永远不会像亚马逊一样愚蠢之前（在我脑子里听起来更好），我还发现了另一篇关于另一家公司做类似事情的文章。
+
+又一个帖子，又一个帖子，还有这个帖子
+
+<iframe class="" src="https://cdn.embedly.com/widgets/media.html?type=text%2Fhtml&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;schema=twitter&amp;url=https%3A//x.com/rameerez/status/1841451179609370748&amp;image=" allowfullscreen="" frameborder="0" height="281" width="500" style="box-sizing: border-box; border: 0px solid rgb(229, 231, 235); --tw-border-spacing-x: 0; --tw-border-spacing-y: 0; --tw-translate-x: 0; --tw-translate-y: 0; --tw-rotate: 0; --tw-skew-x: 0; --tw-skew-y: 0; --tw-scale-x: 1; --tw-scale-y: 1; --tw-pan-x: ; --tw-pan-y: ; --tw-pinch-zoom: ; --tw-scroll-snap-strictness: proximity; --tw-gradient-from-position: ; --tw-gradient-via-position: ; --tw-gradient-to-position: ; --tw-ordinal: ; --tw-slashed-zero: ; --tw-numeric-figure: ; --tw-numeric-spacing: ; --tw-numeric-fraction: ; --tw-ring-inset: ; --tw-ring-offset-width: 0px; --tw-ring-offset-color: #fff; --tw-ring-color: rgba(59,130,246,.5); --tw-ring-offset-shadow: 0 0 #0000; --tw-ring-shadow: 0 0 #0000; --tw-shadow: 0 0 #0000; --tw-shadow-colored: 0 0 #0000; --tw-blur: ; --tw-brightness: ; --tw-contrast: ; --tw-grayscale: ; --tw-hue-rotate: ; --tw-invert: ; --tw-saturate: ; --tw-sepia: ; --tw-drop-shadow: ; --tw-backdrop-blur: ; --tw-backdrop-brightness: ; --tw-backdrop-contrast: ; --tw-backdrop-grayscale: ; --tw-backdrop-hue-rotate: ; --tw-backdrop-invert: ; --tw-backdrop-opacity: ; --tw-backdrop-saturate: ; --tw-backdrop-sepia: ; display: block; vertical-align: middle; max-width: 100%; width: 680px; min-height: 240px;"></iframe>
+
+还有这篇文章和这篇文章：
+
+> 别看现在，在英国接受调查的企业中，有25%的企业已经将一半或更多基于云的工作负载迁回了内部基础架构。这是云软件集团（Cloud Software Group）业务部门思杰（Citrix）最近的一项研究结果。
+
+Serverless只是一个无穷无尽的钱坑。为其辩护的人可能从未见过账单。或者他们几乎没怎么用过。我有一款中规中矩的应用，带有关卡编辑器和云保存功能。这些都是非常小众的功能，使用的人并不多，这意味着如果我使用Serverless，就不必为它们支付太多费用。
+
+但对于像 RSS 阅读器这样专注于在线内容的应用程序？你需要自己的 VPS。
+
+Serverless是个骗局。它并不总是骗局。最初，要做到 AWS、GCP 和 Azure 所做的某些事情非常困难。但情况发生了变化。在此之前，你永远不会想推出自己的 auth。但现在呢？有一个库可以实现这一点。现在有很多库，甚至是整个后端：PocketBase、Supabase、Appwrite，可能还有其他的。依赖其他公司提供所有服务的时代已经过去了。因为如果你依赖一家公司提供所有服务，你既要相信这家公司不会滥用其垄断地位，又要相信这家公司的创新速度能超过市场。而云服务提供商在这两方面都失败了。
\ No newline at end of file
diff --git a/docs/md/spring/SpringBoot3.4-release.md b/docs/md/spring/SpringBoot3.4-release.md
new file mode 100644
index 000000000..77c3566c1
--- /dev/null
+++ b/docs/md/spring/SpringBoot3.4-release.md
@@ -0,0 +1,391 @@
+# SpringBoot3.4发布声明
+
+## 1 从 Spring Boot 3.3 升级到 3.4
+
+### 1.1 RestClient 和 RestTemplate
+
+新增对 `RestClient` 和 `RestTemplate` 自动配置的支持，可用 Reactor Netty 的 `HttpClient` 或 JDK 的 `HttpClient`。支持的客户端优先级：
+
+- Apache HTTP Components (`HttpComponentsClientHttpRequestFactory`)
+- Jetty Client (`JettyClientHttpRequestFactory`)
+- Reactor Netty 的 `HttpClient` (`ReactorClientHttpRequestFactory`)
+- JDK 的 `HttpClient` (`JdkClientHttpRequestFactory`)
+- 简单的 JDK `HttpURLConnection` (`SimpleClientHttpRequestFactory`)
+
+若类路径没有 HTTP 客户端库，默认可能用 `JdkClientHttpRequestFactory`，而非之前的 `SimpleClientHttpRequestFactory`。可以通过设置 `spring.http.client.factory` 来选择特定客户端，支持的值包括 `http-components`、`jetty`、`reactor`、`jdk` 和 `simple`。
+
+所有五个客户端默认会遵循重定向。如需禁用此行为，可以将 `spring.http.client.redirects` 设置为 `dont-follow`。
+
+### 1.2 Apache HTTP Components 和 Envoy
+
+Apache HTTP Components 的 `HttpClient` 在 HTTP/1.1 的 TLS 升级默认行为有所改变。虽然大多数代理服务器可以正确处理升级，但使用 Envoy 或 Istio 时可能会遇到问题。
+
+如果需要恢复以前的行为，可用新的 `ClientHttpRequestFactoryBuilder`。定义一个 `HttpComponentsClientHttpRequestFactoryBuilder` 并按以下方式自定义：
+
+```java
+@Bean
+public HttpComponentsClientHttpRequestFactoryBuilder httpComponentsClientHttpRequestFactoryBuilder() {
+    return ClientHttpRequestFactoryBuilder.httpComponents()
+            .withDefaultRequestConfigCustomizer((builder) -> builder.setProtocolUpgradeEnabled(false));
+}
+```
+
+### 1.3 配置属性的 Bean 验证
+
+之前，当一个 `@ConfigurationProperties` 类标注了 `@Validated` 并通过 Bean Validation（如 Hibernate Validator）实现进行验证时，其嵌套属性会在绑定时被验证，无论是否使用 `@Valid` 。
+
+Spring Boot 3.4 开始，验证行为与 Bean Validation 规范一致。验证从 `@ConfigurationProperties` 注解的类开始，并仅在嵌套属性对应的字段标注了 `@Valid` 时才进行级联验证。
+
+升级时，请检查使用了 Bean Validation 约束的 `@ConfigurationProperties` 类，并在需要对嵌套属性进行级联验证的地方添加 `@Valid`。
+
+### 1.4 基于 Bean 的条件
+
+`@ConditionalOnBean` 和 `@ConditionalOnMissingBean` 在 `@Bean` 方法中使用并设置了 `annotation` 属性时，其行为有所更改。两者仍然默认使用 `@Bean` 方法的返回类型作为匹配的默认类型。然而，从 Spring Boot 3.4 开始，如果设置了 `annotation`，此默认值将不会被使用。如果需要恢复以前的行为，请同时指定一个与 `@Bean` 方法返回类型一致的 `value` 和 `annotation`。
+
+### 1.5 优雅关机
+
+嵌入式 Web 服务器（Jetty、Reactor Netty、Tomcat 或 Undertow）的优雅关机功能现已默认启用。如需恢复之前的立即关机行为， `server.shutdown` 置 `immediate`。
+
+### 1.6 Paketo Tiny Builder 用于构建 OCI 镜像
+
+在使用 Maven 的 `spring-boot:build-image` 目标为 JVM 应用程序构建 OCI 镜像时，默认的 Cloud Native Buildpacks 构建器已从 `paketobuildpacks/builder-jammy-base` 更改为 `paketobuildpacks/builder-jammy-java-tiny`。这将生成更小的镜像。但由于 `tiny` 构建器不包含 shell，因此可能无法适用于需要通过启动脚本运行的应用程序。有关自定义构建器的详细信息，请参阅 [Maven 文档](https://docs.spring.io/spring-boot/3.4/maven-plugin/build-image.html#build-image.examples.builder-configuration)。
+
+### 1.7 使用 Testcontainers 定义动态属性
+
+通过将 `DynamicPropertyRegistry` 注入到 `@Bean` 方法中来定义动态属性的功能已被弃用，现在默认会导致失败。替代方法是实现一个单独的 `@Bean` 方法，返回一个 `DynamicPropertyRegistrar`，此方法应注入属性值来源的容器。这种方式解决了一些容器生命周期问题，并确保属性值来源的容器在属性被使用之前已经启动。
+
+如果仍希望注入 `DynamicPropertyRegistry`（需承担可能的生命周期问题），可以将 `spring.testcontainers.dynamic-property-registry-injection` 设置为 `warn` 或 `allow`。前者会记录警告但允许注入，后者则会完全恢复 Spring Boot 3.3 的行为。
+
+### 1.8 @AutoConfigureTestDatabase 与容器的集成
+
+`@AutoConfigureTestDatabase` 注解现在会自动检测数据库是否来源于容器。如果是，则无需再添加 `replace=Replace.NONE`。
+
+如需恢复旧的行为，可以在注解中设置 `replace=Replace.AUTO_CONFIGURED`。
+
+### 1.9 控制 Actuator 端点的访问权限
+
+启用和禁用端点的支持已被重新设计，替换为更细粒度的访问控制模型。新的模型不仅支持禁用端点（访问级别为 `none`）和完全启用端点（访问级别为 `unrestricted`），还支持只允许端点操作的“只读”访问（访问级别为 `read-only`）。
+
+以下属性已被弃用：
+
+- `management.endpoints.enabled-by-default`
+- `management.endpoint.<id>.enabled`
+
+其替代属性为：
+
+- `management.endpoints.access.default`
+- `management.endpoint.<id>.access`
+
+同样，`@Endpoint` 注解中的 `enableByDefault` 属性已被弃用，新的 `defaultAccess` 属性取代了它。
+
+作为更改的一部分，`enabled-by-default` 的应用现在更加一致，并与是否使用了 `@ConditionalOnEnabledEndpoint` 无关。如果升级后失去了某个端点的访问权限，可以将 `management.endpoint.<id>.access` 设置为 `read-only` 或 `unrestricted`，或者将 `management.endpoint.<id>.enabled` 设置为 `true`，以使端点重新可用。
+
+另外，还引入了一个新属性，用于控制 Actuator 端点访问级别的上限：
+
+- `management.endpoints.access.max-permitted`
+
+此属性限制所有配置的访问级别。例如，如果 `management.endpoints.access.max-permitted` 设置为 `read-only`，而 `management.endpoint.loggers.access` 设置为 `unrestricted`，则日志记录端点仅允许只读访问。
+
+### 1.10 Cloud Foundry 中 @ConditionalOnAvailableEndpoint 暴露的更改
+
+在使用 `@ConditionalOnAvailableEndpoint` 注解时，原本使用的枚举值 `EndpointExposure.CLOUD_FOUNDRY` 已被弃用，建议改用 `EndpointExposure.WEB`。对于典型的 Spring Boot 应用，这一更改通常不会有影响。但如果你定义了自定义的 Cloud Foundry 特定 Actuator 端点 bean，则需要将条件更新为使用 `EndpointExposure.WEB`。
+
+### 1.11 HtmlUnit 4.3
+
+HtmlUnit 已升级至 4.3。本次升级中，依赖坐标从 `net.sourceforge.htmlunit:htmlunit` 变更为 `org.htmlunit:htmlunit`，包名也从 `com.gargoylesoftware.htmlunit.` 更新为 `org.htmlunit.`。升级时，请相应调整构建配置和代码导入。
+
+### 1.12 Selenium HtmlUnit 4.22
+
+Selenium HtmlUnit 已更新至 4.22。本次升级中，依赖坐标从 `org.seleniumhq.selenium:htmlunit-driver` 变更为 `org.seleniumhq.selenium:htmlunit3-driver`。升级时，请相应调整构建配置。
+
+### 1.13 WebJars 定位器集成
+
+[为了更快的启动时间和更高效的 WebJars 资源解析](https://github.com/spring-projects/spring-framework/issues/27619)，你需要在构建文件（如 pom.xml）中将依赖从 `org.webjars:webjars-locator-core` 更新为 `org.webjars:webjars-locator-lite`。这两项依赖由 Spring Boot 统一管理。需要注意，Spring 对 `org.webjars:webjars-locator-core` 的支持已被弃用，并将在未来版本中移除。有关详细信息，请参阅 [参考文档的相关章节](https://docs.spring.io/spring-boot/3.4/reference/web/servlet.html#web.servlet.spring-mvc.static-content)。
+
+### 1.14 OkHttp 依赖管理的移除
+
+Spring Boot 不再直接依赖 OkHttp，因此也不再对其版本进行管理。如果你的应用程序包含 OkHttp 依赖，请更新构建以选择适合需求的 OkHttp 版本。
+
+### 1.15 原生镜像中的 Netty
+
+Spring Boot 3.4 使用的 Netty 版本尚未完全被 Native Build Tools 提供的 GraalVM 可达性元数据支持。要在原生镜像中正常使用 Netty，需手动升级 GraalVM 可达性元数据版本。
+
+对于 Maven：
+
+```xml
+<plugin>
+	<groupId>org.graalvm.buildtools</groupId>
+	<artifactId>native-maven-plugin</artifactId>
+	<configuration>
+		<metadataRepository>
+			<version>0.3.14</version>
+		</metadataRepository>
+	</configuration>
+</plugin>
+```
+
+### 1.16 @MockBean 和 @SpyBean 的弃用
+
+`@MockBean` 和 `@SpyBean` 注解已被弃用，建议使用 Spring Framework 提供的 `@MockitoBean` 和 `@MockitoSpyBean`。新的注解功能与 Spring Boot 提供的注解功能并不完全一致。例如，`@MockitoBean` [尚不支持在 `@Configuration` 类中使用](https://github.com/spring-projects/spring-framework/issues/33934)，你可能需要在测试类中直接注解字段。
+
+### 1.17  Spring Boot 3.2 的弃用项
+
+Spring Boot 3.2 中标记为弃用并计划在 3.4 中移除的类、方法和属性现已被移除。在升级之前，请确保没有调用这些弃用的功能。
+
+### 1.18 最低要求更改
+
+## 2 新功能和亮点
+
+### 2.1 结构化日志
+
+新增了对结构化日志的支持，包括 Elastic Common Schema（`ecs`）、Graylog 扩展日志格式（`gelf`）和 Logstash（`logstash`）的内置支持。可以通过设置 `logging.structured.format.file` 为 `ecs`、`gelf` 或 `logstash` 来启用结构化文件日志记录。类似地，可以通过设置 `logging.structured.format.console` 来启用结构化控制台日志记录。
+
+有关更多信息，包括如何定义自定义格式，请参阅[参考文档](https://docs.spring.io/spring-boot/3.4/reference/features/logging.html#features.logging.structured)。
+
+### `@Fallback` Bean
+
+`@ConditionalOnSingleCandidate` 现在支持 `@Fallback` Bean。如果存在一个主 Bean，或者没有主 Bean 但存在一个非回退的单一候选 Bean，则该条件会匹配。
+
+### 定义附加 Bean
+
+在类型匹配时，基于 Bean 的条件现在会忽略非默认候选 Bean。通过声明某个 Bean 为非默认候选（使用 `@Bean(defaultCandidate=false)`），现在可以定义一个特定类型的 Bean，而不会导致相同类型的自动配置 Bean 退出。这简化了配置，例如在同一个应用程序中使用 [两个 `DataSource` Bean](https://docs.spring.io/spring-boot/3.4/how-to/data-access.html#howto.data-access.configure-two-datasources) 或 [两个 `EntityManagerFactory` Bean](https://docs.spring.io/spring-boot/3.4/how-to/data-access.html#howto.data-access.use-multiple-entity-managers)。
+
+### ClientHttpRequestFactory 构建器
+
+新增了 `ClientHttpRequestFactoryBuilder` 接口，可以为特定技术创建 `ClientHttpRequestFactory` 实例。构建器支持对底层组件进行细粒度自定义，并提供一致的方式来应用通用设置。
+
+以下构
+
+建器可以通过接口的静态工厂方法创建：
+
+- Apache HTTP Components（`ClientHttpRequestFactoryBuilder.httpComponents()`）
+- Jetty Client（`ClientHttpRequestFactoryBuilder.jetty()`）
+- Reactor Netty 的 `HttpClient`（`ClientHttpRequestFactoryBuilder.reactor()`）
+- JDK 的 `HttpClient`（`ClientHttpRequestFactoryBuilder.jdk()`）
+- 简单的 JDK `HttpURLConnection`（`ClientHttpRequestFactoryBuilder.simple()`）
+
+有关更多详细信息，包括如何通过配置属性应用通用设置，请参阅[参考文档](https://docs.spring.io/spring-boot/3.4/reference/io/rest-client.html#io.rest-client.clienthttprequestfactory.configuration)。
+
+### 可观察性改进
+
+#### 应用程序分组
+
+新增了 `spring.application.group` 属性，用于对应用程序进行分组，例如将属于某个业务部门的多个应用程序归类。当设置此属性时，它也会出现在日志消息中。此行为可通过 `logging.include-application.group` 属性控制。应用程序分组信息还会自动添加到 OpenTelemetry 的 `Resource` 中。
+
+#### OTLP
+
+支持通过 gRPC 传输发送 OTLP span。要启用此功能，请将新配置属性 `management.otlp.tracing.transport` 设置为 `grpc`。该属性默认为 `http`。此外，还新增了相应的服务连接支持。
+
+新增的 `management.otlp.logs` 配置属性可用于自动配置 OpenTelemetry 的 `OtlpHttpLogRecordExporter` 和 `SdkLoggerProvider`。
+
+#### 其他可观察性更新
+
+`ProcessInfoContributor` 现在还会显示堆和非堆内存的使用信息。
+
+新增的 `management.otlp.tracing.export.enabled`、`management.wavefront.tracing.export.enabled` 和 `management.zipkin.tracing.export.enabled` 属性，可用于更细粒度地启用或禁用跟踪导出。
+
+### 对 MockMvc 的 AssertJ 支持
+
+当类路径中存在 AssertJ 时，将自动配置 `MockMvcTester`。`MockMvcTester` 提供了一种流畅的 API，用于定义请求和断言。它可以在任何可以注入 `MockMvc` 的地方使用。
+
+有关更多详细信息，请参阅 Spring Framework 参考文档的[专用章节](https://docs.spring.io/spring-framework/reference/6.2-SNAPSHOT/testing/mockmvc/assertj.html)。
+
+### Spring Pulsar
+
+Spring Boot 现在提供了配置默认租户和命名空间的属性。这些默认值适用于主题 URL 未完全限定时生产或消费消息的情况。可以通过 `spring.pulsar.defaults.topic.tenant` 和 `spring.pulsar.defaults.topic.namespace` 配置这些属性，或者定义自己的 `PulsarTopicBuilder` bean。如果需要禁用默认值，将 `spring.pulsar.defaults.topic.enabled=false`。
+
+新增了 `PulsarContainerFactoryCustomizer` 接口，用于自定义自动配置的 `PulsarContainerFactory`。
+
+`spring.pulsar.consumer.subscription.name` 配置属性现在应用于自动配置的 Pulsar 监听器容器。
+
+引入了两个用于配置 Pulsar 客户端并发性的属性：
+
+- `spring.pulsar.client.threads.io`：控制用于处理与代理连接的线程数。
+- `spring.pulsar.client.threads.listener`：控制用于消息监听器的线程数。
+
+此外，新属性 `spring.pulsar.listener.concurrency` 可控制自动配置的 Pulsar 消息监听器容器的并发性。
+
+### Couchbase 身份验证
+
+Couchbase 集群现在支持通过客户端证书进行身份验证，作为用户名和密码身份验证的替代方案。详细信息请参阅[参考文档](https://docs.spring.io/spring-boot/3.4/reference/data/nosql.html#data.nosql.couchbase)。
+
+### FreeMarker
+
+FreeMarker 变量现可通过定义一个或多个类型为 `FreeMarkerVariablesCustomizer` 的 bean 来自定义。自定义器将按定义的顺序（如果有）依次调用。
+
+### 嵌入式 ActiveMQ Classic Broker 的支持
+
+由于 ActiveMQ Classic 重新支持嵌入式 Broker，自动配置已更新以支持此功能。
+
+需要注意，与 Spring Boot 2.7.x 不同，ActiveMQ starter 仅限于客户端。如果需要使用嵌入式 Broker，需要将 `org.apache.activemq:activemq-broker` 添加到应用程序中。
+
+### 配置元数据
+
+注解处理器现在支持检测 `Enum` 类型的默认值。如果你为自定义属性手动添加了元数据来提供默认值，请确保将其移除。
+
+### 弃用和替换自动配置类
+
+为简化自动配置的演进，Spring Boot 引入了对自动配置类的弃用和替换支持。替换可以在新的 `META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.replacements` 文件中声明。更多详情请参阅[参考文档](https://docs.spring.io/spring-boot/3.4/reference/features/developing-auto-configuration.html#features.developing-auto-configuration.locating-auto-configuration-candidates.deprecating)。
+
+### 虚拟线程
+
+如果启用了虚拟线程，以下组件将默认使用虚拟线程：
+
+- `OtlpMeterRegistry`
+- Undertow Web 服务器
+
+### 镜像构建改进
+
+Spring Boot 默认使用 [`paketobuildpacks/builder-jammy-java-tiny`](https://github.com/paketo-buildpacks/builder-jammy-java-tiny) 构建器。此构建器原生支持 ARM 和 x64 平台。
+
+Maven插件新增了 `trustBuilder` 选项，用于控制 CNB 生命周期的调用方式，以提高安全性。默认信任的构建器包括 Paketo 项目、Heroku 和 Google 的构建器。详情请参阅 [Maven](https://docs.spring.io/spring-boot/3.4/maven-plugin/build-image.html#build-image.customization)文档。
+
+新增的 `imagePlatform` 选项允许为不同于主机平台的操作系统和架构构建镜像，前提是主机平台支持模拟其他系统（
+
+例如，使用 Apple Silicon 的 Mac 上的 Rosetta 模拟 AMD 架构）。详情请参阅 [Maven](https://docs.spring.io/spring-boot/3.4/maven-plugin/build-image.html#build-image.customization)文档。
+
+### Docker Compose 改进
+
+Docker Compose 现在支持多个 Docker Compose 配置文件。
+
+#### 命令行参数
+
+新属性 `spring.docker.compose.start.arguments` 和 `spring.docker.compose.stop.arguments` 可以用来指定在启动和停止服务时传递给 Docker Compose 子命令的额外命令行参数。新增了 `spring.docker.compose.arguments` 属性，用于向 Docker Compose 传递参数。
+
+#### 更新支持
+
+- Postgres [`POSTGRES_HOST_AUTH_METHOD=trust` 环境变量](https://github.com/docker-library/docs/tree/657557822ecebebf0fa6bea96536125881c5bfb2/postgres#postgres_host_auth_method) 现在被支持。
+- 通过分别使用 `redis/redis-stack` 和 `redis/redis-stack-server` 容器镜像，添加了对 Redis Stack 和 Redis Stack Server 的支持。
+- 通过使用 `grafana/otel-lgtm` 容器镜像，添加了对 [Grafana LGTM](https://grafana.com/blog/2024/03/13/an-opentelemetry-backend-in-a-docker-image-introducing-grafana/otel-lgtm/) 的支持。
+- 添加了对 Hazelcast 的支持（使用 `HazelcastConnectionDetails`）。
+- 添加了对 OTLP 日志记录的支持。
+
+### Testcontainers 改进
+
+- 添加了对 `org.testcontainers.kafka.KafkaContainer` 的支持。
+- 通过分别使用 `redis/redis-stack` 和 `redis/redis-stack-server` 容器镜像，添加了对 Redis Stack 和 Redis Stack Server 的支持。
+- 添加了对 `org.testcontainers.grafana.LgtmStackContainer` 的支持。
+- 添加了对 Hazelcast 的支持（使用 `HazelcastConnectionDetails`）。
+- 添加了对 OTLP 日志记录的支持。
+- 添加了对 `RedisContainer` 的支持。
+
+### Actuator
+
+#### 可插拔的 Actuator 暴露器
+
+现在可以扩展 Spring Boot，以可插拔的方式暴露 actuator 端点。可以实现新的 `EndpointExposureOutcomeContributor` 接口来影响 `@ConditionalOnAvailableEndpoint` 条件。
+
+这个扩展应该使得提供类似我们现有的 Cloud Foundry 支持的额外平台集成变得更加容易。
+
+#### SSL 信息和健康检查
+
+如果您使用的是 SSL 包，现在有一个新端点显示 SSL 信息（有效期、发行者、主题等），可在 `/actuator/info` 下获取。该端点还会显示即将过期的证书，以提醒您需要尽快轮换证书。新增了名为 `management.health.ssl.certificate-validity-warning-threshold` 的配置属性来配置阈值。
+
+还添加了一个新的健康检查来监控 SSL 证书。如果证书无效，它将状态设置为 `OUT_OF_SERVICE`。
+
+#### `/actuator/scheduledtasks` 端点中的额外信息
+
+[`/scheduledtasks` Actuator 端点](https://docs.spring.io/spring-boot/3.4/api/rest/actuator/scheduledtasks.html#scheduled-tasks.retrieving) 现在公开了有关计划任务的额外元数据，例如 "下一次预定执行时间" 和 "上次执行时间、状态和异常"。
+
+## 3 依赖升级
+
+Spring Boot 3.4 迁移到了几个 Spring 项目的新版：
+
+- [Spring AMQP 3.2](https://github.com/spring-projects/spring-amqp/releases/tag/v3.2.0)
+- [Spring Authorization Server 1.4](https://github.com/spring-projects/spring-authorization-server/releases/tag/1.4.0)
+- [Spring Batch 5.2](https://github.com/spring-projects/spring-batch/releases/tag/v5.2.0)
+- [Spring Data 2024.1](https://github.com/spring-projects/spring-data-commons/wiki/Spring-Data-2024.1-Release-Notes)
+- [Spring Framework 6.2](https://github.com/spring-projects/spring-framework/releases/tag/v6.2.0)
+- [Spring HATEOAS 2.4](https://github.com/spring-projects/spring-integration/releases/tag/2.4.0)
+- [Spring Integration 6.4](https://github.com/spring-projects/spring-integration/releases/tag/v6.4.0)
+- [Spring Kafka 3.3](https://github.com/spring-projects/spring-kafka/releases/tag/v3.3.0)
+- [Spring Pulsar 1.2](https://github.com/spring-projects/spring-pulsar/releases/tag/1.2.0)
+- [Spring Security 6.4](https://github.com/spring-projects/spring-security/releases/tag/6.4.0)
+- [Spring Session 3.4](https://github.com/spring-projects/spring-session/releases/tag/3.4.0)
+
+许多第三方依赖项也已更新，其中一些更值得注意的包括：
+
+- Apache Http Client 5.4
+- [AssertJ 3.26](https://github.com/assertj/assertj/releases/tag/assertj-build-3.26.0)
+- [Artemis 2.37](https://activemq.apache.org/components/artemis/download/release-notes-2.37.0)
+- Elasticsearch Client 8.15
+- [Flyway 10.20](https://documentation.red-gate.com/flyway/release-notes-and-older-versions/release-notes-for-flyway-engine)
+- [Gson 2.11](https://github.com/google/gson/releases/tag/gson-parent-2.11.0)
+- Hibernate 6.6
+- HtmlUnit 4.5.0
+- JUnit Jupiter 5.11
+- Jackson 2.18.0
+- Jedis 5.2
+- Kafka 3.8
+- Lettuce 6.4
+- [Liquibase 4.29](https://docs.liquibase.com/start/release-notes/liquibase-release-notes/liquibase-4.29.0.html)
+- Log4j 2.24
+- [HtmlUnit 4.3](https://github.com/HtmlUnit/htmlunit/releases/tag/4.3.0)
+- [MariaDB 3.4](https://mariadb.com/kb/en/mariadb-connector-j-3-4-0-release-notes/)
+- [Micrometer 1.14](https://github.com/micrometer-metrics/micrometer/releases/tag/v1.14.0)
+- [Micrometer Tracing 1.4](https://github.com/micrometer-metrics/tracing/releases/tag/v1.4.0)
+- [Mockito 5.13](https://github.com/mockito/mockito/releases/tag/v5.13.0)
+- MongoDB 5.2.0
+- [MySQL 9.1](https://dev.mysql.com/doc/relnotes/connector-j/en/news-9-1-0.html)
+- [OpenTelemetry 1.41](https://github.com/open-telemetry/opentelemetry-java/releases/tag/v1.41.0)
+- [Oracle Database 23.4](https://download.oracle.com/otn-pub/otn_software/jdbc/23c/JDBC-UCP-ReleaseNotes-23ai.txt)
+- R2DBC MySQL 1.3
+- Rabbit AMQP Client 5.22
+- Rabbit Stream Client 0.18.0
+- [Reactor 2024.0](https://github.com/reactor/reactor/releases/tag/2024.0.0)
+- [Selenium 4.25](https://raw.githubusercontent.com/SeleniumHQ/selenium/selenium-4.25.0/java/CHANGELOG)
+- [Testcontainers 1.20.3](https://github.com/testcontainers/testcontainers-java/releases/tag/1.20.3)
+- [XMLUnit 2.10](https://github.com/xmlunit/xmlunit/releases/tag/v2.10.0)
+
+### 杂项
+
+除了上述变化外，还包括许多小的调整和改进：
+
+- 现在可以使用 `Customizer<Liquibase>` bean 在使用 Liquibase 之前对其进行自定义。
+- 现在可以通过定义 `JCachePropertiesCustomizer` bean 来自定义用于创建 JCache `CacheManager` 的属性。
+- 现在可以通过定义名为 `viewNameTranslator` 的 bean 来自定义 Spring MVC 使用的 `RequestToViewNameTranslator`。
+- 现在可以使用 `LettuceClientOptionsBuilderCustomizer` bean 来自定义 Lettuce 的 `ClientOptions`。对于整个 `LettuceClientConfiguration` 的更广泛配置，继续使用 `LettuceClientConfigurationBuilderCustomizer`。
+- 可以使用新的自定义器 `ProxyConnectionFactoryCustomizer` 来自定义 R2DBC 的 `ProxyConnectionFactory`。
+- 如果发生 Spring Security 注销，现在会发布一个审计事件。
+- 现在可以使用新的属性 `spring.mail.ssl.*` 通过 SSL 包配置 `JavaMailSender` 上的 TLS。
+- 现在可以使用新的 `spring.gson.strictness` 属性配置 GSON 的严格性。
+- 现在可以在 JavaBean 风格的配置属性的字段上使用 `@Name` 来自定义其名称。
+- 当从另一个 `DataSource` 派生时，`DataSourceBuilder` 现在可以使用源 DataSource 的 URL 确定驱动程序类名称，如果它不公开驱动程序类名称。
+- [就绪和存活健康探针](https://docs.spring.io/spring-boot/3.4-SNAPSHOT/reference/actuator/endpoints.html#actuator.endpoints.kubernetes-probes) 现在在 Cloud Foundry 平台上自动启用。
+- 可以使用新属性 `spring.application.version` 读取和设置应用程序版本。属性的默认值取自清单中的 `Implementation-Version`。
+- 自动配置的 `EntityManagerFactoryBuilder` 也定义了原生（例如 Hibernate）属性。
+- 即使没有使用 `@EnableScheduling`，Spring Integration 的 `TaskScheduler` 现在也支持虚拟线程。
+- `@ConditionalOnAvailableEndpoint` 现在有一个 `value` 别名用于 `endpoint`。
+- 添加了一个新的配置属性 `spring.data.web.pageable.serialization-mode`，用于配置 Spring Data Web 的序列化模式。
+- 使用 `SpringApplication.from(…)` 语法时，现在可以指定要激活的额外配置文件。
+- Spring Boot 插件不再在构建包环境中设置 `BP_NATIVE_IMAGE: true`。
+- 注册的 `@ConfigurationProperties` beans 现在尊重 `@DependsOn`、`@Description`、`@Fallback`、`@Lazy`、`@Primary`、`@Scope` 和 `@Role` 注解。
+- 现在支持 Log4j2 的 `MultiFormatStringBuilderFormattable` 在结构化日志中。
+- 添加了一个新的配置属性 `spring.jms.listener.max-messages-per-task`，用于配置监听器在单个任务中处理的最大消息数。
+- 默认的安全配置现在暴露了映射到附加路径的健康组。此外，两个 `EndpointRequest` 类现在提供了 `toAdditionalPaths(…)` 方法。
+- 现在可以通过属性设置会话 cookie 的[分区](https://developer.mozilla.org/en-US/docs/Web/Privacy/Privacy_sandbox/Partitioned_cookies)属性。
+- 添加了一个新的 `server.jetty.max-form-keys` 属性，用于自定义 Jetty 的最大表单键。
+- 添加了新的属性 `management.otlp.logging.connect-timeout` 和 `management.otlp.tracing.connect-timeout` 以配置与 OTLP 收集器的连接超时。
+- 添加了通过 OTLP 传输日志时的 gRPC 传输支持。
+- 如果在构建过程中绑定了容器中使用的目录，现在会显示警告。
+- 如果使用 `--enable-sbom=sbom` 构建原生镜像，现在会自动检测到这个 SBOM。
+- `DatabaseDriver` 枚举现在支持 ClickHouse JDBC 驱动程序。
+- 可以使用新属性 `management.logging.export.enabled`
+- 和 `management.otlp.logging.export.enabled` 禁用日志导出。
+  - 可以通过定义带有 `@BatchTaskExectuor` 注解的 `TaskExecutor` bean 来自定义 Spring Batch 使用的 `TaskExecutor`。
+  - Spring Session 自动配置现在支持响应式 Web 应用程序中的 `indexed` 存储库类型。
+  - 如果未配置池挂起并且创建了检查点，`HikariCheckpointRestoreLifecycle` 现在会记录一条警告。
+
+## 3.4 版本 Spring Boot 的弃用
+
+  - 弃用 `spring.gson.lenient`，改用 `spring.gson.strictness`。
+  - 弃用 `@MockBean` 和 `@SpyBean`，改用 Spring Framework 的 `@MockitoBean` 和 `MockitoSpyBean`。
+  - 弃用 `org.springframework.boot.ResourceBanner#getApplicationVersion(Class<?>)`，改用 `spring.application.version` 属性。
+  - 弃用 `org.springframework.boot.SpringApplication#logStartupInfo(boolean)`，改用 `org.springframework.boot.SpringApplication#logStartupInfo(ConfigurationApplicationContext)`。
+  - 弃用 `org.springframework.boot.logging.logback.ApplicationNameConverter`，改用 `org.springframework.boot.logging.logback.EnclosedInSquareBracketsConverter`。
+  - 弃用 `org.springframework.boot.actuate.autoconfigure.endpoint.expose.EndpointExposure#CLOUD_FOUNDRY`，改用 `org.springframework.boot.actuate.autoconfigure.endpoint.expose.EndpointExposure#WEB`。
+  - 弃用 `org.springframework.boot.actuate.autoconfigure.tracing.otlp.OtlpTracingConnectionDetails#getUrl()`，改用 `getUrl(Transport)`。
+  - 弃用 `org.springframework.boot.actuate.autoconfigure.tracing.OpenTelemetryAutoConfiguration`，改用 `org.springframework.boot.actuate.autoconfigure.tracing.OpenTelemetryTracingAutoConfiguration`。
+  - 弃用 `OtlpAutoConfiguration`，改用 `OtlpTracingAutoConfiguration`。
+  - 弃用 `management.endpoints.enabled-by-default` 和 `management.endpoint.<id>.enabled`，改用 `management.endpoints.access.default` 和 `management.endpoint.<id>.access`。
+  - 弃用 `@Endpoint` 上的 `enableByDefault`，改用 `defaultAccess`。
\ No newline at end of file

From 597bcd5d19f6aea131db1d5b4ded88d32cd505a0 Mon Sep 17 00:00:00 2001
From: JavaEdge <sss2855845850@gmail.com>
Date: Tue, 28 Jan 2025 18:30:37 +0800
Subject: [PATCH 02/20] =?UTF-8?q?perf:=E4=BC=98=E5=8C=96=E4=B8=93=E6=A0=8F?=
 =?UTF-8?q?=E5=88=86=E7=B1=BB?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .vscode/.server-controller-port.log           |   4 +-
 docs/.vuepress/config.js                      | 141 +++--
 docs/md/AI/building-effective-agents.md       | 211 +++++++
 docs/md/AI/llm/chatgpt-canva.md               | 148 +++++
 .../biz-arch/cloud-efficiency-at-netflix.md   |  65 +++
 ...-their-cache-consistency-to-99-99999999.md | 256 +++++++++
 ...nables-searching-a-message-within-150ms.md | 113 ++++
 ...e-launch-observability-at-netflix-scale.md |  71 +++
 docs/md/career/big-company-work-style.md      | 133 +++++
 ...icked-my-brain-to-be-addicted-to-coding.md | 184 ++++++
 docs/md/career/p6-promotion-guide.md          | 222 ++++++++
 ...t-get-you-promoted-the-overlooked-truth.md | 212 +++++++
 docs/md/career/workplace-jargon.md            |  80 +++
 docs/md/career/workplace-rule.md              | 200 +++++++
 ...25\347\240\264\345\261\200\357\274\237.md" |   2 +-
 ...77\345\235\221\346\214\207\345\215\227.md" | 147 +++++
 ...-based-architecture-adoption-guidelines.md | 290 ++++++++++
 docs/md/java/java2024.md                      | 130 +++++
 ...23\346\240\217\345\244\247\347\272\262.md" |  66 ++-
 .../monitor/performance-optimization-guide.md | 189 +++++++
 ...50\351\253\230\346\225\210\357\274\201.md" | 413 ++++++++++++++
 ...20\346\234\215\345\212\241\357\274\237.md" | 139 +++++
 ...nancy-with-spring-multi-tenancy-library.md | 464 ++++++++++++++++
 ...13\345\214\226\351\241\271\347\233\256.md" |  79 ++-
 ...04\346\225\260\346\215\256\346\265\201.md" |   2 +-
 docs/md/vue/router.md                         | 493 ++++++++++++++++
 docs/md/vue/table.md                          | 524 ++++++++++++++++++
 docs/md/vue/vue2-to-vue3.md                   | 171 ++++++
 28 files changed, 5059 insertions(+), 90 deletions(-)
 create mode 100644 docs/md/AI/building-effective-agents.md
 create mode 100644 docs/md/AI/llm/chatgpt-canva.md
 create mode 100644 docs/md/biz-arch/cloud-efficiency-at-netflix.md
 create mode 100644 docs/md/biz-arch/how-meta-improved-their-cache-consistency-to-99-99999999.md
 create mode 100644 docs/md/biz-arch/linkedin-architecture-which-enables-searching-a-message-within-150ms.md
 create mode 100644 docs/md/biz-arch/title-launch-observability-at-netflix-scale.md
 create mode 100644 docs/md/career/big-company-work-style.md
 create mode 100644 docs/md/career/how-i-tricked-my-brain-to-be-addicted-to-coding.md
 create mode 100644 docs/md/career/p6-promotion-guide.md
 create mode 100644 docs/md/career/why-hard-work-didnt-get-you-promoted-the-overlooked-truth.md
 create mode 100644 docs/md/career/workplace-jargon.md
 create mode 100644 docs/md/career/workplace-rule.md
 rename "docs/md/career/07-\347\273\217\345\270\270\350\242\253\345\216\213\347\274\251\345\274\200\345\217\221\346\227\266\351\227\264\357\274\214\345\273\266\346\234\237\350\277\230\350\246\201\350\203\214\351\224\205\357\274\214\345\246\202\344\275\225\347\240\264\345\261\200\357\274\237.md" => "docs/md/career/\347\273\217\345\270\270\350\242\253\345\216\213\347\274\251\345\274\200\345\217\221\346\227\266\351\227\264\357\274\214\345\273\266\346\234\237\350\277\230\350\246\201\350\203\214\351\224\205\357\274\214\345\246\202\344\275\225\347\240\264\345\261\200\357\274\237.md" (99%)
 create mode 100644 "docs/md/career/\350\275\254\345\236\213\344\274\240\347\273\237\350\241\214\344\270\232\351\201\277\345\235\221\346\214\207\345\215\227.md"
 create mode 100644 docs/md/design/cell-based-architecture-adoption-guidelines.md
 create mode 100644 docs/md/java/java2024.md
 create mode 100644 docs/md/monitor/performance-optimization-guide.md
 create mode 100644 "docs/md/security/03-OAuth2.0\345\256\236\346\210\230-\350\275\273\346\235\276\345\255\246\344\274\232\344\275\277\347\224\250JWT\357\274\214\350\256\251\344\275\240\347\232\204OAuth2.0\345\256\236\347\216\260\346\233\264\345\212\240\345\256\211\345\205\250\351\253\230\346\225\210\357\274\201.md"
 create mode 100644 "docs/md/security/07-\344\275\240\347\241\256\345\256\232\346\207\202OAuth 2.0\347\232\204\344\270\211\346\226\271\350\275\257\344\273\266\345\222\214\345\217\227\344\277\235\346\212\244\350\265\204\346\272\220\346\234\215\345\212\241\357\274\237.md"
 create mode 100644 docs/md/spring/mastering-multi-tenancy-with-spring-multi-tenancy-library.md
 create mode 100644 docs/md/vue/router.md
 create mode 100644 docs/md/vue/table.md
 create mode 100644 docs/md/vue/vue2-to-vue3.md

diff --git a/.vscode/.server-controller-port.log b/.vscode/.server-controller-port.log
index d338b7efa..75136fd16 100644
--- a/.vscode/.server-controller-port.log
+++ b/.vscode/.server-controller-port.log
@@ -1,5 +1,5 @@
 {
-  "port": 9145,
-  "time": 1734190844439,
+  "port": 9149,
+  "time": 1737701531002,
   "version": "0.0.3"
 }
\ No newline at end of file
diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index e2b71bf23..c690b8fbe 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -4,7 +4,7 @@ module.exports = {
     base: "/",
     // 预加载js
     shouldPrefetch: (file, type) => {
-        return true;
+        return false;
     },
     markdown: {
         lineNumbers: true,
@@ -318,10 +318,9 @@ module.exports = {
                             {
                                 text: 'RocketMQ',
                                 items: [{
-                                        text: '消息队列基础',
-                                        link: '/md/RocketMQ/消息队列面试必问解析.md'
-                                    },
-                                ]
+                                    text: '消息队列基础',
+                                    link: '/md/RocketMQ/消息队列面试必问解析.md'
+                                }, ]
                             },
 
                             {
@@ -442,8 +441,7 @@ module.exports = {
 
                             {
                                 text: 'SpringCloud',
-                                items: [
-                                    {
+                                items: [{
                                         text: 'SpringCloudAlibaba',
                                         link: '/md/spring/spring-cloud/SpringCloudAlibaba介绍.md'
                                     },
@@ -451,7 +449,7 @@ module.exports = {
                                         text: 'SpringCloudGateway工作原理与链路图',
                                         link: '/md/spring/spring-cloud/SpringCloudGateway工作原理与链路图.md'
                                     },
-                                    
+
                                     {
                                         text: 'Seata',
                                         link: '/md/seata/01-Seata客户端依赖坐标引入与踩坑排雷.md'
@@ -482,10 +480,9 @@ module.exports = {
                             {
                                 text: 'Redis',
                                 items: [{
-                                        text: '基础',
-                                        link: '/md/redis/00-数据结构的最佳实践.md'
-                                    },
-                                ]
+                                    text: '基础',
+                                    link: '/md/redis/00-数据结构的最佳实践.md'
+                                }, ]
                             },
 
                             {
@@ -536,10 +533,9 @@ module.exports = {
                         items: [{
                                 text: '大数据平台',
                                 items: [{
-                                        text: '00-互联网大厂的大数据平台架构',
-                                        link: '/md/bigdata/大数据平台架构.md'
-                                    },
-                                ]
+                                    text: '00-互联网大厂的大数据平台架构',
+                                    link: '/md/bigdata/大数据平台架构.md'
+                                }, ]
                             },
 
                             {
@@ -633,7 +629,7 @@ module.exports = {
                                     link: '/md/k8s/00-Kubernetes的基本架构.md'
                                 }]
                             },
-                            
+
                             {
                                 text: 'ServerLess',
                                 items: [{
@@ -812,9 +808,19 @@ module.exports = {
                     {
                         text: '职业',
                         items: [{
-                                text: '01-Java工程师必读书单',
+                                text: '职业规划',
                                 link: '/md/career/01-Java工程师必读书单.md'
                             },
+                            {
+                                text: '晋升',
+                                link: '/md/career/p6-promotion-guide'
+                            },
+
+                            {
+                                text: '职场',
+                                link: '/md/career/经常被压缩开发时间，延期还要背锅，如何破局？'
+                            },
+
                             {
                                 text: '00-如何学习项目管理专栏',
                                 link: '/md/mgr/00-如何学习项目管理专栏.md'
@@ -946,6 +952,10 @@ module.exports = {
                                 "netflixs-distributed-counter-abstraction",
                                 "data-gateway-a-platform-for-growing-and-protecting-the-data-tier",
                                 "enhancing-netflix-reliability-with-service-level-prioritized-load-shedding",
+                                "title-launch-observability-at-netflix-scale",
+                                "cloud-efficiency-at-netflix",
+                                "linkedin-architecture-which-enables-searching-a-message-within-150ms",
+                                "how-meta-improved-their-cache-consistency-to-99-99999999",
                             ]
                         },
 
@@ -1240,6 +1250,7 @@ module.exports = {
                                 "JDK21新特性",
                                 "JDK22新特性",
                                 "JDK23新特性",
+                                "java2024",
                             ]
                         },
 
@@ -1357,7 +1368,7 @@ module.exports = {
                                 "SpringBoot默认线程池",
                             ]
                         },
-                        
+
                         {
                             title: "SpringBoot新特性",
                             collapsable: false,
@@ -1609,6 +1620,7 @@ module.exports = {
                             children: [
                                 "并发用户、RPS、TPS的解读",
                                 "01-性能分析思路",
+                                "performance-optimization-guide",
                             ]
                         },
                     ],
@@ -1654,7 +1666,7 @@ module.exports = {
                             "kafka-versions",
                         ]
                     }, ],
-                    
+
                     "/md/serverless/": [{
                         title: "serverLess",
                         collapsable: false,
@@ -1943,24 +1955,49 @@ module.exports = {
                     }, ],
 
                     "/md/career/": [{
-                        title: "职业规划",
-                        collapsable: false,
-                        sidebarDepth: 0,
-                        children: [
-                            "01-Java工程师必读书单",
-                            "02-为什么中国的程序员有35岁危机",
-                            "03-新人程序员入行忠告",
-                            "04-外企也半夜发布上线吗？",
-                            "05-中外程序员到底有啥区别？",
-                            "06-全球顶级架构师推荐的书单",
-                            "07-经常被压缩开发时间，延期还要背锅，如何破局？",
-                            "08-程序员为何一直被唱衰？",
-                            "09-程序员的“三步走”发展战略",
-                            "10-为何我建议你学会抄代码",
-                            "11-计师能去哪些央国企？",
-                            "mastering-architecture-diagrams",
-                        ]
-                    }],
+                            title: "职业规划",
+                            collapsable: false,
+                            sidebarDepth: 0,
+                            children: [
+                                "01-Java工程师必读书单",
+                                "02-为什么中国的程序员有35岁危机",
+                                "03-新人程序员入行忠告",
+                                "04-外企也半夜发布上线吗？",
+                                "05-中外程序员到底有啥区别？",
+                                "06-全球顶级架构师推荐的书单",
+                                "08-程序员为何一直被唱衰？",
+                                "09-程序员的“三步走”发展战略",
+                                "10-为何我建议你学会抄代码",
+                                "11-计师能去哪些央国企？",
+                                "mastering-architecture-diagrams",
+                                "how-i-tricked-my-brain-to-be-addicted-to-coding",
+                                "转型传统行业避坑指南",
+                                "workplace-jargon",
+                                "workplace-rule",
+                                "big-company-work-style",
+                            ]
+                        },
+
+                        {
+                            title: "晋升",
+                            collapsable: false,
+                            sidebarDepth: 0,
+                            children: [
+                                "p6-promotion-guide",
+                                "why-hard-work-didnt-get-you-promoted-the-overlooked-truth",
+                            ]
+                        },
+
+                        {
+                            title: "职场",
+                            collapsable: false,
+                            sidebarDepth: 0,
+                            children: [
+                                "经常被压缩开发时间，延期还要背锅，如何破局？",
+                            ]
+                        },
+
+                    ],
 
                     "/md/vue/": [{
                         title: "Vue",
@@ -1968,8 +2005,11 @@ module.exports = {
                         sidebarDepth: 0,
                         children: [
                             "01-Vue开发实战",
+                            "vue2-to-vue3",
                             "05-教你快速搭建Vue3工程化项目",
                             "Vuex设计Vue3项目的数据流",
+                            "router",
+                            "table",
                         ]
                     }],
 
@@ -2054,18 +2094,35 @@ module.exports = {
                             sidebarDepth: 0,
                             children: [
                                 "00-免费大模型API",
-                                "Claude3到底多强",
                                 "GPTs推荐",
                                 "ChatGPT为啥不用Websocket而是EventSource",
                                 "携手阿里云：JetBrains AI Assistant 正式发布！",
                                 "中国大陆用户如何使用Jetbrains内置的AI插件AI Assistant",
                                 "contextual-retrieval",
                                 "lm-studio-transform-mac-into-ai-tool",
-                                "计算机使用功能",
                                 "navigating-llm-deployment-tips-tricks-and-techniques",
                                 "goodbye-cursor-hello-windsurf",
                                 "qwen-QwQ",
                                 "only-ai-flow-can-do",
+                                "chatgpt-canva",
+                            ]
+                        },
+                        {
+                            title: "Gemini",
+                            collapsable: false,
+                            sidebarDepth: 0,
+                            children: [
+                                "00-免费大模型API",
+                            ]
+                        },
+
+                        {
+                            title: "Claude",
+                            collapsable: false,
+                            sidebarDepth: 0,
+                            children: [
+                                "Claude3到底多强",
+                                "计算机使用功能",
                             ]
                         },
                         {
@@ -2209,6 +2266,7 @@ module.exports = {
                                 "customizing-a-tool-for-your-ai-agent",
                                 "Complex-SQL-Joins-with-LangGraph-and-Waii",
                                 "AI Agent应用出路到底在哪？",
+                                "building-effective-agents",
                             ]
                         },
 
@@ -2244,6 +2302,7 @@ module.exports = {
                                 "evolution-software-architecture-mainframes-to-distributed-computing",
                                 "cell-based-architecture-distributed-systems",
                                 "cell-based-architecture-resilient-fault-tolerant-systems",
+                                "cell-based-architecture-adoption-guidelines",
                                 "架构师教你kill祖传石山代码重复&大量ifelse",
                                 "measuring-technical-debt",
                             ]
@@ -2354,6 +2413,8 @@ module.exports = {
                             sidebarDepth: 0,
                             children: [
                                 "01-OAuth 2.0实战-为什么要先获取授权码code.md",
+                                "03-OAuth2.0实战-轻松学会使用JWT，让你的OAuth2.0实现更加安全高效！",
+                                "07-你确定懂OAuth 2.0的三方软件和受保护资源服务？",
                             ]
                         },
                     ],
diff --git a/docs/md/AI/building-effective-agents.md b/docs/md/AI/building-effective-agents.md
new file mode 100644
index 000000000..9c69745f3
--- /dev/null
+++ b/docs/md/AI/building-effective-agents.md
@@ -0,0 +1,211 @@
+# 最强AI智能体竟如此简单！Anthropic首次公开内部秘籍！
+
+## 0 前言
+
+过去一年中，我们与不同行业中开发大语言模型 (LLM) 智能体的多个团队进行了合作。我们发现，最成功的实现并非依赖复杂的框架或专业化的库，而是通过简单、可组合的模式构建。
+
+本文分享从客户合作及自身开发智能体的过程中所学到的经验，并为开发者提供构建高效智能体的实用建议。
+
+## 1 啥是智能体？
+
+“智能体”有多种定义：
+
+- 一些客户将智能体定义为完全自主的系统，这些系统能够独立运行较长时间，利用各种工具完成复杂任务
+- 另一些人则将其描述为遵循预定义工作流的更具指令性的实现
+
+在 Anthropic，我们将这些变化形式统称为**智能系统（agentic systems）**，但在架构上对**工作流**和**智能体**做重要区分：
+
+- **工作流**是通过预定义的代码路径来协调 LLM 和工具的系统
+- **智能体**则是动态控制其自身过程和工具使用的系统，保持对任务完成方式的主导权
+
+接下来详细探讨这两种智能系统类型。在附录 1（“智能体的实际应用”）中，我们会描述客户在特定领域中应用这些系统所取得的成果。
+
+## 2 何时（及何时不）使用智能体
+
+在构建 LLM 应用时，建议寻找尽可能简单的解决方案，仅必要时增加复杂性。这可能意味着完全不构建智能系统。智能系统通常以牺牲延迟和成本为代价，换取更好的任务表现，因此需权衡。
+
+当需要更多复杂性时，工作流可以为定义明确的任务提供可预测性和一致性，而智能体更适合需要灵活性和模型驱动决策的大规模任务。然而，对于许多应用，使用检索和上下文示例优化单次 LLM 调用通常已经足够。
+
+## 3 何时及咋用框架
+
+许多框架可简化智能系统实现，如：
+
+- LangChain 的 [LangGraph](https://langchain-ai.github.io/langgraph/)
+- 亚马逊 Bedrock 的 [AI Agent 框架](https://aws.amazon.com/bedrock/agents/)
+- [Rivet](https://rivet.ironcladapp.com/)，一种拖拽式 GUI LLM 工作流构建器
+- [Vellum](https://www.vellum.ai/)，另一个用于构建和测试复杂工作流的 GUI 工具
+
+这些框架通过简化调用 LLM、定义和解析工具以及串联调用等标准底层任务，帮助用户快速入门。然而，它们常常会引入额外的抽象层，可能掩盖底层提示词和响应，使调试变得更困难，同时也容易诱使开发者添加本可以避免的复杂性。
+
+建议开发者从直接使用 LLM API 入手，因为许多模式可以用几行代码实现。如果确实使用框架，请确保对底层代码有充分了解。对框架内部运行机制的错误假设是客户错误的常见来源。
+
+参考我们的 [cookbook](https://github.com/anthropics/anthropic-cookbook/tree/main/patterns/agents) 获取一些示例实现。
+
+## 4 构建模块、工作流与智能体
+
+本部分探讨我们在实际生产环境中观察到的智能系统常见模式。从基础构建模块（增强型 LLM）开始，逐步增加复杂性，从简单的组合工作流到自主智能体。
+
+### 4.1 构建模块：增强型 LLM
+
+智能系统的基本构建模块是通过检索、工具和记忆功能增强的 LLM。我们的现有模型能够主动使用这些功能，如：
+
+- 生成搜索查询
+- 选择合适工具
+- 确定需要保留的信息
+
+增强型 LLM：
+
+![](https://www.anthropic.com/_next/image?url=https%3A%2F%2Fwww-cdn.anthropic.com%2Fimages%2F4zrzovbb%2Fwebsite%2Fd3083d3f40bb2b6f477901cc9a240738d3dd1371-2401x1000.png&w=3840&q=75)
+
+建议重点关注实现的两个关键方面：将这些功能定制化以满足特定用例需求，并确保为 LLM 提供易于使用且文档完备的接口。虽这些增强功能有多种实现，但其中一种方法是使用我们最近发布的 [模型上下文协议](https://www.anthropic.com/news/model-context-protocol)，该协议允许开发者通过简单的 [客户端实现](https://modelcontextprotocol.io/tutorials/building-a-client#building-mcp-clients) 与日益扩展的第三方工具生态系统集成。
+
+接下来，假设每次 LLM 调用都可以访问这些增强功能。
+
+### 4.2 工作流：提示词链式调用
+
+提示词链式调用将任务分解为一系列步骤，每次 LLM 调用处理上一步的输出。您可以在任何中间步骤添加程序化检查（见下图中的“门”）以确保流程仍在正轨上。
+
+提示词链式调用工作流：
+
+![](https://www.anthropic.com/_next/image?url=https%3A%2F%2Fwww-cdn.anthropic.com%2Fimages%2F4zrzovbb%2Fwebsite%2F7418719e3dab222dccb379b8879e1dc08ad34c78-2401x1000.png&w=3840&q=75)
+
+**适用场景：** 此工作流适用于任务可以轻松、清晰地分解为固定子任务的情况。其主要目标是通过使每次 LLM 调用任务更简单，以延迟换取更高准确性。
+
+**提示词链式调用的应用示例：**
+
+- 生成营销文案，然后将其翻译成另一种语言
+- 编写文档提纲，检查提纲是否符合特定标准，然后根据提纲编写文档
+
+### 4.3 工作流：路由
+
+对输入进行分类，并将其引导到特定后续任务来实现的工作流。这允许更好分离关注点，并能为特定类型的输入构建更专业提示词。没这种工作流，为某种输入优化的方式可能影响其他输入的性能。
+
+路由工作流：
+
+![](https://www.anthropic.com/_next/image?url=https%3A%2F%2Fwww-cdn.anthropic.com%2Fimages%2F4zrzovbb%2Fwebsite%2F5c0c0e9fe4def0b584c04d37849941da55e5e71c-2401x1000.png&w=3840&q=75)
+
+**适用场景：** 路由适用于复杂任务，这些任务分为不同类别，每个类别更适合独立处理，并且分类能够准确完成，可以由 LLM 或更传统的分类模型/算法处理。
+
+路由的应用示例：
+
+- 将不同类型的客户服务查询（如一般问题、退款请求、技术支持）分别引导到不同的下游流程、提示词和工具
+- 将简单或常见的问题引导到较小的模型（如 Claude 3.5 Haiku），而将复杂或罕见的问题引导到更强大的模型（如 Claude 3.5 Sonnet），以优化成本和速度
+
+### 4.4 工作流：并行化
+
+在并行化工作流中，LLM 可以同时处理一个任务，其输出随后由程序进行聚合。这种工作流有两种主要形式：
+
+- **分段**：将任务分解为独立子任务并行运行
+- **投票**：对同一任务运行多次以获取多样化输出
+
+并行化工作流：
+
+![](https://www.anthropic.com/_next/image?url=https%3A%2F%2Fwww-cdn.anthropic.com%2Fimages%2F4zrzovbb%2Fwebsite%2F406bb032ca007fd1624f261af717d70e6ca86286-2401x1000.png&w=3840&q=75)
+
+**适用场景：** 并行化适用于可以分解为独立子任务以加快速度的任务，或需要多次尝试或多个视角来提高结果信心的任务。对于需要考虑多个因素的复杂任务，让每个因素由独立的 LLM 调用处理通常表现更优，能够集中精力应对每个特定方面。
+
+**应用示例**
+
+- 分段：
+  - 实现护栏功能，其中一个模型实例处理用户查询，另一个模型实例筛选不适当内容或请求。这种方式通常比单次 LLM 调用同时处理护栏和核心响应更高效。
+  - 自动评估 LLM 性能，每次调用评估模型性能的不同方面。
+- 投票：
+  - 检查代码中的漏洞，通过多种不同提示词对代码进行审查并标记潜在问题。
+  - 评估给定内容是否不适当，多种提示词评估不同方面，或使用不同投票阈值以平衡误报和漏报。
+
+### 4.5 工作流：协调者-工作者模式
+
+在协调者-工作者模式中，中心 LLM 动态分解任务，将子任务分配给工作者 LLM，并综合其结果。
+
+协调者-工作者工作流：
+
+![](https://www.anthropic.com/_next/image?url=https%3A%2F%2Fwww-cdn.anthropic.com%2Fimages%2F4zrzovbb%2Fwebsite%2F8985fc683fae4780fb34eab1365ab78c7e51bc8e-2401x1000.png&w=3840&q=75)
+
+**适用场景：**非常适合无法预测所需子任务的复杂任务。如编码中，每次需要更改的文件数量及每个文件的更改内容可能取决于特定任务。尽管拓扑上类似并行化，其关键区别在灵活性——子任务不是预定义的，而是由协调者根据具体输入动态确定。
+
+**应用示例：**
+
+- 实现复杂更改的编码产品，涉及多个文件
+- 搜索任务，从多个来源收集并分析信息以筛选可能的相关内容
+
+### 4.6 工作流：评估者-优化者模式
+
+在评估者-优化者模式中，一个 LLM 调用生成响应，另一个 LLM 调用则提供评估和反馈，通过循环迭代优化结果。
+
+![](https://www.anthropic.com/_next/image?url=https%3A%2F%2Fwww-cdn.anthropic.com%2Fimages%2F4zrzovbb%2Fwebsite%2F14f51e6406ccb29e695da48b17017e899a6119c7-2401x1000.png&w=3840&q=75)
+
+评估者-优化者工作流
+
+**适用场景：** 此工作流特别适合有明确评估标准的情况，并且迭代改进可以带来显著价值。两个适用标志是：首先，当人类提出反馈时，LLM 的响应能够显著改进；其次，LLM 自身可以提供这样的反馈。这类似于人类写作过程中反复修改以生成精炼文档的过程。
+
+**应用示例**
+
+- 文学翻译，其中译者 LLM 初始可能无法捕捉到所有细微差别，而评估者 LLM 能够提供有益的批评
+- 复杂的搜索任务，这些任务需要多轮搜索和分析以收集全面的信息，评估者决定是否需要进一步搜索
+
+### 4.6 智能体
+
+随 LLM 在理解复杂输入、进行推理和规划、可靠地使用工具以及从错误中恢复的能力方面的逐步成熟，智能体正在生产环境中逐渐被采用。智能体的工作起点通常是用户的指令或与用户的互动讨论。一旦任务明确，智能体会规划并自主执行任务，必要时可能会再次与用户交互以获取更多信息或判断。在执行过程中，智能体需在每个步骤中从环境中获取“真实信息”（例如工具调用的结果或代码执行的反馈），以评估任务进展。智能体可以在检查点或遇到阻碍时暂停以获取用户反馈。任务通常在完成后终止，也可以设置停止条件（如最大迭代次数）以保持控制。
+
+尽管智能体可以处理复杂任务，但其实现通常较为简单，主要是 LLM 在一个循环中基于环境反馈使用工具。因此，设计清晰和完善的工具集及其文档至关重要。在附录 2（“为工具设计提示词”）中，我们扩展了工具开发的最佳实践。
+
+自主智能体：
+
+![](https://www.anthropic.com/_next/image?url=https%3A%2F%2Fwww-cdn.anthropic.com%2Fimages%2F4zrzovbb%2Fwebsite%2F58d9f10c985c4eb5d53798dea315f7bb5ab6249e-2401x1000.png&w=3840&q=75)
+
+**适用场景：** 智能体适合开放性问题，这类问题难以预测所需步骤，且无法通过硬编码定义固定路径。LLM 可能需要多轮操作，因此需要对其决策有一定信任。智能体的自主性使其非常适合在可信环境中扩展任务。
+
+智能体的自主性带来了更高的成本，并可能导致错误的累积。我们建议在隔离环境中进行广泛测试，并配备适当的保护措施。
+
+**应用示例**
+
+来自我们自身的实现：
+
+- 一个编码智能体，用于解决 [SWE-bench 任务](https://www.anthropic.com/research/swe-bench-sonnet)，这些任务根据任务描述对多个文件进行编辑
+- 我们的 [“计算机使用”参考实现](https://github.com/anthropics/anthropic-quickstarts/tree/main/computer-use-demo)，其中 Claude 使用计算机完成任务
+
+High-level flow of a coding agent：
+
+![](https://www.anthropic.com/_next/image?url=https%3A%2F%2Fwww-cdn.anthropic.com%2Fimages%2F4zrzovbb%2Fwebsite%2F4b9a1f4eb63d5962a6e1746ac26bbc857cf3474f-2400x1666.png&w=3840&q=75)
+
+### 4.7 结合与定制这些模式
+
+这些构建模块并非硬性规定，而是开发者可以根据不同用例加以调整和组合的通用模式。与任何 LLM 功能一样，成功的关键在于衡量性能并对实现方案进行迭代优化。重申一点：只有在复杂性确实能够显著改善结果时，才应考虑增加复杂性。
+
+## 5 总结
+
+在大语言模型领域取得成功，并不是构建最复杂的系统，而是构建适合自身需求的**正确系统**。从简单的提示词开始，用全面的评估优化它们，只有当更简单的解决方案无法满足需求时，才引入多步骤的智能系统。
+
+在实施智能体时，我们遵循以下三个核心原则：
+
+1. 在智能体设计中保持**简洁**；
+2. 优先**透明性**，明确展示智能体的规划步骤；
+3. 通过全面的工具**文档和测试**，精心设计智能体的接口。
+
+框架可以帮助快速入门，但随着进入生产阶段，不要犹豫减少抽象层，并以基本组件进行构建。遵循这些原则，您可以创建功能强大、可靠且易于维护的智能体，赢得用户的信任。
+
+## 附录-智能体的实际应用
+
+我们与客户的合作表明，有两个特别有前景的智能体应用领域能够很好地展示本文所讨论模式的实际价值。这两个应用领域显示了智能体在需要结合对话与操作、具有明确成功标准、能够进行反馈循环并且可进行有意义的人工监督的任务中所能带来的显著价值。
+
+### A. 客户支持
+
+客户支持结合了传统的聊天机器人界面与通过工具集成增强的能力。对于更加开放式的智能体而言，这是一个天然契合的场景，因为：
+
+- 支持交互自然遵循对话流程，同时需要访问外部信息和执行操作；
+- 可以集成工具来提取客户数据、订单历史以及知识库文章；
+- 诸如处理退款或更新工单之类的操作可以以编程方式处理；
+- 成功可以通过用户定义的解决方案清晰地衡量。
+
+许多公司已经通过基于使用的定价模式证明了这种方法的可行性，即仅对成功解决方案收费，这显示了对智能体效果的高度信心。
+
+### B. 编码智能体
+
+软件开发领域在 LLM 功能方面展现了显著潜力，其能力已经从代码补全发展到自主解决问题。智能体特别有效的原因包括：
+
+- 代码解决方案可以通过自动化测试进行验证；
+- 智能体可以使用测试结果作为反馈迭代改进解决方案；
+- 问题空间定义清晰且结构化；
+- 输出质量可以通过客观指标进行衡量。
+
+在我们的实施中，智能体已经能够根据拉取请求描述解决 [SWE-bench Verified](https://www.anthropic.com/research/swe-bench-sonnet) 基准测试中的真实 GitHub 问题。然而，尽管自动化测试有助于验证功能性，人工审查对于确保解决方案符合更广泛的系统需求仍然至关重要。
\ No newline at end of file
diff --git a/docs/md/AI/llm/chatgpt-canva.md b/docs/md/AI/llm/chatgpt-canva.md
new file mode 100644
index 000000000..02db63056
--- /dev/null
+++ b/docs/md/AI/llm/chatgpt-canva.md
@@ -0,0 +1,148 @@
+# ChatGPT的Canvas画布功能竟然能做到这些！
+
+## 0 前言
+
+对标 Claude 的Artifacts。
+
+与 ChatGPT 一起写作和编程的新方式：
+图片展示了一款垂直工具栏，包含五个按列排列的图标，背景为柔和的粉彩色调。顶部起第三个图标是一本打开的书，其旁边有标签标注为“阅读等级”。
+
+![](https://images.ctfassets.net/kftzwdyauwt9/uZHfstpnZ78qg2HQhn7m1/25db0387b0f72c0e20c933dcb01533f5/Canvas_Hero.png?w=3840&q=90&fm=webp)
+
+我们推出了 Canvas，这是一个用于写作和编程项目的新界面，能够超越简单的聊天功能。Canvas 会在单独的窗口中打开，允许您与 ChatGPT 合作完成项目。这款早期测试版引入了一种新型协作方式——不仅通过对话，还可以并肩创建和完善想法。
+
+Canvas 基于 GPT-4o 构建，用户可在测试阶段通过模型选择器手动选择。从今天开始，我们将向 ChatGPT Plus 和团队用户全球推出 Canvas。企业和教育用户将在下周获得访问权限。我们还计划在测试版结束后向所有 ChatGPT 免费用户开放 Canvas。
+
+## 1 与 ChatGPT 更好协作
+
+每天都有用户利用 ChatGPT 帮助完成[writing](https://openai.com/chatgpt/use-cases/writing-with-ai/)和编程任务。虽然聊天界面操作简便，适合许多任务，但在需要编辑和修订的项目中，它有所局限。Canvas 为这类工作提供了全新界面。
+
+借助 Canvas，ChatGPT 能更好地理解您试图完成的任务的上下文。您可以高亮特定部分，明确告诉 ChatGPT 需要关注的内容。像一名文案编辑或代码审阅者一样，它可以根据整个项目提供内联反馈和建议。
+
+在 Canvas 中，您掌控项目。您可以直接编辑文本或代码，并通过快捷菜单要求 ChatGPT 调整写作长度、调试代码，以及快速执行其他有用操作。您还可以通过 Canvas 的后退按钮恢复您工作的先前版本。
+
+当 ChatGPT 检测到 Canvas 能发挥作用的场景时，会自动打开 Canvas。您也可以在提示中加入“使用 Canvas”来启动该功能，并将其用于现有项目。
+
+写作快捷方式包括：
+
+- 建议编辑：ChatGPT 提供内联建议和反馈
+- 调整长度：将文档长度调整为更短或更长
+- 改变阅读等级：调整阅读等级，从幼儿园到研究生水平
+- 添加最终润色：检查语法、清晰度和一致性
+- 添加表情符号：添加相关表情符号以增强效果和丰富色彩
+
+## 2 在 Canvas 中编程
+
+编程是一个迭代的过程，在聊天中很难跟踪代码的所有修订。Canvas 使您更容易理解和跟踪 ChatGPT 的修改，我们计划继续提升这些编辑的透明度。
+
+编程快捷方式包括：
+
+- 代码审查：ChatGPT 提供内联建议以改进代码
+- 添加日志：插入打印语句，帮助调试和理解代码
+- 添加注释：为代码添加注释，使其更易于理解
+- 修复错误：检测并重写有问题的代码以解决错误
+- 移植到其他语言：将代码转换为 JavaScript、TypeScript、Python、Java、C++ 或 PHP
+
+## 3 训练模型成为协作者
+
+我们训练了 GPT-4o，使其能够作为创意合作伙伴进行协作。模型能够判断何时打开 Canvas、进行针对性编辑或完全重写。此外，它还理解更广泛的上下文，提供精确的反馈和建议。
+
+为此，我们的研究团队开发了以下核心行为：
+
+- 针对写作和编程任务触发 Canvas
+- 生成多样化的内容类型
+- 进行针对性编辑
+- 重写文档
+- 提供内联批注
+
+我们通过 20 多项自动化内部评估测量了进展。我们采用新颖的合成数据生成技术，例如从 OpenAI o1-preview 中提取输出以对模型进行核心行为的后期训练。这种方法使我们能够快速改进写作质量和用户交互，而无需依赖人工生成数据。
+
+一个关键挑战是定义何时触发 Canvas。我们教模型在接收到诸如“撰写关于咖啡豆历史的博客文章”这样的提示时触发 Canvas，同时避免对诸如“帮我做一道新菜”这样的常规问答任务过度触发。对于写作任务，我们优先改善“正确触发”（以牺牲“正确不触发”为代价），达到了 83%，相比零样本的 GPT-4o 基线有显著提升。
+
+需要注意的是，此类基线的质量高度依赖于具体使用的提示词。在不同提示下，基线可能表现得很差，但以不同的方式——例如，在编程和写作任务中均匀不准确，从而导致不同的错误分布和其他形式的次优表现。对于编程任务，我们故意对触发进行偏置以避免干扰高级用户。我们将根据用户反馈持续优化这一点。
+
+##### Canvas 决策边界触发——写作与编程
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/a10990d430c7c87869d00c19e701cad2.png)
+
+对于写作和编程任务，我们改进了 Canvas 决策边界的正确触发率，在写作和编程任务中分别达到 83% 和 94%，相比基线零样本的 GPT-4o 有明显提升。
+
+第二个挑战是调整模型在触发 Canvas 后的编辑行为——具体来说，决定是进行针对性编辑还是完全重写。当用户通过界面明确选择文本时，我们训练模型执行针对性编辑，否则倾向于重写。随着模型优化，这种行为还将继续改进。
+
+##### Canvas 编辑边界——写作与编程
+
+
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/f791890a359b42dadcd0979858e24597.png)
+
+在写作和编程任务中，我们优先提升 Canvas 的针对性编辑能力。带有 Canvas 的 GPT-4o 在这一能力上的表现比基线提升 18%。
+
+最后，训练模型生成高质量评论需要精细迭代。与前两种情况不同，这种能力难以通过自动化方法评估，因此我们依赖人工评估评论的质量和准确性。结果显示，我们的 Canvas 集成模型在准确性上比零样本 GPT-4o 提升 30%，在质量上提升 16%。这表明，通过合成训练，可以显著改善响应质量和行为，效果优于使用详细指令的零样本提示。
+
+##### Canvas 建议评论
+
+
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/a858fcfb6d7bdc199a2505d72bbd15b2.png)
+
+人工评估显示，Canvas 模型在评论的准确性上提升 30%，在质量上提升 16%，显著优于基线 GPT-4o。
+
+## 4 展望
+
+让 AI 更有用、更易于访问需要重新思考与 AI 的交互方式。Canvas 是一种全新的尝试，也是 ChatGPT 自两年前发布以来首次对视觉界面进行重大更新。
+
+## 5 12月12日重要更新
+
+- Canvas 向所有用户开放并内置到主要模型中，无需额外操作即可使用
+- Canvas 现支持直接运行 Python 程序代码，可直接看到代码生成的文字或图形结果。
+- Canvas 内置到自定义 GPT 中，使其具备 Canvas 的强大功能。
+
+## 6 咋用？
+
+12月12日起，Canvas 直接内置到 GPT-4o ，用户无需再通过模型选择器切换到带有 Canvas 的 GPT-4o。某些提示或粘贴的文字，Canvas 会自动打开。目前，这功能仅支持 ChatGPT web。
+
+Canvas 能帮助用户将一个创意扩展成完整的作品。ChatGPT 界面发现输入区域有一个新按钮，可查看所有可用工具，其中包括「Canvas」。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/aabf40dbe689983799fa2de2f6a99637.png)
+
+## 7 功能盘点
+
+虽然叫 Canvas，但主要是写作及代码工具，编辑长篇或复杂内容。适用场景：
+
+- **撰写长篇文章或文件**：编写技术博客、SOP或完整故事
+- **代码编辑**：Canvas 可编辑代码片段，如 Python 脚本、HTML 网页或其他语言，并支持多种语言的格式化
+- **多次修改与反复调整**：需反复修改内容、重组段落或进行深入校对时，Canvas 让细节调整更方便
+- **团队协作草稿**：与他人分享或共同编辑内容，Canvas 是条理清晰的平台。
+
+### 示例：利用 Canvas 创作故事
+
+在 Canvas 中创建一个故事，如：「为高级软件工程师写一个关于如何进阶为技术专家的故事」。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/46ffd9921c9767c3256be0a685dcbf99.png)
+
+生成后，可在段落的右下角的「编辑建议」按钮中进一步调整：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/c53bb6dac7c2b1ae045c82f86b1da2f5.png)
+
+如修改文章长度、润色程度和阅读等级。调整后，内容会根据目标变化：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/a684dff4b0ce81842862cee504721166.png)
+
+
+
+## 8 支持运行 Python 程序代码
+
+此次更新还使 Canvas 支持运行 Python 代码，用户可以直接在 Canvas 中运行代码，无需手动转移到本地系统验证。
+
+Canvas 可用于以下任务：
+
+- 审核代码
+- 转换代码语言
+- 修复 Bug
+- 添加日志与注释
+
+更重要的是，Canvas 提供了一个内置的 WebAssembly Python 模拟器，几乎可加载任意 Python 库并即时运行程序代码。
+
+## 9 自定义 GPT 的内置 Canvas 功能
+
+对于自定义 GPT 用户，Canvas 将默认内置，用户可通过设置调整何时或是否启用 Canvas 功能。自定义 GPT 的强大功能与基础版 ChatGPT 同步，同时支持更定制化的功能满足用户需求。
\ No newline at end of file
diff --git a/docs/md/biz-arch/cloud-efficiency-at-netflix.md b/docs/md/biz-arch/cloud-efficiency-at-netflix.md
new file mode 100644
index 000000000..96659fbd5
--- /dev/null
+++ b/docs/md/biz-arch/cloud-efficiency-at-netflix.md
@@ -0,0 +1,65 @@
+# Netflix云计算效率优化秘诀！
+
+## 背景
+
+在 Netflix，我们使用亚马逊网络服务（AWS）来满足我们的云基础设施需求，如计算、存储和网络，以构建和运行我们喜爱的流媒体平台。我们的生态系统使工程团队能够利用开源和专有解决方案的组合，大规模运行应用程序和服务。反过来，我们的自助服务平台允许团队更高效地创建和部署工作负载，有时甚至是自定义工作负载。这种多样化的技术环境会从各种基础设施实体中产生大量丰富的数据，数据工程师和分析师会从中协作，在一个持续的反馈循环中为工程组织提供可操作的见解，从而最终提升业务。
+
+我们实现这一目标的一个重要方法是将高度精选的数据源民主化，这些数据将 Netflix 各项服务和团队的使用情况和成本模式阳光化。数据与洞察组织与我们的工程团队密切合作，共享关键的效率指标，使内部利益相关者能够做出明智的业务决策。
+
+## 数据是关键
+
+
+
+这就是我们的团队 Platform DSE（数据科学工程）的作用所在，它使我们的工程合作伙伴能够了解他们正在使用哪些资源，他们使用这些资源的效率和效果如何，以及与资源使用相关的成本。我们希望我们的下游消费者能够使用我们的数据集做出具有成本意识的决策。
+
+
+
+为了以可扩展的方式满足这些众多的分析需求，我们开发了一种由两部分组成的解决方案：
+
+1. Foundational Platform Data (FPD)基础平台数据：该组件为所有平台数据提供一个集中的数据层，具有一致的数据模型和标准化的数据处理方法。
+2. Cloud Efficiency Analytics (CEA)云效率分析：该组件建立在 FPD 的基础上，提供一个分析数据层，在各种业务用例中提供时间序列效率指标。
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/0*vDQJiJUttlRSpVBo)
+
+### 基础平台数据 (FPD)
+
+
+我们与不同的平台数据提供商合作，获取他们各自平台的库存、所有权和使用数据。下面举例说明这一框架如何应用于 Spark 平台。FPD 与生产商签订数据合同，以确保数据质量和可靠性；这些合同使团队能够利用通用数据模型获得所有权。标准化的数据模型和处理促进了可扩展性和一致性。
+
+![img](https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*cln5xplS7lpdE0KOh0LE1Q.jpeg)
+
+### 云效率分析（CEA 数据）
+
+一旦基础数据准备就绪，CEA 就会消耗库存、所有权和使用数据，并应用适当的业务逻辑来生成不同粒度的成本和所有权归属。CEA 的数据模型方法是分门别类和透明化；我们希望下游消费者了解为什么他们会看到资源显示在他们的名字/机构下，以及这些成本是如何计算的。这种方法的另一个好处是，当引入新的业务逻辑或业务逻辑发生变化时，能够快速进行透视。
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/0*bvD7xqAO9T9m4s4G)
+
+出于成本核算的目的，我们将资产分配给单个所有者，或在资产为多租户时分配成本。不过，我们也为不同的消费者提供不同汇总的使用情况和成本。
+
+## 数据原则
+
+
+
+作为效率指标的真实来源，我们团队的任务是提供准确、可靠和可访问的数据，提供全面的文档资料，以便在复杂的效率空间中游刃有余，并提供定义明确的服务水平协议（SLA），以便在延迟、中断或变更期间与下游消费者达成期望。
+
+虽然所有权和成本看似简单，但由于业务基础设施和平台特定功能的广度和范围，数据集的复杂性相当高。服务可能有多个所有者，每个平台的成本启发法都是独一无二的，而且基础设施数据的规模也很大。当我们努力将基础设施的覆盖范围扩大到所有垂直业务领域时，我们面临着一系列独特的挑战：
+
+### 适合大多数人的几种尺寸
+
+
+
+尽管在将上游平台数据转化为 FPD 和 CEA 的过程中签订了数据合同并采用了标准化数据模型，但通常仍存在一定程度的特定平台独有的定制化问题。作为真相的集中来源，我们始终感到处理负担的紧张。在决策制定过程中，我们需要与数据生产者和消费者进行持续的透明对话，经常进行优先级检查，并与业务需求保持一致，因为我们是这一领域的明智领导者。
+
+### 数据保证
+
+为了保证数据的正确性和可信度，我们必须对管道中每一层的健康指标进行审核和可见性，以便快速调查问题并找出异常的根本原因。由于上游延迟和数据转换所需的时间，在确保数据正确性的同时保持数据的完整性变得非常具有挑战性。我们不断改进我们的审核工作，并结合反馈意见来完善和满足我们的 SLA。
+
+### 抽象层
+
+我们重视人而不是流程，工程团队为企业其他部门构建定制的 SaaS 解决方案的情况并不少见。虽然这有利于创新并提高了开发速度，但在理解和解释使用模式以及以对企业和最终消费者有意义的方式进行成本归因时，可能会产生一些难题。有了来自 FPD 的明确库存、所有权和使用数据，以及分析层中的精确归因，我们就能为下游用户提供衡量指标，无论他们是利用内部平台还是直接在 AWS 资源上进行构建。
+
+## 未来展望
+
+展望未来，我们的目标是继续为 FPD 和 CEA 搭建平台，力争在来年实现几乎全面的成本洞察覆盖。从长远来看，我们计划将 FPD 扩展到安全和可用性等其他业务领域。我们的目标是通过预测分析和 ML 来优化使用和检测成本中的异常情况，从而转向主动方法。
+
+最终，我们的目标是让我们的工程组织在构建和维护让我们享受 Netflix 流媒体服务的各种服务时，能够做出注重效率的决策。
\ No newline at end of file
diff --git a/docs/md/biz-arch/how-meta-improved-their-cache-consistency-to-99-99999999.md b/docs/md/biz-arch/how-meta-improved-their-cache-consistency-to-99-99999999.md
new file mode 100644
index 000000000..90c579763
--- /dev/null
+++ b/docs/md/biz-arch/how-meta-improved-their-cache-consistency-to-99-99999999.md
@@ -0,0 +1,256 @@
+# Meta如何用极致技术实现接近完美的缓存一致性？
+
+## 0 导言
+
+缓存是一种强大的技术，广泛应用于计算机系统的各个方面，从缓存等硬件到操作系统、网络浏览器，尤其是后端开发。对于 Meta 这样的公司来说，缓存是非常重要的，因为它可以帮助他们减少延迟、扩展繁重的工作负载并节省资金。由于他们的用例非常依赖缓存，这就给他们带来了另一系列问题，那就是缓存失效。
+
+多年来，Meta 已将缓存一致性从 99.9999（6 个 9）提高到 99.99999999（10 个 9），即其缓存集群中，100 亿次缓存写入中只有不到 1 次不一致。本文讨论：
+
+1. 什么是缓存失效和缓存一致性？
+2. Meta 为何如此重视缓存一致性，以至于连六个九都不够？
+3. Meta 的监控系统如何帮助他们改进缓存失效、缓存一致性并修复错误
+
+## 1 缓存失效和缓存一致性
+
+顾名思义，缓存并不保存数据真实来源，因此当真实来源中的数据发生变化时，应该有一个主动失效陈旧缓存条目的过程。若失效过程处理不当，会在缓存中无限期地留下与真实源中不同的不一致值。
+
+### 咋才能使缓存失效？
+
+可设置一个 TTL 保持缓存的新鲜度，就不会有来自其他系统的缓存失效。但本文讨论mata的缓存一致性问题，我们将假设无效操作是由缓存本身以外的其他系统执行的。
+
+ 先看咋引入的缓存不一致：
+
+![](https://engineering.fb.com/wp-content/uploads/2022/06/Cache-made-consisent-image-1.png?w=1024)
+
+1、2、3、4 依次递增的时间戳
+
+1. 缓存尝试从数据库中填充值
+2. 但 x=42 的值到达缓存前，一些操作更新了数据库中 x=43 的值
+3. 数据库为 x=43 发送缓存失效事件，该事件在 x=42 之前到达缓存，缓存值被置 43
+4. 事件 x =42 现在到达缓存，缓存被设置为 42，出现不一致
+
+
+对此，可用version字段解决该冲突，旧版本就不会覆盖新版本。这种解决方案已适用互联网 99% 公司，但由于系统过于复杂，这样的解决方案也可能不满足 Meta 的运营规模。
+
+## 2 为啥这么关注缓存一致性？
+
+- Meta的角度，这几乎与数据库数据丢失一样糟糕
+- 用户角度，它可能导致糟糕的用户体验
+
+试想一下，将Alice的主信息存储从region2 转移到region1 后，Bob和Mary都向Alice发送了信息：
+
+- 当Bob向Alice发信息时，系统查询了Bob居住地附近区域的 TAO 副本，并将信息发送到region1
+- 当Mary向Alice发送信息时，系统查询了Mary居住地附近区域的 TAO 副本，命中了不一致的 TAO 副本，并将信息发送到region2
+- Mary和Bob将信息发送到不同的区域，两个region/存储都没有Alice信息的完整副本
+
+cache invalidations：
+
+![](https://engineering.fb.com/wp-content/uploads/2022/06/Cache-made-consisent-image-2.png?w=1024)
+
+## 3 缓存失效的心理模型
+
+
+
+![](https://engineering.fb.com/wp-content/uploads/2022/06/Cache-made-consisent-image-3.png?w=1024)
+
+理解缓存失效的独特挑战很困难。从一个简单的心理模型开始。缓存的核心是一个有状态的服务，它将数据存储在可寻址的存储介质。分布式系统本质是个状态机。若每次状态转换都正确执行，就有了个按预期运行的分布式系统。否则，就会遇到问题。关键问题是：啥改变了有状态服务的数据？
+
+![](https://engineering.fb.com/wp-content/uploads/2022/06/Cache-made-consisent-image-4.png?w=1024)
+
+一个静态缓存有一个很简单的缓存模型（如一个简化的 CDN 就符合该模型）。数据是不可变的，无需缓存失效。对于数据库，数据仅在写入（或复制）时发生变更。通常会记录几乎所有数据库的状态更改日志。每当发生异常，日志可帮助我们了解发生过啥，缩小问题范围并定位问题。构建一个容错的分布式数据库（本身已很困难）自带一系列独特的挑战。这些只是简化的心理模型，不会无意轻视任何人的困难。
+
+![](https://engineering.fb.com/wp-content/uploads/2022/06/Cache-made-consisent-image-5.png?w=1024)
+
+对于动态缓存，如 [TAO](https://www.usenix.org/system/files/conference/atc13/atc13-bronson.pdf) 和 [Memcache](https://research.facebook.com/publications/scaling-memcache-at-facebook/)，数据在读（缓存填充）和写（缓存失效）路径上都会发生变更。这种确切的结合使许多竞争条件成为可能，并使缓存失效成为难题。缓存中的数据不持久，即有时在冲突解决中重要的版本信息可能会被逐出。结合所有这些特性，动态缓存产生了超出你想象的竞争条件。
+
+要记录和追踪每次缓存状态的更改几乎不可能。引入缓存通常是为扩展以读为主的工作负载。即大多缓存状态更改是通过缓存填充路径发生。TAO每天处理超过一千万亿次查询。即使缓存命中率达到 99%，每天仍需进行超过 10 万亿次缓存填充。记录和追踪所有的缓存状态变化，会将以读为主的缓存工作负载变成对日志系统来说极为写密集的工作负载。调试分布式系统本已极具挑战性；在没有缓存状态更改日志或追踪时，调试分布式缓存系统几乎不可能。
+
+尽管面临这些挑战，Meta仍将 TAO 的缓存一致性从 99.9999 提高到了 99.99999999。他们是如何做到的呢？
+
+## 4 可靠的一致性可观测性
+
+要解决缓存失效和缓存一致性问题，第一步是进行监测。我们需要监测缓存的一致性，并在缓存中存在不一致条目时告警。监测结果不能包含任何误报。人脑可轻松忽略噪声，若存在误报，人们会迅速学会忽略这些警报，导致该指标失去信任并变得无用。还需要监测结果精确，因为我们讨论的是 10 个 9 的一致性水平。若进行了一次一致性修复，希望能够定量地监测其改进。
+
+![](https://engineering.fb.com/wp-content/uploads/2022/06/Cache-made-consisent-image-6.png?w=1024)
+
+
+
+## 5 Polaris
+
+为解决监测问题，Meta构建了一种 Polaris 服务。对有状态服务中的任何异常，仅当客户端能以某种方式观察到它时，它才是异常。否则，我们认为它不重要。基此原则，Polaris 专注监测客户端可观察的不变量的违例情况。
+
+高层讲，Polaris 以客户端的身份与有状态服务交互，并假定不了解服务的内部细节。这使其具有通用性。Meta有数十个 Polaris 集成。如“缓存应该最终与数据库一致”是 Polaris 监控的一个典型客户端可观察不变量，尤其在异步缓存失效时。此时，Polaris 伪装成一个缓存服务器并接收缓存失效事件。如若 Polaris 收到一个失效事件 “x=4 @version 4”，它就会作为客户端查询所有缓存副本以验证是否存在违反该不变量的情况。若某缓存副本返回“x=3 @version 3”，Polaris 会将其标记为不一致，并将该样本重新排队以稍后再次检查同一目标缓存主机。Polaris 会按一定时间尺度报告不一致，如1min、5min或10min。若该样本在1min后仍显示为不一致，Polaris 会将其报告为相应时间尺度的不一致。
+
+这种多时间尺度设计不仅允许 Polaris 在内部拥有多个队列以高效地实现回退和重试，对防止产生误报至关重要。
+
+### 更有趣案例
+
+假设 Polaris 收到一个失效事件“x=4 @version 4”。但当它查询缓存副本时，得到的回复 *x* 并不存在。此时，Polaris 是否应将其标记为不一致并不明确：
+
+- 可能 *x* 在version 3 不可见，version 4 写入是该K的最新写入，这确实是个缓存不一致问题
+- 也可能已存在一个version 5 的写入删除了键 *x*，或许 Polaris 只是看到了比失效事件中数据更新的视图更近期的数据
+
+为区分这俩情况，需绕过缓存并检查数据库内容。绕过缓存的查询计算密集型操作，也给数据库带来风险——保护数据库并扩展以读为主的工作负载是缓存最常见的用途之一。因此，无法发送过多绕过缓存的查询。Polaris 通过延迟执行计算密集型操作直到不一致样本跨过报告时间尺度（如1min或5min）来解决此问题。真正的缓存不一致和同一K的竞争写入操作很少见。因此，在跨过下一个时间尺度边界之前重试一致性检查，有助减少大部分需要执行这些绕过缓存查询的需求。
+
+此外，还在 Polaris 发送到缓存服务器的查询中添加了一个特殊标志。因此，在回复中，Polaris 可知目标缓存服务器是否已看到并处理了缓存失效事件。这点使 Polaris 能区分：
+
+- 暂时的缓存不一致（通常由复制/失效延迟引起）
+- 和“永久”缓存不一致——当缓存中的过期值在处理最新失效事件后仍无限期存在
+
+Polaris 生成一个指标，类似“在 M 分钟内，N 个 9 的缓存写入是一致的”。Polaris 提供了5min时间尺度的这些数字。即5min内，99.99999999% 的缓存写入是一致的。在 TAO 中，5min后不到每 100 亿次缓存写入中会出现一次不一致。
+
+将 Polaris 部署为一个独立服务，以便它能独立于生产服务及其工作负载进行扩展。若希望监测更高的 N 个 9，只需增加 Polaris 的吞吐量或在更长的时间窗口内进行聚合。
+
+##  6 编码示例
+
+一个咋产生缓存不一致的编码示例，看 polaris 咋帮 Meta 解决的一个 bug。设有一高速缓存，维护着K到Meta数据的映射和K到version的映射：
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*b0OLg-8qs95RIZ4glFefbQ.jpeg)
+
+```python
+cache_data = {}
+cache_version = {}
+meta_data_table = {"1": 42}
+version_table = {"1": 4}
+```
+
+1. 当读请求到来，先检查缓存值，如缓存中无该值，则从数据库返回该值：
+
+```python
+def read_value(key):
+    value = read_value_from_cache(key)
+    if value is not None:
+        return value
+    else:
+        return meta_data_table[key]
+
+
+def read_value_from_cache(key):
+    if key in cache_data:
+        return cache_data[key]
+    else:
+        fill_cache_thread = threading.Thread(target=fill_cache(key))
+        fill_cache_thread.start()
+        return None
+```
+
+2.缓存返回 None 结果，然后开始从数据库填充缓存。我在这里使用了线程来使进程异步。
+
+```python
+def fill_cache_metadata(key):
+    meta_data = meta_data_table[key]
+    print("Filling cache meta data for", meta_data)
+    cache_data[key] = meta_data
+    
+def fill_cache_version(key):
+    time.sleep(2)
+    version = version_table[key]
+    print("Filling cache version data for", version)
+    cache_version[key] = version    
+
+def write_value(key, value):
+    version = 1
+    if key in version_table:
+        version = version_table[key]
+        version = version + 1    
+
+    write_in_databse_transactionally(key, value, version)
+    time.sleep(3)
+    invalidate_cache(key, value, version)
+    
+def write_in_databse_transactionally(key, data, version):
+    meta_data_table[key] = data
+    version_table[key] = version
+```
+
+3.与此同时，当版本数据被填入缓存时，数据库会有新的写入请求来更新元数据值和版本值。此时此刻，这看起来像是一个错误，但其实不是，因为缓存失效应使缓存恢复到与数据库一致的状态（在缓存中添加了 time.sleep，并在数据库中添加了写入函数，以重现该问题）。
+
+```python
+def invalidate_cache(key, metadata, version):
+    try:
+        cache_data = cache_data[key][value] ## To produce error
+    except:
+        drop_cache(key, version)
+        
+def drop_cache(key, version):
+    cache_version_value = cache_version[key]
+    if version > cache_version_value:
+        cache_data.pop(key)
+        cache_version.pop(key)
+```
+
+4. 之后，在缓存失效过程中，由于某些原因导致失效失败，在这种情况下，异常处理程序有条件放弃缓存。
+
+   删除缓存函数的逻辑是，如果最新值大于 cache_version_value，则删除该键，但在我们的情况下并非如此。因此，这会导致在缓存中无限期地保留陈旧的元数据
+
+记住，这只是错误可能发生的非常简单的变体，实际的错误更加错综复杂，涉及到数据库复制和跨区域通信。只有当上述所有步骤都按此顺序发生时，才会触发错误。不一致性很少被触发。错误隐藏在交错操作和瞬时错误后面的错误处理代码中。
+
+## 7 一致性跟踪
+
+大多架构图用一个简单方框表示缓存。即使省略许多依赖和数据流，现实更接近如下：
+
+![](https://engineering.fb.com/wp-content/uploads/2022/06/Cache-made-consisent-image-7.png?w=1024)
+
+缓存可在不同时间点从不同的上游填充，这可能发生在区域内或跨区域。促销活动、分片迁移、故障恢复、网络分区以及硬件故障都可能导致缓存不一致。
+
+但如前所述，记录并追踪每个缓存数据的变化不现实。但若仅记录和追踪那些可能引发缓存不一致（或错误处理缓存失效）的缓存变更呢？分布式系统中，任一组件的细微缺陷都可能导致缓存不一致，是否有一个大部分甚至所有缓存不一致的引入点呢？
+
+我们得找到一个简单的解决方案管理这复杂性。希望从单个缓存服务器的视角评估整个缓存一致性问题。最终，缓存的不一致必须在某缓存服务器上体现出来。缓存服务器的角度，它关心：
+
+- 它是否接收到失效通知？
+- 它是否正确处理了失效通知？
+- 该节点之后是否变得不一致？
+
+![](https://engineering.fb.com/wp-content/uploads/2022/06/Cache-made-consisent-image-8.png?w=1024)
+
+这是文章开头解释的相同例子，现以时空图展示。关注底部缓存主机的时间线，可见在客户端写入后，有一个窗口期，在此期间，失效通知和缓存填充会竞速更新缓存。一段时间后，缓存会进入静止状态。在这种状态下，尽管缓存填充仍可能高频发生，但从一致性角度来看，其重要性降低，因为没有写入操作，它只是一个静态缓存。
+
+可构建一个有状态的追踪库，记录并追踪这个小紫色窗口中的缓存变更，在其中，所有有趣且复杂的交互都可能触发导致缓存不一致的错误。该库涵盖了缓存驱逐，甚至日志缺失也能表明失效事件是否未到达。它被嵌入到几个主要缓存服务和整个失效管道中。它会缓冲最近修改数据的索引，判断后续的缓存状态变化是否需要记录。还支持代码追踪，因此我们可了解每个被追踪查询的具体代码路径。
+
+这种方法帮助发现并修复许多bug。它提供一种系统性且更具可扩展性的方法来诊断缓存不一致问题，已被证明很有效。
+
+我们还观察到，该追踪库的实现具有高度灵活性：
+
+- 不仅可用于诊断缓存一致性问题
+- 还能扩展支持更复杂的使用场景。如通过简单配置，可将其应用于不同的数据存储服务。内置的代码追踪功能进一步帮助工程师快速定位问题的根本原因，从而大幅提升问题排查效率
+
+相比传统的日志记录方法，这种基于状态的追踪方式性能更优。它仅在可能引发缓存不一致的关键时刻记录数据，避免冗余信息的生成和不必要系统开销。这特适用于大规模分布式系统，性能开销降低会带来显著的整体效益。
+
+这种创新的方法不仅能够解决当前的缓存一致性挑战，还为未来分布式系统的诊断工具开发提供重要启示。
+
+## 8 记录一次bug修复
+
+![](https://engineering.fb.com/wp-content/uploads/2022/06/Cache-made-consisent-image-9.png?w=1024)
+
+某系统中，为每条数据分配了版本，用于排序和冲突解决。观察到：
+
+- 缓存中数据“metadata=0 @version 4”
+- 而数据库中数据“metadata=1 @version 4”
+
+缓存状态一直保持不一致。这种情况本不可能发生。若是你，咋解决这问题？若能获得导致最终不一致状态的每个步骤的完整时间线，这会多么有用？
+
+一致性追踪提供了我们所需的完整时间线：
+
+![缓存失效](https://engineering.fb.com/wp-content/uploads/2022/06/Cache-made-consisent-image-10.png?w=1024)
+
+在系统中发生了一种罕见的操作事务性地更新底层数据库中的两个表——metadata表和version表。基于一致性追踪，我们知道：
+
+1. 缓存尝试用version数据填充元数据
+2. 第一轮，缓存先填充了旧的metadata
+3. 接着，一次写事务原子地更新了metadata表和version表
+4. 第二轮中，缓存填充了新version数据。在这里，缓存填充操作与数据库事务交错。这种情况很少发生，因为竞争窗口很小。你可能想这就是bug。实际上到目前为止一切都按预期工作，因为缓存失效应该让缓存达到一致状态
+5. 后来，缓存失效在尝试更新缓存条目为新metadata和新version时到来。这几乎总是有效的，但这次没有
+6. 缓存失效在缓存主机上遇到了一个罕见的瞬态错误，这触发了错误处理代码
+7. 错误处理程序从缓存中删除了该条目。伪代码：
+
+```python
+drop_cache(key, version);
+```
+
+即若缓存中的version小于指定version，就删除该条目。但不一致的缓存条目包含了最新version。因此，这段代码啥也没做，导致缓存中的陈旧元数据无限期保留，这就是bug。这里对案例进行了大幅简化，实际更复杂，涉及数据库复制和跨区域通信。只有当上述所有步骤以这种特定顺序发生时，才会触发不一致。这种不一致很罕见，bug隐藏在错误处理代码中，交错操作和瞬态错误的后面。
+
+多年前，找到这种bug的根因需代码和服务非常熟悉的人费数周时间，且要幸运才能找到。而在这案例，Polaris 立即识别了异常并告警。借助一致性追踪的信息，值班工程师在不到 30min 内就定位该漏洞。
+
+## 9 总结
+
+本文分享咋通过一种通用的、系统性的和可扩展的方法，使缓存更一致。未来规划将所有缓存一致性提升到物理上可能的最高接近 100% 的水平。对于分离的二级索引，一致性带来了一个有趣的挑战。我们还正在监测并显著改善读取时的缓存一致性。最后，我们正在为分布式系统构建一个高级一致性 API——可以将其类比为 C++ 的 `std::memory_order`，但针对的分布式系统。
\ No newline at end of file
diff --git a/docs/md/biz-arch/linkedin-architecture-which-enables-searching-a-message-within-150ms.md b/docs/md/biz-arch/linkedin-architecture-which-enables-searching-a-message-within-150ms.md
new file mode 100644
index 000000000..23e2fe8db
--- /dev/null
+++ b/docs/md/biz-arch/linkedin-architecture-which-enables-searching-a-message-within-150ms.md
@@ -0,0 +1,113 @@
+# LinkedIn搜索架构独家解析：如何实现150毫秒极速响应？
+
+## 0 前言
+
+你在 LinkedIn 上收到一位老同事请求推荐的信息。你还在996，所以只是快速确认了信息，却忘记保存他们发的简历。几天后想起这段聊天，但又懒得滚动，于是直接输入关键词搜索：
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*xocsMb0aBN10ELhjIJDFcw.png)
+
+这简单操作正是 LinkedIn 消息搜索系统的全部功能。但为何这么流畅？幕后原理是啥？本文深入了解 LinkedIn 搜索架构及。
+
+## 1 搜索服务
+
+搜索信息的一个核心理念：每条信息的搜索都仅限于用户，即用户只能在自己的收件箱中搜索。这点很重要，因为我们知道搜索时只需搜索用户，可根据用户创建搜索索引。
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*7V8IUZAYSVycf39hQHAX-w.png)
+
+但Linkedin 的一大发现：并非所有用户都用搜索功能。因此，他们没有为每个用户创建和更新索引，而只为主动进行搜索的用户创建索引。这是为优化成本和写入性能，因为若为每个用户存储索引，索引就会存储在磁盘，而为每个用户创建内存索引的成本会很高。在写繁重的系统，将索引存储在磁盘中将意味着从磁盘中读取索引、解密信息、再次更新信息和索引、加密信息并再次将其存储在磁盘中，导致写效率极低。
+
+## 2  RocksDB: 存储信息
+
+LinkedIn 使用高性能KV存储库 RocksDB 存储消息。每条信息的数据结构都很简单，用键值对代表信息元数据：
+
+- **Key**: `MemberId | ConversationId | MessageId`
+- **Value**: The content of the message, 如："嗨，JavaEdge，你好吗？能帮我介绍一下这个职位吗？注意，Value是加密的
+
+当用户的收件箱中收到一条新邮件时，它就会以新记录的形式存储在 RocksDB 中，包括成员 ID、对话 ID 和邮件 ID。如：
+
+- `member-id1|conversation-id1|message-id1`
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*_wct8GPJtY01YfdNd1n-tg.png)
+
+
+
+## 3 使用 Lucene 进行反向索引
+
+现在，为搜索消息，LinkedIn 使用 lucene，它使用倒排索引--本质上是单词（或标记）到它们在文档（消息）中出现次数的映射。每条信息都被视为一个文档。如
+
+### 文件 1：
+
+```json
+{
+  "message": "Hi Mayank, how are you? Can you refer me to this position?"
+}
+```
+
+### 文件 2：
+
+```json
+{
+  "message": "Hi Mayank, can you refer me to this new position?"
+}
+```
+
+### 步骤 1：标记信息
+
+信息被标记为单个单词（忽略标点符号并全部小写）：
+
+**Document 1 Tokens**:
+
+["hi", "mayank", "how", "are", "you", "can", "you", "refer", "me", "to", "this", "position" ]
+
+**Document 2 Tokens**:
+["hi", "mayank", "can", "you", "refer", "me", "to", "this", "new", "position"]
+
+### 步骤 2：建立反向索引
+
+Lucene 通过将每个单词（标记）映射到它们出现的文档来创建倒排索引。下面是这两个文档的索引：
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*XIdUVT47N6XHT4sebxvtzg.png)
+
+#### 反向指数的解释
+
+- "hi "出现在两份文件中（信息-id-1 和信息-id-2）。它在两份信息中都位于位置 1。
+- "You "出现在两份文件的不同位置：在信息-id-1 的第 5 和第 7 位，在信息-id-2 的第 4 和第 6 位。
+- 在两份文件中，"refer "分别出现在 message-id-1 的第 8 位和 message-id-2 的第 6 位。
+
+### 步骤 3：进行搜索
+
+当用户搜索 "refer "一词时，系统将
+
+1. 在倒排索引中查找 "refer"。
+2. 发现它分别出现在信息-id-1 和信息-id-2 的第 8 和第 6 位。
+3. 然后，系统就能从这两份文件中快速检索出相关信息。
+
+LinkedIn 实施的一项重要性能优化是将索引存储在内存中，而不是磁盘上。这对性能至关重要，因为将索引存储在内存中可以加快搜索结果的速度，最大限度地减少延迟。当提出搜索请求时，系统会快速扫描内存中的索引并返回结果。
+
+## 4 咋决定何时创建索引？
+
+LinkedIn 不会自动为所有用户创建索引。相反，它会在有搜索请求时触发索引创建。具体操作如下：
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*XQx-sL2zVv-41qjybXfjPA.png)
+
+1. 搜索请求：当用户提交搜索请求时，系统会对 RocksDB 中的 MemberId 进行前缀扫描。这将检索与该用户相关的所有信息。
+2. 创建文档：为每条信息创建一个文档，其中包含成员 ID、对话 ID、信息 ID 和信息文本。
+3. 建立索引：将文件添加到索引中，索引存储在内存中，以便快速查找。
+
+## 5 分区
+
+索引在系统中的多个节点上进行分区，分区的依据是 MemberId 和 DocumentId。这样可以确保不会有任何一个节点因为来自某个用户的大量信息而不堪重负。
+
+为此，有一个协调器节点作为所有搜索查询的入口。协调器节点将搜索查询发送到各个节点，收集搜索结果，并根据相关性对搜索结果进行排序，然后将最终结果发回给用户。
+
+## 6 使用 Zookeeper 进行节点协调
+
+LinkedIn 依靠内部服务 D2（一种分布式协调服务）来维护系统中的节点信息。D2 帮助协调节点确定哪些节点应该处理搜索请求，确保查询被发送到正确的节点。
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*UQwhesTXgCGUdGkGsMssCw.png)
+
+此外，LinkedIn 还采用了粘性路由，这意味着针对特定成员的所有搜索请求都会路由到同一个副本。这可以确保搜索结果的一致性，并防止在多个副本上重建索引，从而提高性能和一致性。
+
+## 7 Conclusion: 结论
+
+我们研究了 Linkedin 所做的一些巧妙的设计决定，这些决定不仅帮助他们节省了搜索时间，还帮助他们降低了基础设施的成本。他们实施的内部搜索解决方案满足了他们的需求。
\ No newline at end of file
diff --git a/docs/md/biz-arch/title-launch-observability-at-netflix-scale.md b/docs/md/biz-arch/title-launch-observability-at-netflix-scale.md
new file mode 100644
index 000000000..7ab8a4612
--- /dev/null
+++ b/docs/md/biz-arch/title-launch-observability-at-netflix-scale.md
@@ -0,0 +1,71 @@
+# 大规模可观测性揭秘：Netflix 如何通过标题玩转全球内容发布？
+
+## 1  导言
+
+在 Netflix，我们每月管理着上千个全球内容发布项目，每年的投资额高达数十亿美元。确保每部影片在我们平台上的成功和可发现性是我们的首要任务，因为我们的目标是将每个故事与合适的受众联系起来，让我们的会员满意。为了实现这一目标，我们致力于建立强大的系统，提供全面的可观察性，使我们能够对我们服务中的每个标题负全责。
+
+## 2 可观测性的挑战
+
+作为工程师，我们习惯于跟踪错误率、延迟和 CPU 利用率等系统指标，但对标题的成功至关重要的指标呢？
+
+下面是两个不同的 Netflix 主页示例：
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/0*B4iyOBZJZEo7eW-p)
+
+主页样本 A
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/0*5F9ATQbyOp99jMwJ)
+
+样本主页 B
+
+对于一个基本的推荐系统来说，这两个示例页面可能看起来是等同的，只要浏览者观看顶部标题即可。然而，这两个页面却截然不同。每个标题都代表了无数小时的努力和创造，我们的系统需要尊重这种独特性。
+我们如何弥合这种差距？我们如何才能设计出认识到这些细微差别的系统，让每个职称都能发光发热，为会员带来欢乐？
+
+## 个性化系统的运行需求
+
+在 Netflix Originals 的早期，我们的发布团队会在午夜时分聚集在一起，手动验证影片是否出现在所有正确的位置。虽然这种亲力亲为的方法对少数作品有效，但很快就发现它无法扩大规模。随着 Netflix 在全球范围内的扩张和片头发布量的激增，维持这种手动流程所带来的运营挑战已成为不争的事实。
+
+在为全球流媒体服务运营个性化系统的过程中，需要处理大量有关特定时间和地点为何会出现或不会出现某些标题的询问。 举例如下
+
+- 为什么标题 X 没有显示在某个会员的 "即将推出 "行中？
+- 为什么巴西的搜索页面缺少标题 Y？
+- 标题 Z 是否按预期在所有产品体验中正确显示？
+
+随着 Netflix 规模的扩大，我们面临着越来越大的挑战，即如何为有关标题性能和可发现性的日益复杂的查询提供准确、及时的答案。这导致了一套分散在各个团队的零散脚本、运行手册和临时解决方案--这种方法既无法持续，也不高效。
+
+要确保每个标题都完美无瑕地发布，赌注就更大了。元数据和资产必须正确配置，数据必须无缝流动，微服务必须无差错地处理标题，算法必须按预期运行。这些操作需求的复杂性凸显了对可扩展解决方案的迫切需求。
+
+## 自动化操作
+
+随着时间的推移，我们逐渐发现，我们需要实现业务自动化，以便随着业务的扩展而扩展。当我们进一步思考这个问题和可能的解决方案时，出现了两个明确的选择。
+
+## 选项 1：日志处理
+
+日志处理为监控和分析标题启动提供了直接的解决方案。通过记录所有标题的显示过程，我们可以处理这些日志以识别异常情况并深入了解系统性能。这种方法有以下几个优点：
+
+1. 对现有系统造成的负担小：日志处理对现有基础设施的改动极小。通过利用常规操作中已经生成的日志，我们可以在不对系统进行重大修改的情况下扩展可观测性。这样，我们就可以专注于数据分析和问题解决，而不是管理复杂的系统变更。
+2. 使用真相来源：日志提供了系统事件的全面记录，是可靠的 "真相来源"。通过日志，我们可以验证标题是否按预期呈现，并调查任何差异。这种能力对于确保我们的推荐系统和用户界面正常运行、支持成功发布标题至关重要。
+
+然而，采用这种方法也会带来一些挑战：
+
+1. 提前发现问题：日志记录主要是针对启动后的情况，因为只有在向会员展示标题后才会生成日志。为了主动发现问题，我们需要提前模拟流量并预测系统行为。一旦产生人工流量，丢弃响应对象并完全依赖日志就会变得效率低下。
+2. 适当的准确性：全面记录要求服务记录包含和排除的标题，以及排除的原因。这可能导致记录的数据呈指数增长。使用概率记录方法可能会影响准确性，使人难以确定记录中缺少的标题是由于排除还是偶然。
+3. 服务水平协议和成本考虑：我们现有的在线日志系统不支持标题粒度级别的日志记录。虽然可以重新设计这些系统，以适应这一额外的轴，但会增加成本。此外，这些调查具有时间敏感性，因此不能使用冷存储，因为冷存储无法满足严格的 SLA 要求。
+
+## 方案 2：我们个性化系统中的可观察终端
+
+为了优先考虑标题发布的可观察性，我们可以采用集中式方法。通过在所有系统中引入可观察性端点，我们可以将实时数据流引入标题发布可观察性专用微服务。这种方法可将可观察性直接嵌入到管理标题发布和个性化的服务结构中，确保无缝监控和洞察。主要优势和策略包括
+
+1. 实时监控：Observability 端点可对系统性能和标题位置进行实时监控，使我们能够在问题出现时及时发现并解决。
+2. 主动问题检测：通过模拟未来的流量（我们称之为 "时间旅行"）并提前捕捉系统响应，我们可以在潜在问题影响会员或业务之前先发制人地发现它们。
+3. 增强准确性：可观察性端点提供有关标题包含和排除的精确数据，使我们能够对系统行为和标题可见性做出准确的断言。它还为我们提供了修复已发现问题所需的高级调试信息。
+4. 可扩展性和成本效益：虽然初始实施需要一定的投资，但这种方法最终为管理 Netflix 规模的标题发布提供了一种可扩展且具有成本效益的解决方案。
+
+选择这一方案也会带来一些折衷：
+
+1. 初期投资巨大：一些系统需要创建新的端点并重构代码库，以采用这种新的方法来确定启动的优先级。
+2. 同步风险：这些新端点可能无法准确反映生产行为，因此需要有意识地确保所有端点保持同步。
+
+## 下一页
+
+通过采用全面的可观察性策略（包括实时监控、主动问题检测和真实源调节），我们大大增强了确保在 Netflix 上成功发布和发现影片的能力，丰富了会员的全球观看体验。在本系列的下一部分，我们将深入探讨我们是如何实现这一目标的，并分享关键技术见解和细节。
\ No newline at end of file
diff --git a/docs/md/career/big-company-work-style.md b/docs/md/career/big-company-work-style.md
new file mode 100644
index 000000000..3f2ed870c
--- /dev/null
+++ b/docs/md/career/big-company-work-style.md
@@ -0,0 +1,133 @@
+# 大厂员工的做事模式
+
+## 0 你的问题，我知道！
+
+“他做事靠谱”、“他做事很厉害”、“他技术很牛的”。同一部门，级别一样，岗位职责一样，一个项目，为啥某些人做事就更靠谱、厉害？
+
+是他们态度更积极，更会表现？带过团队就知道，做事的态度和做事能力不等价。尤其在部门绩效拉通和晋升预审时，若你向其他部门负责人介绍时，说自己团队某人“做事积极主动，很认真，很拼”，多半被“怼”。
+
+“有两天晚上9点下班就算拼了？我们团队xxx做项目时都每天加班，周末也在干。”
+
+那管理者咋判断你的做事能力强否？
+
+## 1 做事能力判断标准
+
+### 1.1 闭环
+
+最基本的能力要素：做事，不能只是完成任务导向，而要从端到端角度，去思考和落地。
+
+无论何事，端到端过程都可分为：
+
+- 事前规划
+- 事中执行
+- 事后总结
+
+一般人只关注“事中执行”。
+
+#### 1.1.1 对那俩阶段不care
+
+##### ①  不是我负责
+
+对技术，需求是PM提的，需求上线后也是PM做业务分析，这些都不是你的本职。
+
+##### ② 不一定强制要求
+
+大部分混子中层TL是问题驱动型：
+
+- 完成项目任务
+- 或处理问题
+
+而不主动规划，因为规划费脑，得全面理解公司业务。于是，很多人完成任务就万事大吉，接着做下个任务，而不对当前任务总结，不会去想：
+
+- 哪些做得好，可传承
+- 做得不好，可改进
+
+若你有闭环思维，就算不是你自己负责或不是强制要求的事，你也会想方设法了解更多，思考以后怎么做更好，这就是[晋升原则]中的**主动原则**和**成长原则**。
+
+虽然你本职开发，但按闭环思维，做之前，除理解需求，还应了解：
+
+- 事前规划：“为啥做这需求”、“需求ROI是啥”
+- 事后总结：需求上线后，还应了解“需求上线后效果咋样？”、“具体业务数据咋？”、“通过做这项目，收获啥”
+
+若你本就端到端负责某事，更要会事后复盘、给领导汇报等技巧，而非做完事后被动等别人问结果。
+
+### 1.2 方法论
+
+有闭环思维，你做事就已比较靠谱。但事情能否做好，还看你的做事有无方法论：做事，不只靠经验教训的积累，还有一套系统流程或模板（SOP）。
+
+#### 1.2.1 优势
+
+- 无论遇到啥情况，都能有较好结果，保证交付质量下限。若只凭经验，则下次环境稍变，你就不适应
+- 你行为背后有一套逻辑支撑，而非拍脑袋得出，更具说服力
+
+如你说“我觉得XX业务功能可改改”，但又给不出充分理由，别人认为你瞎bb；但若用AARRR漏斗模型分析业务数据，在模型基础提出改进建议，别人接受可能性就大多。
+
+### 1.3 能拿好结果
+
+你可能虽有方法论，但方法论错的。你之前方法论可能厉害，但不适当前公司或业务。判断方法论好坏唯一标准，还是最后结果，给公司带来的价值，这也是晋升原则的**价值原则**。
+
+虽说拿好结果有运气成分，但剔除运气，方法论影响也大。这也是为何大公司高P，拿原方法论到中小企业，直接生搬硬套，水土不服。
+
+## 2 做事方法
+
+系统的做事方法论，按闭环思维的三阶段展开：
+
+![](https://p.ipic.vip/5ibnr9.jpg)
+
+### 2.1 事前规划
+
+OKR规划法：Intel提出、Google发扬光大，合理设定目标和分解关键成果，弥补KPI缺陷，用于制定工作规划。
+
+不同于传统KPI规划，OKR注重聚焦和逻辑，可理解为“OKR教你如何制定牛逼KPI”。
+
+### 2.2 事中执行
+
+#### 3C方案设计法
+
+制定多个备选方案，来系统地分析事情相关方方面面，避免思维狭隘，用于设计合理的落地方案。
+
+#### PDCA执行法
+
+美国人提出、日本人发扬光大。通过四环节循环，把控执行过程，保证具体事项高效高质地落地，用于推进事情执行。
+
+#### 5W根因分析法
+
+丰田集团提出，又叫“丰田五问法”，通过五个为什么来深挖问题本质，用于分析根本原因。
+
+#### 5S问题处理法
+
+通过五个步骤来解决问题，化“危”为“机”，用于系统地处理问题。
+
+### 2.3 事后总结
+
+#### 4D总结法
+
+通过四个维度来整理做事的收获，能够帮助你在完成任务后进一步全方位地提升自己的能力，用于事后总结。
+
+#### 金字塔汇报法
+
+参考麦肯锡的金字塔原理所提出的方法，通过遵循四个原则来展示工作成果，从而更容易获得高级别管理人员的认可，用于事后汇报。
+
+#### 四线复盘法
+
+通过四个角度来复盘重大问题，达到公平公正的处理效果，避免背锅和甩锅，用于重大问题发生后的复盘改进。
+
+## 3 总结
+
+- 当你不熟悉，可先照搬这些方法
+- 当你积累一定经验，别再局限本文内容了，可自己尝试总结新方法
+
+别忘了按那三条标准检验。
+
+- 做事能力，三条业界达成共识的判断标准：闭环思维、方法论和结果
+- 做事方法：分事前规划、事中执行和事后总结三阶段，包括OKR规划法、3C方案设计法、PDCA执行法、5W根因分析法、5S问题处理法、4D总结法、金字塔汇报法和四线复盘法等方法
+
+## 4 FAQ
+
+Q：咋做到知行合一？
+
+A：不断在实际工作总尝试和训练自己，让这些方法成为自己的自然反应。
+
+Q：时间久，要闭环事太多，咋保证无遗漏？
+
+A：装个TODO之类的app在手机或电脑用outlook等日程管理。
\ No newline at end of file
diff --git a/docs/md/career/how-i-tricked-my-brain-to-be-addicted-to-coding.md b/docs/md/career/how-i-tricked-my-brain-to-be-addicted-to-coding.md
new file mode 100644
index 000000000..875727755
--- /dev/null
+++ b/docs/md/career/how-i-tricked-my-brain-to-be-addicted-to-coding.md
@@ -0,0 +1,184 @@
+# 我是如何欺骗大脑，沉迷技术的？
+
+##  0 前言
+
+
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*IodtST4Qfwjaur7Pnn9kXg.png)
+
+是否想过，编码也能像玩游戏或刷抖音一样上瘾、充满乐趣？如果我告诉你，有一种方法可以让你的大脑像渴望游戏或社交媒体一样渴望编码，你会怎么做？
+
+在我的编码生涯中，我学习了 9 种编程语言，构建了 40 多个编码项目，，并通过了多家大型科技公司的面试。
+
+但我一开始并不是这样的。
+
+事实上，我的情况恰恰相反--我沉迷于电子游戏，花几个小时玩《王者》和《吃鸡》等游戏，而且长期在社交媒体。
+
+我是如何从电子游戏迷上编码的？
+
+本文分享帮助我迷上了编码的 5 个心理黑客，这些也可以帮助你重新连接大脑，享受编码的乐趣。
+
+## 1 我们的真正动力是什么？
+
+讨论 "如何 "之前，让我们先从 "为什么 "开始--为什么有些活动（如游戏）让人上瘾，而另一些活动（如编码）很难让人保持动力？
+
+答案就在于我们大脑中的一种叫做多巴胺的分子。
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/0*ITQ6kT-MylaVjthx.png)
+
+多巴胺是我们大脑中 "想要 "的化学物质。是它驱使我们去追求奖励，并让我们不断回来获得更多。当你在游戏获胜或在社交媒体获得点赞时，多巴胺会迅速迸发，使你立即获得奖励。
+
+但编码工作并不总是这样，至少在开始时不是这样。在编码工作中，回报往往是延迟的。学习一门新的编程语言或完成一个编码项目并不总能让你快速获得多巴胺刺激。
+
+但若能诱使大脑在编码时更频繁地释放多巴胺，使其感觉像游戏一样有成就感呢？
+
+## 2 条纹
+
+你是否注意到游戏和应用程序是如何奖励你每天出现的？这就是所谓的 "连胜"，它是一种强大的动力。如在 LeetCode 上，您每连续解决一个问题，就会增加您当前的连胜纪录。这促使我在准备编码面试时，每天至少解决一个问题。
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*w_UqVLWcIBidCVRN1xQHSQ.png)
+
+保持连胜成为一项有趣的挑战。
+
+在 GitHub 上也能看到同样的情况。每推送一次修改或贡献，你就会得到一个绿点，为你的进展创建一个可视化记录。这些绿点让你每天都想编码，因为你不想打破连胜纪录。看到自己的连胜纪录不断增长，你会感到很满足，也有助于你继续坚持下去。
+
+但是，保持连胜并不意味着你需要每天写几个小时的代码。有时，只要露面 10-15 分钟，就足以保持良好的势头。随着时间的推移，这些小环节逐渐增加，编码就会成为一种习惯。
+
+您可以通过在日历上标记天数或使用跟踪应用程序来创建自己的连胜纪录。
+
+> 每勾选一天，就会释放多巴胺，让你感觉良好，并激励你继续坚持下去。
+
+## 3 简单易行
+
+
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/5fa6006514bc25ef5208d3f7587f66c8.png)
+
+首先：一开始就尽可能简化编码。
+
+想想电子游戏--一开始新手村青铜总是很简单的。这是有意为之。早期的胜利会让你尝到成功的滋味，激励你继续前进。如果一件事一开始让我们感觉很容易，我们就更有可能坚持下去。所以很多人学 java...缺很少有人学 c++...
+
+刚开始学习编码时，不要马上进入复杂的项目或算法。相反，应从可实现的小任务做起。从小型项目开始：一个计算器应用程序、一个简单的游戏或一个基本的待办事项列表。
+
+这些任务看似简单，但这正是关键所在！完成这些任务会让你瞬间获得多巴胺--大脑中的小庆祝。
+
+如果你正在学习 LeetCode，请从简单的问题开始。每解决一个问题，都像是一次小小的胜利，它能释放多巴胺，让你流连忘返。这种正反馈循环有助于您养成每天编码的习惯。
+
+当你对简单的东西驾轻就熟时，感到厌倦了，赢麻了，就可以开始提升等级了。就像在游戏中一样，你现在已经准备好迎接下一个挑战，王者躺了十几个赛季，就想挑战荣耀王者了。
+
+但不要从 1 级跳到 10 级。请从 1 级跳到 2 级。这样，你就能挑战自己，既能提高自己，又不会感到力不从心。所以王者设置了那么多段位给你慢慢冲刺。当然最多的还是普通大学生，永恒钻石。
+
+它能欺骗你的大脑，让你觉得编码并不难，而且你想一直做下去。
+
+## 4 寓教于乐
+
+
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/c5584f606aa4101f7fbf6276e33c2a1b.png)
+
+其次，让编码变得有趣。我们中的大多数人开始学习代码是为了找到理想的工作或获得面试机会。
+
+但是，如果有那么一刻，你在编码时不用担心最终结果会怎样呢？想想你玩游戏--你玩游戏是因为它有趣、有挑战性，也许还有点竞争性。
+
+编码也可以是同样的方式。一开始，在没有任何压力和期望的情况下编码。我刚开始学习编程时，大学用的是 C 语言，说实话，感觉枯燥乏味，就像和机器人对话。
+
+我会觉得这是我为了取得好成绩而不得不学的东西，而不是我兴致勃勃要深入研究的东西。但当我在暑假期间学会了Java，情况发生了变化。这是我第一次觉得自己可以真正创造出一些东西。
+
+学习了基础知识后，我开始模仿制作一些小东西--先是一个简单的计算器应用程序，然后是乒乓球和俄罗斯方块等游戏，再到全栈应用程序。
+
+我只是为了建造而建造。我没有考虑成绩、面试或工作，只想着从头开始创造的兴奋。随着时间的推移，我意识到，当我真正喜欢上我所创造的东西时，我就会忘记时间，也正是从那时起，编码开始变得不仅仅是一项技能。它变成了一种激情。
+
+### 如何才能让自己享受到编码的乐趣？
+
+首先，选择真正令你兴奋的项目。忘记在 boss 某聘上给任何人留下深刻印象吧。专注于自己感兴趣的事情。
+
+这些项目非常简单，可以在短时间内完成，但又足够吸引人，让你兴趣盎然。
+
+这些项目不一定要具有投资组合价值，也不一定要改变职业生涯。
+
+这只是为了好玩，是一个没有压力的尝试和犯错的机会。
+
+> 当编码变得有趣时，它就会从你不得不做的事情变成你想做的事情。
+
+## 5 核对表
+
+
+谈谈如何将编码游戏化，每天奖励自己。
+
+答案就是制定一份任务清单，在完成任务时打勾。游戏中：每完成一个任务或关卡，就能获得勇者积分、上一颗星星或get新技能或仅仅是胜利的快感。
+
+这种奖励会引发多巴胺释放，让你继续玩下去。同样，也可将检查清单视为一系列小型任务。每当你从清单上划掉一个项目时，都会让你产生多巴胺刺激，帮助你保持动力，并让你继续回来做更多的事情。
+
+现在，创建编码核对表不仅仅是随意罗列任务。这就是把你的大目标分解成字节大小的任务。
+
+决定哪些任务对开始工作至关重要，并确定优先顺序。
+
+确定每天要完成的 1-3 项任务。
+
+在学习新知识时，应创建一份要涵盖的主题清单。尽可能细化，并添加子课题作为清单的一部分。
+
+比方说，你的大目标是 "成为一名全栈开发人员"。这令人兴奋，也令人不知所措。取而代之的是，把它分解成更小的步骤，如：
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*UTazkjioo7pg78UV_8YWyA.png)
+
+针对每一个步骤，深入研究并创建一份清单，列出您需要学习和构建的内容。
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*T_oc4OhXM_MEB7lbtRbU1Q.png)
+
+当你有了一份清单，每天都会感觉是一个小小的胜利。
+
+即使你没有完成所有任务，你也能清楚地看到自己的成就和剩余的任务。
+
+编码成了你想要回来的东西，只是为了看到清单上的内容越来越少。
+
+可用 Notion 等应用程序或简单的待办事项清单来创建清单并跟踪进度。
+
+## 6 新鲜感
+
+
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/d13d4cb0530872fb1328af9db65a32f4.png)
+
+好吧，让我们来谈谈学习中最强大但却被低估的一个方面：新鲜感。
+
+我们的大脑有寻求新体验的功能。每当我们尝试新鲜有趣的事物时，多巴胺就会释放出来。
+
+在编码工作中，新鲜感可以让你日复一日地投入其中，保持兴奋。如果没有多样性，编码工作就会开始变得重复，甚至枯燥乏味。我还记得第一次从 Java 转向学习 Python 时的情景--就像重新学习骑自行车一样。
+
+从语法到解决问题的方法，一切都感觉不同。但这种挑战也让人兴奋不已。保持兴趣的方法之一是探索不同类型的项目和技术。如果你已经从事开发工作一段时间了，不妨尝试一些不同的东西--也许可以制作一款游戏或尝试使用人工智能模型。
+
+每种类型的项目都会带来各自的挑战、工具和技能，给你带来新鲜感。新鲜不仅与学习内容有关，还与学习方式有关。有时，以新的形式呈现同一个主题，会完全改变你对它的感受。如果您一直通过视频学习，可以尝试动手操作项目或手写笔记。
+
+## 7  多巴胺排毒
+
+现在，让我们来谈谈听起来可能有点不舒服的东西--多巴胺排毒。
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/0*NvBYp1_cjVJsTzTc.jpg)
+
+多巴胺排毒疗法的原理是通过减少社交媒体和游戏等高多巴胺活动来重置大脑的奖励系统。
+
+当你降低这些即时奖励时，你的大脑会更容易接受来自生产活动的多巴胺，比如解决一个编码问题或完成一个项目。
+
+首先要确定哪些活动能让您立即获得多巴胺刺激，并能让您从编码工作中抽出时间。
+
+尽量避免在一天的早些时候进行这些高多巴胺活动。如果你的一天是从这些活动开始的，那么编码等重要任务就会显得不那么有吸引力。
+
+相反，把这些高多巴胺的活动作为奖励。
+
+在完成大量编码任务后，给自己几分钟时间上社交媒体或看视频。
+
+这样一来，编码就成了主要的关注点，分心就成了奖励而不是问题。当你奖励自己时，你就是在告诉大脑："这很好，我们再来一次"。所以，要庆祝你的胜利，哪怕是小小的胜利。
+
+## 8 总结
+
+
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/ba50f9ce62500915facab9666f28a497.png)
+
+最后，善待自己。并不是每一天都完美无缺，这完全没关系。
+
+有时你会遇到让你沮丧的错误，有时你会感觉不对劲儿，有时你会感觉进度不如人意。
+
+重要的是重新站起来，继续前进，哪怕只是向前迈出一小步。
+
+我知道我在这篇文章中分享了很多策略，你不必一一尝试。尝试一下，看看哪些能引起你的共鸣，并采用那些真正能让你更愉快、更持久地进行编码的方法。
\ No newline at end of file
diff --git a/docs/md/career/p6-promotion-guide.md b/docs/md/career/p6-promotion-guide.md
new file mode 100644
index 000000000..30118b47e
--- /dev/null
+++ b/docs/md/career/p6-promotion-guide.md
@@ -0,0 +1,222 @@
+# 大厂P6职级提升攻略
+
+P5核心能力要求：在他人指导下完成任务。若能从P5晋升P6，说明你已完成从学生到打工人，成长为一名合格员工。P6对应工作2～5年
+
+## 1 核心能力要求
+
+独立负责端到端任务。
+
+### 1.1 独立
+
+P6做的事和P5差不多，但无需人带。P5、P6都参加需求评审：
+
+- P5参加时只是在听
+- P6可能得针对需求直接提出意见
+
+### 1.2 端到端
+
+负责项目中的某部分功能的全流程相关事项：
+
+- 开发的端到端事项包括需求评审、方案设计、编码、修改bug和上线等
+- 测试的端到端事项包括需求评审、测试方案设计、执行测试和上线等
+- 产品的端到端事项则包括用户分析、需求写作、数据分析和竞品分析等
+
+P6、P7是大头兵，占团队60%～80%。P6主要提升目标是成为独立自主项目能手。
+
+## 2 技术目的
+
+掌握团队用到的技术“套路”。P6技术核心要求：熟练掌握端到端的工作流技术，因P6是项目主力，需参与项目流程中的某些阶段，完成任务。
+
+### 2.1 技术详细要求
+
+| 复杂度     | 核心要求                           | 详解                                                         |
+| ---------- | ---------------------------------- | ------------------------------------------------------------ |
+| 规模复杂度 | 熟练掌握项目端到端工作流需要的技术 | 1. 熟练可以从两个方面来衡量：<br/>(1)能够综合运用团队各项技术，独立完成任务；<br/>(2)能够指导 P5 应用这些技术。<br><br/>2. 端到端工作流指项目运作过程中，某个岗位全流程需要完成的事情。 |
+| 时间复杂度 | 不要求                             | 不需要自己进行技术规划。                                     |
+| 环境复杂度 | 熟练掌握团队已用技术               | 公司的基础技术平台，团队常用的框架、中间件、工具、第三方库等。 |
+| 创新复杂度 | 局部优化                           | 能够优化端到端工作流中的各个步骤的一些做法，比如代码重构、自动化脚本等。 |
+
+P6提升技术能力的关键：掌握团队用到的各种技术的“套路”。
+
+如Android开发，套路包括设计模式、SOLID设计原则、MVP架构和各类工具（比如Fiddler，Wireshark，tcpdump）等。不同岗位的“套路”不同，也可求助有经验同事。
+
+P5只要了解一些单个技术点；但P6须知怎么**整合**这些技术套路，完成端到端的项目开发任务。P6要知道如何将数据库、缓存、面向对象、设计模式、HTTP等技术点整合起来完成某功能开发。
+
+### 2.2  提升技术深度
+
+除了熟练使用套路，P6还要深入理解套路背后的技术原理和细节，提升自己的**技术深度**。
+
+设计模式为例，P5只知道每个设计模式啥意思，但P6要知道何时用设计模式，何时不用，具体用哪个。
+
+这也是P6能指导P5的原因：P5只知what，P6还知why。
+
+P6阶段提升技术时，易掉到陷阱：
+
+### 2.3 贪多求全
+
+你可能看了很多技术，其他人说起某个技术点的时候，你都有印象。但只是蜻蜓点水，无深入学习。
+
+### 2.4 正确做法
+
+重点抓住跟当前工作内容强相关的技术点和技术套路，深入学习和研究，重点提升技术深度。有精力再拓展学习一些暂时用不到、但以后可能用到的技术。
+
+千万不要因为短时间内什么流行就去学什么，一会儿学这一会学那，结果啥就懂一点，啥都不精。
+
+## 3 业务
+
+掌握所有功能，并深度理解处理逻辑。
+
+P6比P5提升主要体现在：
+
+- P6对功能掌握更全面；P5只掌握部分功能，P6基本要求掌握某类业务所有功能
+- P6对处理逻辑的理解更深刻；P5只需知道具体需求处理逻辑，而P6要求理解需求的“上下文信息”，如需求给用户/客户带来的价值是什么，解决啥问题，为何要设计5步而非3步，为何竞品功能设计不一样
+
+### 业务能力要求
+
+| 复杂度     | 核心要求                        | 详解                                                         |
+| ---------- | ------------------------------- | ------------------------------------------------------------ |
+| 规模复杂度 | 掌握某类业务相关功能及实现      | 1. 若采用微服务类似架构，“某类”指单个子系统的所有功能；若是较大单体系统，“某类”指单个模块的所有功能。<br><br/>2. 较简单的衡量方法：不管用啥架构，大概3~5人负责“某类”功能。无论行政组织结构看，这3~5人是虚拟团队，还是实际团队，都可据此法判断。 |
+| 时间复杂度 | 预测业务功能 1~3 个月可能的变化 | 1. 预测粒度是“单个功能”，目的是在需求评审和方案设计时，能更全面评估和理解需求。在此基础，针对性进行可扩展设计；或根据优先级，将功能拆为几个迭代开发。<br>2. 无需针对单个功能预测太长时间，如预测单个功能2年后可能变化，无太大意义 |
+| 环境复杂度 | 熟悉竞品类似功能的处理逻辑      | 若竞品比自己产品提前发布某功能，竞品已有实现可提供很多参考信息，助我们更快、更全面理解需求；<br><br/>若竞品和自己产品都做了某功能，可对比相似点、差异点更深一步理解需求，重点关注为啥会有差异 |
+| 创新复杂度 | 优化需求逻辑                    | 能针对产品设计的需求逻辑提出一些优化建议，如增加/删除/合并某些步骤，给某些步骤换种方式 |
+
+P6提升业务能力的核心方法：“5W1H8C1D”分析法。
+
+传统“5W1H”分析法，只关注需求的功能属性，所以我在“5W1H”基础上，增加对需求的质量属性（8C）和上线后效果（1D）的考虑。
+
+做好**竞品分析**也很重要。通过对比竞品和自己的产品类似功能的差异、优劣，你能够更好理解业务。
+
+## 4 管理
+
+负责项目中的子任务推进。
+
+### 4.1 具体的管理要求
+
+
+
+| 复杂度     | 核心要求         | 详解                                                         |
+| ---------- | ---------------- | ------------------------------------------------------------ |
+| 规模复杂度 | 负责子任务推进   | 1. 项目常含很多子任务，如开发项目按不同功能点划分为多个子任务，每个子任务也需要按项目管理流程逐步推进<br><br/>2. 能端到端完成子任务推进，包括人力评估、时间评估、问题跟进、风险预判和沟通协调等 |
+| 时间复杂度 | 制定子任务的计划 | 能较准确评估子任务时间和资源投入，并制定对应项目计划         |
+| 环境复杂度 | 熟悉上下游接口人 | 独立完成子任务推进，推进过程涉及与其它团队成员沟通协作，熟悉上下游团队接口人更有利任务推进，即“熟人好办事”。 |
+| 创新复杂度 | 项目级别的优化   | 总结项目经验教训，提出对应改进措施沉淀到项目流程或规范       |
+
+### 4.2 工作量评估：WBS分解法
+
+P6管理职责包括任务的工作量评估、计划制定及分配和跟踪等。
+
+工作量评估是P6核心职责，计划制定以及分配和跟踪，主要是配合项目经理来完成。
+
+工作量评估的准确性是第一步，直接影响后续工作合理性。掌握工作量评估的有效方法，也是P6管理方面核心力。
+
+很多人在评估工作量的时候无依据，心虚，若项目经理或产品经理稍微挑战，易退让，导致工作量压缩。到实际项目执行时，发现工作量评估偏少，为赶项目进度，就996。
+
+工作量评估方面，有的团队做法和WBS相似，列了一个子任务技术难点清单，然后分级，每个级别按照斐波那契数赋予难度系数。分析任务和方案时，开发人员也按照这个清单，评估工作量，避免主观评估了。
+
+#### 评估方法
+
+##### 拍脑袋法
+
+让团队有经验的人直接拍脑袋想一个工作量数字。
+
+##### 扑克牌法
+
+找3～5个人员，每人给一张小纸条，每个人把工作量评估写在纸条上，最后取平均值。
+
+##### 对比法
+
+参考曾经做过的类似的项目，看看之前的项目工作量是多少，然后以此为基础想一个数字。
+
+##### WBS分解法
+
+把需求拆解为多项小任务，单独评估每个小任务的工作量，然后汇总；评估小任务的工作量的时候可能采取上面这3种方法。
+
+WBS分解法效果最好，评估误差基本不超20%。Work Breakdown Structure，工作分解结构，通过把项目工作按**阶段可交付成果**分解成更小的、更易管理的组成部分，提升项目管理效率。
+
+朋友圈点赞为例，开发人员采用WBS得到如下任务分解表格：
+
+| 团队   | 任务项                                     | 工作量 | 备注                            |
+| ------ | ------------------------------------------ | ------ | ------------------------------- |
+| App    | 增加 1 个按钮                              | 2 人天 | 包括 iOS 和 Android             |
+| App    | 动态显示点赞列表                           | 4 人天 | 包括 iOS 和 Android             |
+| App    | 数据库增加“赞”的表格                       | 2 人天 | 采用 MySQL 存储即可, 不需要缓存 |
+| 服务端 | 添加赞接口                                 | 2 人天 | NA                              |
+| 服务端 | 取消赞接口                                 | 2 人天 | NA                              |
+| 服务端 | 查询赞列表接口                             | 2 人天 | NA                              |
+| 汇总   | 评估工作量: 14 人天<br>最终工作量: 17 人天 |        | Buffer 系数: 1.2                |
+
+对分解出的子任务项，就能用“拍脑袋法”评估。兼顾效率和效果，因子任务项已较小，凭经验就能得到较合理结果。就算单任务项有偏差，也是有偏多有偏少，最终偏差反而抵消。
+
+### 4.3 避免过于乐观：加Buffer
+
+大部分人评估较乐观，且项目过程中可能各种意外（如某开发或测试生病）。在实践中，为避免过于乐观评估给后面项目进度带来风险，往往采取加Buffer（缓冲），即将评估初步结果乘以一个大于1的系数作为项目工作量。
+
+若初评工作量14人天，Buffer系数1.2，最终项目计划时，参考工作量17人天：
+
+14*1.2 = 16.8 ≈ 17
+
+Buffer系数可在1.2～1.6之间浮动，一般根据项目的复杂度决定。全新的业务功能Buffer会高一些，在已有业务功能上修改时，Buffer较低。
+
+## 5 总结
+
+P6核心能力要求：独立负责端到端项目任务，成为独立自主“项目能手”。
+
+- 技术层，P6需掌握团队用到的各种技术“套路”，重点提升技术深度，学习避免贪多求全，优先深入学习跟工作内容强相关技术
+- 业务层，P6需掌握某类业务相关所有功能，并深度理解处理逻辑，主要提升方法：“5W1H8C1D”分析法和竞品分析
+- 管理层，P6需负责项目子任务推进，包括工作量评估、计划制定和沟通协调等。评估工作量推荐WBS分解法，先拆解成容易评估的小任务，然后独立评估每项任务，最后汇总
+
+## 6 FAQ
+
+Q：晋升评委咋分配三维在职级能力占比
+
+A：如下：
+
+- 技术7
+- 业务2
+- 管理1
+
+P6主要实现及性能质量保证，而业务和管理需要有这个意识。≥P7业务管理的占比就要提高。
+
+### 2B系统竞品分析
+
+2B系统底层通用能力或内部使用系统，如审核系统，数据报表系统等，咋竞品分析？看不到竞对类似功能！
+
+2B系统很多竞品资料可从客户获取，竞品资料和标书在市场部能搞到很多。内部系统确实难，一般只有技术大会能看到分享，但现在好很多，很多垂直领域技术大会，如GOPS（运维）、大数据峰会（审核、报表、风控等领域）、人工智能峰会等，多关注和参与。
+
+### IT岗业绩衡量标准
+
+如销售岗位员工有销售额业绩，运营岗位有用户活跃度等，这些都可作为工作业绩或成果，他们有明确目标，可以针对目标情况复盘总结哪里可以做的更好。
+而开发岗位似乎主要编码完成一个个需求，对应工作业绩或成果是啥？导致回顾自己的工作时，难以像业务岗人员那样有明确的目标可以得知自己哪里做的好，哪里不好。
+
+- 红线考核：如P2级以上生产问题，考评就是3.25
+- 质量考核：看你工作质量和效率，如bug数、版本delay数
+- 群体智慧（360、环评）：有的团队互相打分，或主管找产品运营项目经理或者合作团队等配合团队的人来评分
+- 主管凭感觉：各种会议、各种项目、各种事件处理过程中的表现
+
+技术岗位无法量化，不可能100%公平公正，但整体上来说，如果按照上面的方式来评，八九不离十。
+
+### P7、P8如何平衡技术和管理
+
+熟悉的工作内容和工作方法，原来这就是P6主要工作，我也曾做这些工作好长时间。回想做这些工作的时期，也存在一些问题，如领导挑战我的排期，我都退步，最后大部分是自己加班。
+
+
+在面对产品，运营需求，在他们描述完对上线后，我也产生了这些产出，这些收益的渴望，我也挺愿意早日上线的。一般，我会主动做出让步，这却使自己陷入长期，频繁的加班之中。当然，也做了很多事。和上下游各部门合作也愉快。
+
+
+加班不算什么，重要的是要把时间花在了更重要的地方，使自己成长更快。而努力的方向不对，则可能成为一个熟练，好用的工具人，一直不得成长。
+
+
+我的几个导师，都是再升一级做管理了。我却还想沉下心来搞技术，做到50多岁还写码那种。不知道那个级别的技术高工，工作内容都是什么样？
+
+管理和技术不冲突，尤其是你能够带着团队来做技术，那种感觉更爽，毕竟一个人的力量始终有限，发挥团队的力量才能干大事。
+
+### 业务开发，技术好像很难体现？
+
+怎么会呢？前端可以开发体验好的页面；后端可以设计高性能的索引，这些都是用户在使用业务的时候能直观感受到的。
+
+### 小公司运维如何破局
+
+小公司运维，就1-2人这种，什么都没有，管理服务器（包括云主机）也就是几十至300这样，上级一般是开发经理，他都不怎么懂运维，只会安排零散工作。连什么是运维项目、完整的运维流程都没接触过？怎么成长？也不知道在哪里找资料、书籍类。
+
+换个坑，回顾晋升三原则的价值原则部分，若公司就这规模，你水平高也不能为公司创造额外价值，更何况你连学习的机会都没有。运维书籍：谷歌的SRE、Netflix的混沌工程，还有DevOps的很多书籍。
+技术大会有GOPS等运维技术大会，有很多资料和演讲PPT都能搜到。
\ No newline at end of file
diff --git a/docs/md/career/why-hard-work-didnt-get-you-promoted-the-overlooked-truth.md b/docs/md/career/why-hard-work-didnt-get-you-promoted-the-overlooked-truth.md
new file mode 100644
index 000000000..abc756b6b
--- /dev/null
+++ b/docs/md/career/why-hard-work-didnt-get-you-promoted-the-overlooked-truth.md
@@ -0,0 +1,212 @@
+# 为什么你努力了却没升职？99%的人都忽视了这个真相！
+
+## 0 你的问题，我知道！
+
+- 我一整年工作这么拼，项目结果也不错，咋晋升挂？
+- 我在岗四五年了，而他就三年，为啥主管提名它？ 
+
+但这只是打工人视角看晋升的一厢情愿。
+
+### 晋升本质
+
+晋升并非奖励。若过去功劳特多，也应用绩效、年终奖奖励，而非晋升。大多企业，晋升也非论资排辈，不是你在岗位久，就该晋升。
+
+在企业角度才能看懂，晋升是企业的内部人才选拔，选拔：
+
+- 对公司未来发展更有价值
+- 能承担更大责任的人
+
+那这人才选拔标准到底是啥？大多从战功、能力、影响力及候选人与企业文化匹配度：
+
+```bash
+企业文化
+----------------
+
+    影响力
+      ▲
+      │
+     能力
+      │
+      ▼
+     战功
+```
+
+## 1 战功
+
+晋升基石，你拿到的结果，一般看你从上次晋升窗口到现在都：
+
+- 做啥项目
+- 拿到啥重要业绩
+
+我今年一直忙，做十来个项目，**项目质量**都很好，为啥晋升也无？这是你对“结果”一词不理解。
+
+项目质量是研发份内工作，做好是及格要求。况且，不是代码上线后，Bug 少，就是项目质量好。项目质量还包括：
+
+- 设计阶段方案合理
+- 提测代码 Bug 率少
+- 发布后还有完整监控方案及相关数据埋点
+- ...
+
+若你负责核心模块，还包括故障期间的降级预案等。
+
+而战功事关业务价值。给客户创造价值这事，你贡献啥？驱动业务这方面又创造啥价值？
+
+研发战功评估维度：
+
+### ①  业务数据
+
+如:
+
+- 智能营销的算法，通过模型迭代优化，助产品复购率提升多少？
+- 客户端研发，通过线上性能优化提升了多少首页秒开率，从而提升了多少新用户转化等等
+
+这些是硬通货，日常工作需提前做好数据埋点、数据回收。具备数据思维，让工作更有目标性。
+
+### ② 复杂度
+
+通常：
+
+- 重构项目复杂度＞现有模块维护
+- 高并发模块的性能瓶颈优化会一般的日常需求开发
+- 外部依赖多的项目复杂度＞纯内部项目
+- 项目负责人的挑战＞一般项目成员
+
+### ③ 创新性
+
+你的工作中哪些是你独创。
+
+你是只把部门成功经验复制到你的项目，还是从0到1做了一件新事？如部门要提升测试效率，但公司内无很好自动化测试实践，你从 0 到 1 把自动化测试框架搭建好，且在组内成功落地，这就是从 0 到 1。第一个“吃螃蟹”的价值被放大。
+
+## 2 能力
+
+晋升核心，战功虽重要，但非唯一，毕竟战功代表过去且可能有幸运因素，不完全代表未来。就像战功奖赏，绩效奖金都已兑现过了。作为人才选拔晋升，最重要考核因素是能力。
+
+一般企业都有职级能力要求说明。如阿里：
+
+- 校招P5
+- P6要求独立完成任务
+- P7技术专家，能独立带项目，具有复杂项目的设计和开发能力，具备一定的系统思考能力
+
+如你已P6多年，想知能力是否具备晋升到 P7，除日常需求开发高质量交付，还要看：
+
+### 2.1 系统思考能力
+
+- 你负责的业务域当前面临啥问题？
+- 这些问题之间关联关系是啥？
+- 解决这些问题ROI如何？
+- 这些问题解决的优先顺序啥？
+- 根据当前实际情况，合理规划是啥？
+
+这些问题统称为对某个方向的思考和规划能力，把这些问题思考清楚，并且形成清晰的规划文档和路线图，就没问题。
+
+### 2.2 带人拿结果
+
+- 有了规划，要针对问题设计合理技术方案，并落地执行拿到结果，持续推进这方向业务
+- 一般 P7 可能是一个领域负责人，还需要具备基础的带人去拿结果的能力
+
+### 2.3 专业技术问题
+
+日常工作能解决一些别人解决不了的技术难题，对日常技术有较全面了解，新项目技术选型有较清晰思路。
+
+深入了解职级能力要求，除公司内职级文档说明，也可参考身边相应职级的标杆同学，对比自己有啥差距？或和TL沟通，你希望有晋升机会，让他就你当前的状况给你更落地的方向指导。
+
+## 3 影响力
+
+外围因素，除了自己做事，有没有把自己能力辐射到别人，助别人一起成长。
+
+最简单的，你是否带过复杂项目或辅导新人成长，把自己做项目经验分享给别人？或帮助团队改进合作中的问题？如制定更好规范、SOP机制等助大家提效。
+
+你可能说，我干好自己的活，把项目做漂亮不就行？为啥管这些事？
+
+企业对员工的期待不但有业务价值，还有组织价值。企业希望组织里优秀人才越来越多，你个人能力强没问题，不过如你还能助别人也变强或团队提效，那就是为组织能力提升贡献，你的价值自然放大。
+
+## 4 企业文化
+
+筛选器，候选人与企业文化的匹配度，易忽视，它是一条隐含标准。晋升是企业选拔人，除战功和能力，也看这人能否和公司走得远，就要通过企业文化评估。认同企业文化，尊重企业价值观，才能更好协作拿结果。越是高阶晋升，这部分关注越多。
+
+## 5 个人咋得晋升机会？
+
+很多技术人存在两类典型心理：
+
+- 特别低调，认为做好自己事，老板眼睛贼亮，一定能获得晋升机会
+- 很着急，盯着下个职级定义，咬文嚼字，“我觉得自己都达到了，为啥不给晋升机会？”
+
+这些不但高估自己能力，还低估职场复杂度。先要：
+
+### 5.1 摆正晋升心态
+
+既然晋升本质是组织面向未来选拔人才，在晋升这事，我们和企业是命运共同体，企业业绩目标达到，发展好，个人才能享受企业发展红利，才可能晋升。
+
+啥时晋升机会多？显然企业高速发展期。业务飞速发展，每天有很多事历练，团队规模快速扩张，很多时候人被“拔着用”。
+
+那些自身素质不错的校招人“一年P6、三年P7”，不是神话。移动互联网飞速发展时期，团队要做新业务线试水。没人可用，只能让一个校招刚一年的小伙伴来当主程开发。他也靠谱，真把这个硬骨头啃下来了，第二年他顺理成章地得到晋升。所以说，晋升机会的多少跟企业发展阶段是息息相关。
+
+如一个团队：
+
+- 从10人扩大到100人，一定涌现很多晋升机会，需有人上去带带新人
+- 当下就是 100 人，到年底还是 100，甚至变90，那现有人才结构可能饱和，晋升机会一定少，和我们优不优秀无直接关系，大环境决定。
+
+职业发展≠升职加薪。即使先无晋升机会，不代表无成长。个人职业发展需回到自我身上。职位一时，只是该企业的一个Title，而能力在己身，离开公司也能带走。
+
+当然，若现有晋升机会，就要做好充分准备，抓住难得机会。
+
+### 5.2 日常提升
+
+#### 5.2.1 主动创造价值
+
+想获得晋升机会，最最重要是为组织创造价值，否则空有本领，但不能为企业所用。
+
+很多人一听创造价值，就只想到公司、业务线战略级项目。做重要项目，确实大概率放大创造的价值，有机会时确实应加入，甚至主动争取加入。
+
+但这项目可遇不可求，尤其业务增速放缓。如当下没有，你也不用过分沮丧。你可以看看自己的 +1、+2（也就是你的直接上级、上级的上级）在完成业绩目标上存在哪些挑战，在其中你可以做些什么？可能是某个重要模块的性能未来可能有瓶颈，可能是部门要提效，但相关基础库和组件的建设还不够等。
+
+这些事情有的可能是一些脏活累活，但对于业绩目标达成，对于团队长期发展又是非常重要的活。只要你去做，拿到结果，照样也能创造好价值。
+
+#### 5.2.2 主动成长，提升能力
+
+知道下个职级能力要求，对比自己与下个职级的能力Gap，主动学习提升：
+
+- 定向学习。如觉得复杂架构设计能力不够，去看组内那些大项目咋设计，琢磨为啥技术选型，考量啥，在稳定性建设上又是如何提前考量的。当然，也可以向别人请教，甚至付费学
+- 做中学习。大多能力在实践中提升，就像技术人学习新语言，从不是靠啃几本书，都是上手写代码，做项目，不断与Bug肉搏才提升
+
+因此，日常工作，也要不断创造更有挑战工作，如做更复杂项目，主动思考现有代码、系统优化空间？挑战中倒逼学习，实践长能力。
+
+技术能力提升无止境，最好围绕“能给公司创造价值”。你做ToB业务，业务面临问题可能不是服务性能瓶颈，而是咋快速交付，才能在市场竞争激烈、与客户谈判时有更多的筹码。你要尽快学习的不是高并发系统架构设计，而是咋提高交付效率，可能需了解一些敏捷开发、研发效能提升工具，再思考在系统架构上哪些地方可以优化，哪些可抽象？业界内相似的系统架构是咋设计？
+
+能力的提升要回到实际工作。
+
+#### 5.2.3 定期回顾，多思考总结
+
+大多数被提名晋升，最后答辩没通过的失败原因只有：平时没好好思考过自己工作。你一直埋头干活，全无复盘思考习惯？但晋升功夫在日常，不是突击。咋做日常回顾呢？
+
+##### ① 回顾工作与公司目标关系
+
+你做的模块、项目跟公司今年目标啥关系？围绕目标提升，你这模块做了啥？还可做啥？
+
+降本增效当下，建议增加经营视角：主动帮公司省钱，如：
+
+- 主动优化服务资源消耗，降低线上资源
+- 主动看业务链路中哪些环节可线上化，降低人力成本
+- ……
+
+这些工作可持续做。
+
+##### ②  回顾你的工作在行业内、公司内的水位
+
+比如你是做交易系统的，那你做的交易系统在公司内有没有类似的？你做的系统和别人比，有哪些好的，哪些不足？同样也可以看看行业内的系统，这样你就能非常清晰后续的优化迭代方案。
+
+##### ③ 向内回顾你的工作
+
+也就是你过去做的工作有哪些经验、教训、形成了哪些思考和方法论？哪些是可以帮助团队内成长的？把这些成果固化下来，固化的方式可以写经验 Wiki、做分享等等。
+
+当你把这些回顾工作做扎实，每项 TODO 都扎实落地，等晋升答辩时，你的通过率会大幅提升。
+
+## 6 总结
+
+业务每一个大大小小的需求/项目，成了程序员训练自身能力的源泉，在积极主动做事过程中立战功，强化自身能力（系统设计、拿结果、解难题），推动影响力（辐射他人）。正确看待晋升、复盘总结沉淀、功夫在平时。最终还需要企业文化认同，相信如果没有最后这条，一个人在一个地方也呆不久。
+
+晋升非奖励，也非论资排辈，而是企业一次人才选拔，对公司未来发展更价值，能承担更大责任者。
+
+想晋升，需主动为企业多创造价值，把自己能力提升到下个阶段水平，同时日常不断回顾，复盘总结。
+
+晋升重要，但非职业发展全部。建议战略上藐视，战术上重视。和日常一样，挣钱不是目的，而是结果。晋升也非目的，而是结果，是你创造好价值，能力也得到提升，当外界环境具备，水到渠成，不强求。修好内功才是职业发展最重要。
\ No newline at end of file
diff --git a/docs/md/career/workplace-jargon.md b/docs/md/career/workplace-jargon.md
new file mode 100644
index 000000000..6d69d2839
--- /dev/null
+++ b/docs/md/career/workplace-jargon.md
@@ -0,0 +1,80 @@
+# 你肯定听过这些职场“黑话”！
+
+### 0 开场白
+
+**大家好！**
+
+我是从业时长五年半，有着多年互联网私企的被裁经验，也算职场小油条了。今天咱们聊个话题——职场黑话。黑话是啥意思呢？诶，那肯定不是黑社会的行话！
+
+我们可以先从一个词的反义词来理解，比如白话，白话文，大家都知道，当年新文化运动，为了让大家都能沟通简单明了而推广，摈弃文言文那种晦涩难懂，曲高和寡，俗称不讲人话。所以就明白了吧，黑话是啥意思呢？诶，对了，就是高情商！委婉地把一些难听的话，包装得更具“艺术性”。
+
+------
+
+### 1 初入职场
+
+想当初，刚毕业的愣头青，自以为写了几年博客和代码了，靠技术好，肯定能一直升职加薪，早早退休！
+
+进了公司忙活大半年，年底开始绩效考核，才发现，年轻了！被主管1V1谈话时，说需要改改学生思维，我当时就蒙了啊！你说我这刚毕业的一个正经纯情大学生，肯定满脑子都是学生思维吧，这到底是啥意思啊？后来不断职场经历，才稍有感悟：
+
+- 只是以完成任务为导向，而非以拿到项目成果为导向
+- 以自我为中心，缺乏团队合作意识，不能有效的跨部门协作；
+- 一味被动接受组织安排的工作，缺乏主动性和owner意识，没有去主动思考如何改进工作流程、提高效率
+- 只是一味学习，很少关注咋应用到工作，给部门和公司赋能（这也是个黑话）。其实都是一边做项目，一边学习各种知识点
+- 凡事追求标准答案，一是一、二是二，缺乏思考和变通；
+- 畏难情绪重，做项目，怕这怕那，其实干就完了！先做出一坨屎，再去优化！
+
+然后，在平时工作中，我们也经常听到：
+
+- **你平时沟通有点耿直。”** 就是说你情商低，那你如果还听不懂，那真就太低了！
+- **“有点轴”** 当年同桌一个十年经验的老程序员给我指示技术方案时说的，就是有点死板，给你画什么流程，你就完全按这个流程去写，也不主动多考虑其他可能或任何异常情况容错
+- **“随便写。”** 你写得肯定都不行，我到时就知道不该咋写了
+- **“在吗？”** 这个比“你干嘛呢”还恐怖。谈过恋爱的同学都知道，这个一般和对象聊天，想对方了都这个开场白对吧。但这是职场啊，领导又不是想潜规则你，所以一般就是有不好的事要来了。比如可能看你最近表现不行，问问你是不是想跑路了呀，或者裁员指标想给你了，可能有点于心不忍，先问候下你
+- **“赋能”**：你得想个法儿给公司省钱，比如用cursor啊，用 chatgpt 啊提高你的其他能力，就不用再招人做了，你都给他干了。其实这还好，最怕的就是外行的领导指导内行，一个通过营销号看到什么东西觉得有用，但其实是没用的，让你来赋能，这你就难受了！
+- **“颗粒度”**：当年转正述职，给主管们讲解 PPT 时，你这颗粒度不够啊，我当时还以为是颗粒感，毕竟这个经常看马赛克的同学都知道，我说要不我把分辨率放大点，或者你坐近点？其实是报告精细程度不够，一件事，可能解决一个重大 bug，得交代清楚背景前因后果，咋发现的，然后解决思路和阻塞点，最后复盘总结一条龙，要形成一套方法论出来！
+- **“降本增效、优化、毕业，输送”**：就是：裁员！初衷是好的，把工作态度差的，天天划水摸鱼或经常出严重事故的人干了，但现实错综复杂，公司内部各种势力交错，维护嫡系利益，顺便把一些不好管的刺头干了。精准地把平时最卖力干活的老黄牛都裁了。然后等出了阿里云、滴滴、支付宝大范围的宕机事故，营销号们就说公司裁员裁到大动脉了
+- “对标”：就是你抄谁的
+- “倒逼”：被逼无奈
+- “落地”：这活得有人干
+- “格局”：你得让我占点便宜，比如一个人当全干用
+- **“你是专业的，相信你。”**：你办事，我放心。听着像夸你，其实是把锅扔给你。做出问题都你的，做好了，功劳我就拿去了，到时看心情给你喝点汤
+- “我是部门领导，出事了我肯定第一责任人”。但真出事了吧，那些开除和通报的都是实习生、临时工，甚至字节的实习生啊，还被要求索赔几百万。所以我们说工作必须留痕。这也就能理解为啥经常看到甩锅问题。因为多做多错，少做少错，不做不错，不错不错！
+
+这些其实也都来自阿里职场文化，像现在大环境不好，平时领导说话不像以前画大饼了，而是画“三明治”，就是左一句夸你，右一句批评你。比如你今年做的事还是蛮多，很辛苦，但是吧，还得多加强owner意识，再多主动承担一些职责，一些跨部门沟通和快速解决问题能力还得再提升。不过总体还是不错的，今年先给你个普通绩效，努努力，明年最佳绩效肯定是你的！真到了明年，就会说大家都一个水准，你就继续是普通绩效。
+
+------
+
+### 2  面试
+
+因为多年被裁经验吗，所以自然这个面试经验也是老司机了。才发现招聘简直就是一套黑话模板全国统一话术啊：
+
+- **“上升空间大”**：公司没几个人，只要你随便干干，就成技术骨干了
+- **“扁平化管理”**：也是没几个人，公司行政职级规划就是摆设，只要是上级，都是下级的领导，都能给你派活；
+- **“双休、五险一金”**：对正规遵守劳动法的公司说是标配，但对一些小作坊，这真的是老板愿意给的最大福利了！国企下限是劳动法，私企上限才是劳动法；
+- 包装简历啊，听过就是了解，用过就是熟练，用的比较多，那就是精通，实则工作中还真是这样，但招聘里面全部默认上升一级！
+- 离职原因：更不能说实话了，比如你不能说钱少，不能说天天受委屈，不想给别人擦屁股。你得说现阶段没有啥成长了，想接受更大的挑战，去更好的平台，说清楚自己的职业规划。
+
+------
+
+### 3 PUA
+
+很多人上班上着上着就上出班味儿了。每天感觉上班如上坟，私企里经常哀嚎遍野，主要还是互联网红利都被吃尽了，现在都是条条大路做牛马 ，360行，行行干破防。
+
+再加上很多一些私企没啥能力的靠时间和跪舔混上去的领导，最擅长的就是帝王驭人术，也就是PUA，比如一到考核述职就说：
+
+- 为什么是你来做，其他人不能做吗？
+- 你有自己的判断力吗？你有自己的思考吗？你有自己的一套打法和方法论吗？难道还要我来天天手把你叫你咋做吗？那还要你干嘛？
+- 以后，把你的思考沉淀到日报、周报、月报里，我希望看到你的进步，而不仅是进度
+- 你的产出和效率，和同层级比，是比较单薄的，你看咱们团队的那个谁，干活都勤勤恳恳尽职尽责的，做得又好又快，你为啥不行？多和人家学学啊？
+- 成长，一定是伴随着痛苦的，当你最痛苦的时候，才是你成长最快的时候
+
+很多这样，通过精神和情感控制，让你由外到内的全身心怀疑自己，让你持续感到工作压力和焦虑感，从而更好的卖命，来讨好上级，以求得到上级的肯定，让他能早提新房新车。为啥说无能呢？他们也不知道咋推进项目，也不会和你说具体咋改进，也没具体做事标准，全凭一张嘴，否定你自以为没有功劳也有苦劳的一切精力付出。
+
+所以你看到私企里很多人啊：甲状腺结节，颈椎病、腰酸背痛、偏头痛、加班猝死、投河跳楼、焦虑躯体化症状啊。对于这些，老祖宗的五行学说早就说清楚了：
+
+生气就是火，火大克金，那就挣不到钱。水能克火，所以上班需要经常摸鱼划水！资本家为啥能赚大钱呢？因为土能生金，土就是没事时看不见，有事就和稀泥。然后领导也会经常说我脑袋不太灵光，有点轴，也没问题，因为金克木，钱不到位，人就容易麻木。
+
+### 4 总结
+
+上班，其实就是各取所需，员工出卖体力和脑力，换取金钱和经验。企业支付工资，以获取更大利润。所以一切背离这些本质价值交换的，都不用太在意。
+
+最后我想一句话结束今天话题：少一些黑话，多一点真诚，因为**真诚永远是必杀技**！谢谢大家！
\ No newline at end of file
diff --git a/docs/md/career/workplace-rule.md b/docs/md/career/workplace-rule.md
new file mode 100644
index 000000000..18b50c001
--- /dev/null
+++ b/docs/md/career/workplace-rule.md
@@ -0,0 +1,200 @@
+# 职场真相：努力加班≠好绩效，你必须懂的职场规则！
+
+## 0 你的问题，我知道！
+
+没有职场认知而产生的疑惑：
+
+- 遇到问题就死磕，觉得问人丢人，麻烦别人不好意思，结果问题没解决，自己先纠结半天；
+- 觉得工作特努力，常加班，但好绩效无缘
+- 面临裁员，愤怒为什么裁我，又因无规划，觉得惶恐
+
+这些问题是不是很眼熟？你或多或少也想过？其实，认识职场就是：
+
+- 认识职场的底层规律，即“游戏规则”
+- 底层规律之上，还要理解职场的事和人
+
+## 1 职场的“游戏规则”
+
+### 1.0 职场由来
+
+工业革命带来机器化大生产，带来细化社会分工，产生这么多岗位。互联网会有市场、运营、产品、研发、测试等等岗位，大家有工作，才有现在职场。
+
+职场看作游戏，有如下“游戏规则”。
+
+### 1.1 职场人都是工具人
+
+每个岗位的工作，都承载了公司体系内的一部分功能，最终形成合力，实现整个体系的目标，而我们就是每一个部分的工具。
+
+- 销售谈客户，了解客户需求
+- 产品把需求转换成需求文档
+- 研发为实现需求写代码
+- 测试验证功能，最后发布
+- 运维保障线上安全
+
+虽分工不同，但都是实现目标的工具。分工是为每个人精力更聚焦，在一个岗位又精又专。
+
+理解“工具人”本质，就明白很多事了。社会大分工体系强调：
+
+- 技能，立足根本，每个岗位都有专业能力要求。企业雇佣一个技术人，一定会看专业技能，如编程能力，问题分析定位能力、管理能力
+- 服从性，连接他人的根本。一定的服从性让每人基于分工，更好围绕目标协同
+
+问题：
+
+#### ① 公司“既要”“又要”“还要”，心累！
+
+企业是雇佣方，肯定给员工提很多要求。既要、又要、还要的企业目标，是为更好协同，拿结果or其它？
+
+若为更好结果提出要求，打工人确实要去适配，实在无法适配，环境就不适合你的职业规划了。
+
+#### ② 想引入新技术，常被老板按倒，无奈！
+
+如一个前端爱技术，总在工作引入新技术，但导致页面加载慢，测试验证成本和线上维护成本高。在自己角度，觉得新技术引入不易，但难拿好结果。因为分工协作体系，光有技术不够。
+
+引入新技术，还得考虑 ROI，与现有产品兼容情况，测试验证成本，维护成本等。所以，服从性也可理解为协作中为整体的团队和产品考虑，毕竟企业不是实验室，需为结果负责。
+
+### 1.2 只认结果
+
+🐂🐴岗都是围绕企业目标服务，围绕为客户创造价值服务，即结果导向。而非你做多少项目，写多少代码，引多新技术，而是看你的事给公司创造啥价值。
+
+结果导向评价体系，对目标明确，个人情感色彩少，保持激进的人心理摩擦力小。和个人特质，甚至每人“出场设置”有关。如果你不是这样的人，别轻易给自己“玻璃心”的标签，可在理解职场规则同时做自我管理。
+
+这条规则可很好帮你理清两个方面的困惑，先看问题：
+
+#### ① 我这么努力，咋低绩效？
+
+领导为啥“看不到‘我’努力”。加班、努力是过程，对过程，企业最多鼓掌打气加油，只有结果，企业才买单。
+
+一个厉害的技术人，年年高绩效，而今年从一线升为技术管理者，工作更努力了，却只拿普通绩效，觉委屈。因为是技术管理者了，考核结果是团队拿到的结果及团队拿结果的能力。他才意识到，自己虽拼，但团队没成长，才意识到管理者的角色要求，找到后续努力方向。
+
+所以在职场，如你努力，结果不好，还是回到目标，看努力方向对否。
+
+#### ② 工作卷，有意义吗？
+
+既然结果导向，工作环境又卷，得区分当前是：
+
+- 面向结果卷：更好更快给客户交付结果
+- 无意义的卷？暗比谁加班多，谁更哄领导开心。作为知识工作的技术人，显然不是靠加班就能带来结果根本改变，还是要回到业务目标，不断思考围绕目标可做的贡献
+
+### 1.3 职场复杂且模糊
+
+上学时，学校有明确考纲，只需每天刷题，成绩就会不错，而且成绩是一切指挥棒，成绩好老师就喜欢你，也能上好大学，万事大吉。简单清晰又明确。
+
+而职场无明确考纲，OKR也随着市场变而变，很多角色协同才能拿结果，不是靠个人努力“刷题”就有好绩效。问题：
+
+#### ① 为啥部门总变动，公司疯了?
+
+- 企业处变化的市场，去年要 ALL IN 的业务，今年可能市场冲击，需转型
+- 或方向没变，但要重排兵布阵
+- 子公司和集团总部之间的博弈
+- 组织有很多角色，运营、产品、技术、BI、HR、法务、行政等，这些角色协同，出现“抢活”、“踩脚”
+
+所以职场常“组织调整”。
+
+#### ② 领导总突发奇想，让弄下这，弄下那，又没有流程，咋办？
+
+“弄下这个”，到底咋弄？在这么复杂组织，大概率无SOP，尤其国企。若还持有学生思维的“刷题 - 考试”，大概率这件事没结果。那咋办？
+
+还是主动！职场是“混龄班”：
+
+- 上学时，你同学再优秀，你俩年龄也差不太多，认知水平差小
+- 而职场常有一个工作十几年的人，和工作十几天的人在一组，很多“隐形经验”藏在工作时间更长的同事的脑海。明白为啥要主动了？
+
+职场人需理解：
+
+- 没有一个系统是完美的，所有东西都在动态变化。阿里的拥抱变化没错，很多变化不是你能控制，要理性看待
+- 摒弃只需好好学习的“学生思维”，因为无人帮你把所有东西准备好。你得更积极和前辈请教求助，甚至跨团队、跨组织和跨级别，才能更快学到工作的“隐形经验”
+
+当微观环境让你不舒服，也可主动优化，去优化流程，让复杂系统运转更流畅。
+
+## 2 面对游戏规则，咋办？
+
+### 2.1 放弃幻想
+
+#### ① 干到退休
+
+很多人有职场幻想：我在一家公司多年，如接受不涨薪躺平，能干到退休？
+
+职场中，任何人都可替代。
+
+回忆自己从小白变成职场老油条。用一个不恰当的比喻，公司能“生产”你，一定还能“生产”跟你一样优秀的小王、小张、小李。除非高精尖领域，我们这代大概率不可能在企业干到退休。所以工作之外，要突破打工人思维，把焦点回归自己身上，为长远发展未雨绸缪。
+
+当下若不幸被裁，也别陷入情绪沼泽，这是企业作为商业组织在当下市场环境中要做的选择。大概率和你个人无关，非针对你，非你不优秀，无需妄自菲薄。向前看，回到广阔市场，继续找自身价值和位置。
+
+#### ② 工作当人生寄托
+
+当成就感、价值感、甚至幸福感来源。但职场承载不了太多。
+
+职场无同频伙伴，很正常，可工作外找，构建自己稳健的社会支持系统。
+
+若工作无法满足成就感需要，主动挖掘工作价值，寻找自我成就感与企业要求的“最大公约数”，如：
+
+- 工作已轻车熟路，可能会发现帮助团队小伙伴成长给自己带来极大成就感，而大家对成长需求正好也摆在那，“最大公约数”就来了。主动分享，沉淀输出
+- 若工作中找不到，也可工作外找能带来成就感事，如助人或公益
+
+若渴望乔布斯“改变世界”，实现使命和价值，只能创业。
+
+### 2.2 最大化“工具人”价值
+
+作为工具人的我，应早早自我保护？给多少钱，干多少活？
+
+不！这绝对浪费生命。职场工作时间有限，黄金打工时间很短。注意是打工，而非工作、创业或其他副业。国内22本科毕业，40+跳槽可能面临被挑三拣四，大多人黄金打工时间最多就不到20年。得珍惜打工时间，充分利用。既然在职场本质工具人，就最大化挖掘“工具人”价值：
+
+#### ① 别只盯住岗位价值，还要抓住环境提供的价值
+
+按企业要求，需按岗位要求，完成工作内容。但对个人，职场也是锻炼机会，大多能力成长都是工作做事而得，所以要不断给自己创造机会，提升能力。
+
+咋做？若发现工作挑战不大，至瓶颈期，别只抱怨或等老板给你安排更有挑战活。你可主动多承担，如思考团队的问题，可做啥贡献？可和TL申请加入更有挑战工作。一定要牢记为成长负责。
+
+之前老板要策划一个 500+ 人年会，需总体负责人。跟日常做技术管理的我有关系？没有，却主动请缨报名。完全硬头皮上，就想有突破，这么大型活动，一定需要很多不具备能力，而这相当于公司出钱，出人，给我历练机会。最后年会完美交付，我发现自己平时带团队的经验有很多可以平移到组织年会，还解锁跟销售谈判，挖掘技术人编码外的潜力，最重要的是对跨界有很多信心。
+
+#### ② 积累领域经验和相应的人脉资源
+
+职场提供真实场景，让我们在某行业某场景解决问题。如一直做金融领域，你可能对这个行业的模式以及常见的问题有深入了解，时间久认识不少领域的人。
+
+你过去的领域经验、人脉可帮你平滑找到下份工作。如对当前领域愿钻研，也可像持续深耕，做领域专家。
+
+这也能是未来更多可能性的起点。我一个朋友 43 离开职场，本打算休息阵，结果朋友创业，企业很多架构问题困惑，邀请他指导，发现他不但能准确分析、梳理问题，更能一招见效解决，于是又让他给团队做架构设计培训。
+
+后来慢慢口碑也做出，成了专职服务企业的培训师和技术顾问。而这方面经验都是职场十几年沉淀，大部分企业客户都是自己原来同事或同事推荐。
+
+他说上班时，没想过走这路，也没刻意设计，只是随工作，沉淀和积累顺手的事。
+
+若说一个人的职业发展最终是为实现人生使命，那职场这游戏与你的使命关系如下：
+
+```bash
+                    +---------------+
+                    |   使命召唤    |
+                    +---------------+
+                           |
+                           |
+                           v
+                    +---------------+
+                    |     职场      |
+                    |   "游戏场"    |
+                    +---------------+
+                   /                 \
+                  /                   \
+                 /                     \
+                /                       \
+    +---------------+               +---------------+
+    |  技能/能力    |               |  认知/资源    |
+    +---------------+               +---------------+
+```
+
+完成工作同时，再有意识提升技能，锻炼综合能力，提升对行业、领域认知，积累经验和人脉，当底座越来越稳，探索到人生使命，自己真正热爱、愿意终生投入的事业时，这些积累都能更好地帮助我们把“使命召唤”发光发彩。
+
+## 3 总结
+
+工作是双向选择：
+
+- 优秀的人离职，不代表团队不好，可能他的职业阶段有新目标
+- 你掏心掏肺几年业务说没就没，不是运气不好，也不是公司瞎折腾，可能市场变化，从长远角度须做出的决定
+
+工作中，你都是自己职业发展主人。成就感不只是岗位本身带来，更是自己挖掘。优秀人离开，反而你机会来，离开半死不活业务，你可能有更好发展。别被一份工作困住身心，都是双向选择。
+
+打工人：
+
+- 客观理解职场的游戏规则
+- 最大化自己的职场价值
+
+黄金打工时间短，终离开职场，但职场历练技能，积累资源和人脉，都是无形资产。
\ No newline at end of file
diff --git "a/docs/md/career/07-\347\273\217\345\270\270\350\242\253\345\216\213\347\274\251\345\274\200\345\217\221\346\227\266\351\227\264\357\274\214\345\273\266\346\234\237\350\277\230\350\246\201\350\203\214\351\224\205\357\274\214\345\246\202\344\275\225\347\240\264\345\261\200\357\274\237.md" "b/docs/md/career/\347\273\217\345\270\270\350\242\253\345\216\213\347\274\251\345\274\200\345\217\221\346\227\266\351\227\264\357\274\214\345\273\266\346\234\237\350\277\230\350\246\201\350\203\214\351\224\205\357\274\214\345\246\202\344\275\225\347\240\264\345\261\200\357\274\237.md"
similarity index 99%
rename from "docs/md/career/07-\347\273\217\345\270\270\350\242\253\345\216\213\347\274\251\345\274\200\345\217\221\346\227\266\351\227\264\357\274\214\345\273\266\346\234\237\350\277\230\350\246\201\350\203\214\351\224\205\357\274\214\345\246\202\344\275\225\347\240\264\345\261\200\357\274\237.md"
rename to "docs/md/career/\347\273\217\345\270\270\350\242\253\345\216\213\347\274\251\345\274\200\345\217\221\346\227\266\351\227\264\357\274\214\345\273\266\346\234\237\350\277\230\350\246\201\350\203\214\351\224\205\357\274\214\345\246\202\344\275\225\347\240\264\345\261\200\357\274\237.md"
index fc43115bd..6ccc5528d 100644
--- "a/docs/md/career/07-\347\273\217\345\270\270\350\242\253\345\216\213\347\274\251\345\274\200\345\217\221\346\227\266\351\227\264\357\274\214\345\273\266\346\234\237\350\277\230\350\246\201\350\203\214\351\224\205\357\274\214\345\246\202\344\275\225\347\240\264\345\261\200\357\274\237.md"
+++ "b/docs/md/career/\347\273\217\345\270\270\350\242\253\345\216\213\347\274\251\345\274\200\345\217\221\346\227\266\351\227\264\357\274\214\345\273\266\346\234\237\350\277\230\350\246\201\350\203\214\351\224\205\357\274\214\345\246\202\344\275\225\347\240\264\345\261\200\357\274\237.md"
@@ -1,4 +1,4 @@
-# 07-经常被压缩开发时间，延期还要背锅，如何破局？
+# 经常被压缩开发时间，延期还要背锅，如何破局？
 
 ## 0 前言
 
diff --git "a/docs/md/career/\350\275\254\345\236\213\344\274\240\347\273\237\350\241\214\344\270\232\351\201\277\345\235\221\346\214\207\345\215\227.md" "b/docs/md/career/\350\275\254\345\236\213\344\274\240\347\273\237\350\241\214\344\270\232\351\201\277\345\235\221\346\214\207\345\215\227.md"
new file mode 100644
index 000000000..a3c0a983d
--- /dev/null
+++ "b/docs/md/career/\350\275\254\345\236\213\344\274\240\347\273\237\350\241\214\344\270\232\351\201\277\345\235\221\346\214\207\345\215\227.md"
@@ -0,0 +1,147 @@
+# 转型传统行业避坑指南
+
+## 0 前言
+
+大环境不好，很多程序员被优化，被逼转型传统行业，但：
+
+- 不同级别的人，咋融入传统行业？
+- 转型传统行业的同学会经历哪 3 个经典阶段？
+- 入局后的“坑”
+
+## 1 不同阶层，咋转型传统行业？
+
+### 1.1 高层
+
+总监及总监以上的 VP、C*O 等。最重要的是想尽一切办法找到价值，同时带领团队做出有价值的事：
+
+- 找价值
+- 建团队
+
+#### 1.1.1 找价值
+
+大多去传统行业做数字化转型的高P，原是互联网大厂中层，面临挑战：
+
+- 大厂中层难接触业务一号位，也基本无需自己找价值，所以思维惯性上不主动寻找价值
+- 互联网领域，“技术和系统能干啥”大多有共识，客户也会主动给系统提需求。但到传统行业，老板、业务可能只意识到数字化好，但具体能做啥，很难提出清晰需求，需要你主动找价值，且持续的价值
+
+所以，最核心的点是不能等需求，而要主动挖掘价值：
+
+- 咋找？需深入核心业务
+- 咋干？有啥机会？多跟企业高层、核心业务的管理者、甚至具体执行的一线员工去沟通，去学习
+
+最忌讳自认互联网过来，以为降维打击。实际上，传统行业能干那么久，很多高含金量的东西是值得互联网码农去学习。
+
+#### 1.1.2 建团队
+
+##### ① 好的成本意识
+
+- 组建多大团队
+- 这团队能输出啥价值？
+
+必须根据前面挖掘的价值来做匹配。还要考虑要输出这个价值，应该用啥模式去工作，哪个工种要较强……核心岗的人很关键，能力强，还得有强意愿。
+
+实际跟互联网的成熟模式差异大，招聘难度也大。
+
+##### ② 团队内部管理
+
+差异也大。如是空降，可能发现团队内的工作方法，流程很多欠缺，质量和效率不太能保障，这都很常见，需做很多基础工作。
+
+总之，传统行业会遇很多互联网大厂遇不到的新问题。如可能带十个人的总监就需直接对大老板，做出价值，承诺结果，这些问题是职业发展路上关键思路的转折点，在职场上越往高级别走，越会逼你更接近业务，做更本质思考。
+
+遇到困难不是坏事，而是你提前得到这样的锻炼机会，对你真的学会怎么去领命打战很关键。
+
+### 1.2 中层
+
+指负责一个团队的管理者或架构师。
+
+#### 1.2.1 摆脱惯性依赖
+
+有意识找价值，不能全部依赖上级，也需要自己去找价值。尤其算法同学，相比互联网企业有策略产品，传统行业本身几乎无策略产品。切忌“拿锤找钉”，如我原做搜索推荐，就一定要发现一个搜索推荐的场景，而是要根据业务需要，针对业务需求去做事，就需要现学新东西。
+
+#### 1.2.2 加强技术广度
+
+大厂技术偏向深度。但传统企业，除了一些核心业务可能需深度，大多无需特别深度，更关注广度。
+
+所以传统行业不像大厂投入很多人力，把一个项目做到极致，可能只是为了晋升时讲故事，传统行业务实，日常工作可能是你需要了解很多方案，从中选择最优，而这个最优衡量标准就是性价比。
+
+技术最基本的安全稳定质量也要关注，但要注意 ROI。那些只提升技术团队工作效率，而非直接带来业务价值的事，需谨慎。
+
+### 1.3 一线
+
+长本事，第一要务。把事情做好，做的过程有学习有成长。
+
+传统行业是否能达到这目标，跟团队及 Leader 关系大。如：
+
+- 团队输出的价值是否清晰？
+- 团队是否看重质量和效率？团队的工作方法和流程是不是规范？是否有相应的内部学习机制？Leader 是否关注大家的成长，大家的工作方法和效率……
+
+这也是为啥一线小伙伴去互联网大厂长本事很快，因为配套机制健全，而传统行业依赖团队和Leader。如选择到一个好团队，也会成长快，相比大厂，还有增值部分，如对业务价值思考及不同角色合作，传统行业锻炼更多。
+
+![](https://p.ipic.vip/kr6rvo.png)
+
+## 2 转型传统行业的 3 个阶段
+
+从互联网到传统行业，一般经历蜜月期、中期、长期三阶段。
+
+### 2.1 蜜月期
+
+入职前半年，大家比较客气，专业性上也尊重你，重点去理清目标，和大家对齐，包括战略目标，沟通方式，文化，方法论。对齐不是一定要想法完全一致，是指彼此能看到、理解，尤其自己能适配这家企业的已有状态。
+
+避坑：
+
+- 别破坏性乱砸。如原来系统太差，然后组织一帮重构。或原来团队不行，大规模重组换人……你还没对齐，可能做很多错误决定
+- 找亮点。无需特大亮点，但可体现你的差异化价值。如系统bug、上线准时性、质量高等在大厂的基本功做扎实都可。做几个漂亮事，帮你积累口碑
+
+### 2.2 中期
+
+到你比较稳了，即前面提到的存身公式（融入度 X 差异化价值），两维都得到验证的阶段。
+
+有了蜜月期亮点，也看清组织，对齐目标，中期重点是理清自己和团队在公司要实现的长期价值，开始做结果。即存身能力的两个因子（融入度 X 差异化价值）在这阶段都得做好。
+
+相比甜蜜期“别乱砸”，这阶段反而**不能胆小，该干啥要干**。因为如在中期做不出业绩，很可能你在组织里得到的价值评价大幅受损。做啥事，就是找到价值点，要去识别咋做，并找到机会点。
+
+要找到差异化价值，可关注：
+
+- 产品、技术这些在互联网锻炼的硬能力
+- 互联网的思维模式。如在互联网行业数据分析师会做数据建模，用数据去描述整个业务的一些宏观现状，这可能在传统行业就是思维模式的差异化价值
+
+### 2.3 长期
+
+不同行业差异大，但有几个坑需规避。
+
+#### ① 渴望很快成为嫡系或者亲信
+
+如你是半路加入，跟公司高层并无深渊源，短期无法成为嫡系的。
+
+- 中层，想较好融入，要一起扛过枪，打过仗
+- 高层，一定是大家共同担风险，才能成为亲信。这都取决契机，不是单靠努力
+
+#### ② 过分依赖差异化价值
+
+过分依赖，可能进入“飞鸟尽，良弓藏”，除非你功成名就后退出。
+
+![](https://p.ipic.vip/typfmw.png)
+
+## 3 常见“坑”
+
+### 3.1 希望管理老板的预期
+
+互联网习惯的沟通模式：一个上线可能有风险，提前跟老板报备，同时做好预案，可能能得到老板谅解。
+
+而传统行业，你面对老板不是产品技术出身，甚至背景差异大，你不断给对方讲风险，反让他觉得你技术不行。
+
+他要的是你去搞定结果，不出问题，所以搞定不出问题是应该，出了问题那就是你的问题。反过来想，你是老板，你愿意被下面兵管理你吗？与其想着咋管理老板预期，不如思考咋把自己的事搞定，怎么做人融入企业，这才是根本。
+
+### 3.2 过度依赖数据
+
+如上线后带来啥收益，啥效果等，大厂习惯用数据量化，但传统行业，光有数据远不够，还要落到实处，不然可能站不稳脚跟。如 case by case 的分析，确实是这样的结果或有成功案例说明或业务方的口碑，他认为你做的系统上线以后对业务产生了实际价值。
+
+传统行业做事，要把事情做到实处。
+
+## 4 总结
+
+从互联网到传统行业，像“上山下乡”，一定会遇到不少挑战，但若当前工作瓶颈已明显，互联网红利期已一去不复返，勇敢打破舒适区，在更广阔的天地里去验证技术的价值，这不但对职业发展，对人生视野拓展，格局的打开，都重要。
+
+参考：
+
+- https://mp.weixin.qq.com/s/c8G85uZ8Vh-x6OUoWtNYeg
\ No newline at end of file
diff --git a/docs/md/design/cell-based-architecture-adoption-guidelines.md b/docs/md/design/cell-based-architecture-adoption-guidelines.md
new file mode 100644
index 000000000..053e112fb
--- /dev/null
+++ b/docs/md/design/cell-based-architecture-adoption-guidelines.md
@@ -0,0 +1,290 @@
+# 单元化架构最佳实践指南！
+
+## 0 前言
+
+- 单元化架构通过减少故障影响范围来增强系统的弹性。
+- 单元化架构是对于那些无法接受停机或可能对最终用户产生负面影响的系统的良好选择。
+- 单元化架构可能很复杂，有一些最佳实践可以遵循，以提高成功的机会。
+- 在推出单元化架构或将现有的云原生/微服务架构改造/转变为单元化架构时，有一些实际步骤需要考虑。
+- 单元不是微服务的替代品，而是一种帮助在大规模情况下管理微服务的方法。许多适用于微服务的最佳实践、问题和实际步骤也适用于单元。
+
+一切都在不断失败，而单元化架构可以是接受这些失败、隔离它们并保持整个系统可靠运行的好方法。然而，这种架构在设计和实施上可能很复杂。本文探讨了组织可以用来成功的一些最佳实践、问题和采用指南。
+
+##  1 单元化架构的最佳实践
+
+组织在采用单元化架构以提高系统的可管理性和弹性时，应考虑几个最佳实践。
+
+### 1.1 考虑用例
+
+单元化架构可能更复杂、成本更高。并不是每个系统都需要像S3那样的规模和可靠性；考虑用例，以及是否值得额外投资。对于需要：
+
+1. 高可用性。
+2. 大规模扩展，以避免级联故障。
+3. 非常低的RTO（恢复时间目标）。
+4. 系统如此复杂，以至于自动化测试覆盖不足以覆盖所有测试用例。
+
+还要考虑系统的大小。对于一些组织来说，每个单元代表一个完整的堆栈：每个服务都部署在每个单元中，单元之间不相互通信（[DoorDash](https://doordash.engineering/2024/01/16/staying-in-the-zone-how-doordash-used-a-service-mesh-to-manage-data-transfer-reducing-hops-and-cloud-spend/), [Slack](https://slack.engineering/slacks-migration-to-a-cellular-architecture/)）。对于其他组织来说，每个单元都有自己的有界业务上下文，系统由多个相互通信的单元层组成（[WSO2](https://github.com/wso2/reference-architecture/blob/master/reference-architecture-cell-based.md), [Uber的DOMA](https://www.uber.com/en-GB/blog/microservice-architecture/)）。后者可能更灵活，但无疑更复杂。
+
+### 1.2 明确单元所有权
+
+如果多个单元层相互通信，理想情况下，每个单元应该由一个单一的团队拥有，该团队有权构建和交付单元的功能到生产环境。
+
+考虑使单元的边界“团队大小”，以便于建立所有权，并帮助团队根据业务需求发展系统。技术如领域驱动设计和事件风暴可以帮助找到这些边界。
+
+###  1.3 隔离单元
+
+单元应尽可能相互隔离，以最小化可靠性和安全问题的爆炸半径。这在现实世界中并不总是可能的，但共享资源应该谨慎进行，因为它可以显著降低使用单元的好处。
+
+在AWS上，确保隔离的一个好方法是每个单元使用一个单独的账户。许多账户可能会带来管理问题，但它们默认提供了很好的爆炸半径保护，因为您必须显式允许跨账户访问数据和资源。
+
+重要的是要考虑单个单元是否应该位于单个可用性区域，或者将其服务复制到多个可用性区域以利用可用性区域提供的物理隔离。这里有一个权衡。
+
+#### 1.3.1 单个AZ
+
+在单个AZ设计中，每个单元在单个可用性区域中运行：
+
+![](https://p.ipic.vip/vt9j5t.jpg)
+
+优点：可以检测到AZ故障，并采取行动处理它，例如将所有请求路由到其他区域。
+
+缺点：
+
+1. 恢复可能会因为需要将单元内容复制到另一个AZ而变得复杂，这可能会破坏单元设计的隔离属性
+2. 根据路由器设计，客户端可能需要知道特定区域的端点。
+
+#### 1.3.2 多个AZ
+
+在多AZ设计中，每个单元跨越两个或更多可用性区域运行：
+
+![](https://p.ipic.vip/4ytskx.jpg)
+
+多AZ的优势在于使用[区域](https://docs.aws.amazon.com/whitepapers/latest/aws-fault-isolation-boundaries/regional-services.html)云资源（如Amazon DynamoDB）使单元在单个区域失败时更具弹性。
+
+缺点：
+
+1. 当服务仅在一个AZ中遇到问题时，可能会发生灰色故障，这使得排除给定单元的特定AZ变得困难
+2. 此外，可能还会有额外的跨AZ数据传输成本。[DoorDash](https://doordash.engineering/2024/01/16/staying-in-the-zone-how-doordash-used-a-service-mesh-to-manage-data-transfer-reducing-hops-and-cloud-spend/) 使用监控和具有[AZ感知路由](https://www.envoyproxy.io/docs/envoy/latest/intro/arch_overview/upstream/load_balancing/zone_aware)的服务网格来优化成本，尽可能在同一个AZ内保持流量
+
+#### 1.3.3 单元故障转移
+
+如果单个AZ设计中的AZ变得不可用，会发生什么？受影响的用户请求将被路由到哪里？
+
+一个答案是根本不处理故障转移：单元旨在隔离故障。必须修复故障，受影响的单元才能重新使用。
+
+另一个选择是使用灾难恢复策略将单元数据复制到另一个AZ中的另一个单元，并开始将请求路由到新单元。这里的风险是复制可能会降低单元的隔离。复制过程将取决于数据需求和底层数据存储（区域云服务可以帮助这里：见[利用高可用云服务](https://www.infoq.com/articles/cell-based-architecture-adoption-guidelines/#leveragehighavailabilitycloudservice)）。
+
+### 1.4 自动化部署
+
+就像微服务一样，要大规模运行单元，您需要能够在几小时内甚至最好是几分钟内部署它们——而不是几天。快速部署需要标准化、自动化的方式来管理单元，这一点至关重要，取决于对工具、监控和流程的投资。
+
+标准化并不意味着每个团队都需要使用相同的语言、数据库或技术。然而，应该存在一个被良好理解和标准化的方式来打包和部署应用程序到新的或现有的单元。理想情况下，配置/部署管道应该允许团队：
+
+1. 创建新的单元。
+2. 监控它们的健康状况。
+3. 向它们部署更新的代码。
+4. 监控部署状态。
+5. 节流和扩展单元。
+
+部署管道应该减少平台用户的复杂性和[认知负荷](https://techbeacon.com/app-dev-testing/forget-monoliths-vs-microservices-cognitive-load-what-matters)——这到底是什么样子将取决于组织的大小和技术栈。
+
+### 1.5 使路由可靠
+
+![](https://p.ipic.vip/6yhx6w.jpg)
+
+单元上方的路由器可以说是系统中最关键的部分：没有它，其他什么都不工作，它可能成为单点故障。设计它尽可能简单是很重要的，因此有几件事需要考虑：
+
+1. 技术：DNS、API网关、自定义服务。每个都有其自身的优缺点（例如，管理DNS的生命周期）。
+2. 利用高可用服务。例如，如果路由器需要存储客户单元，使用S3或DynamoDB，它们具有非常高的SLA，而不是单个MySQL实例。
+3. 分离[控制和数据平面](https://docs.aws.amazon.com/whitepapers/latest/advanced-multi-az-resilience-patterns/control-planes-and-data-planes.html)。例如，客户单元可以存储在S3中，路由器可以在桶中查找数据。单独的控制平面管理桶的内容，控制平面可以失败而不影响路由。
+4. 考虑认证应该在哪里发生。例如，应该是：
+   1. 在路由器中，这简化了下游服务，但如果失败会增加一个大的爆炸半径。
+   2. 在单元中，这可能会增加每个单元的复杂性和重复性。
+5. 路由器必须知道单元的位置和健康状况，以便将请求从失败或正在排出的单元路由出去。
+
+### 1.6 限制单元间通信
+
+如果多个单元层相互通信，它应该通过明确定义的API进行，这有助于封装单元的逻辑，并允许单元内的服务在不过分破坏API契约的情况下发展。根据复杂性需求，这个API可能由单元中的服务直接暴露，或者由单元边缘的网关暴露。
+
+避免单元之间的频繁通信。限制单元之间的依赖将帮助它们保持故障隔离并避免级联故障。
+
+您可能需要使用内部层来协调单元之间的流量，例如服务网格、API网关或自定义路由器。同样，必须小心确保所使用的任何东西都不是单点故障。异步消息传递也可能有所帮助，只要消息传递层是可靠的。
+
+### 1.7 利用高可用云服务
+
+如上文路由部分所述，许多云服务已经为高可用性而构建（通常使用像[EBS](https://www.youtube.com/watch?v=6IknqRZMFic)和[Azure AD](https://techcommunity.microsoft.com/t5/microsoft-entra-blog/identity-at-ignite-strengthen-resilience-with-identity/ba-p/2747271)这样的单元）。这些服务可以简化您的选择并避免重新发明轮子。
+
+考虑云服务的[SLA](https://queue.acm.org/detail.cfm?id=3096459)，无论它们是全球的、区域的还是区域的，以及如果给定的云服务失败，将如何影响系统的性能。
+
+## 2 基于单元架构的潜在问题
+
+### 2.1 获取组织支持
+
+单元化架构可能很复杂，运行成本更高，因此像许多技术项目一样，它需要组织的支持才能成功。
+
+对于管理层来说，专注于业务影响可能是有帮助的，例如增加速度（团队可以更自信地部署新代码）和提高可用性（满意的客户和更好的声誉）。
+
+它还需要架构、DevOps和开发团队的支持和投资，以构建和运行具有足够隔离、监控和自动化的单元，因此请确保尽早让他们参与以帮助指导过程。
+
+### 2.2 避免单元间共享
+
+在单元之间共享资源，如数据库，可能看起来是减少复杂性和成本的好方法，但它降低了单元之间的隔离，并使得一个单元中的故障更有可能影响其他单元。
+
+关键问题是：如果这个共享资源失败，会有多少单元受到影响？如果答案是很多，那么存在问题，并且没有完全实现基于单元架构的好处。
+
+共享数据库可以作为迁移到单元的旅程中的一个有用的步骤，但不应无限期共享；还应有一个拆分数据库的计划。
+
+### 2.3 避免创建过于复杂的路由器
+
+路由器可能是单点故障，并且随着复杂性的增加，遇到某种故障的风险会增加。向路由器添加功能以简化单元服务可能很诱人，但每个决策都必须权衡对系统整体可靠性的影响。执行一些故障模式分析以识别和减少路由器中的故障点。
+
+例如，如果路由器需要从数据库中查找单元映射，那么在启动路由器时将数据库存储在内存中可能比依赖每个请求的数据访问更快、更可靠。
+
+### 2.4 错过单元间的复制和迁移
+
+可能很诱人，认为单元迁移是一个高级功能，并在项目开始时跳过它，但它对架构的成功至关重要。如果单元失败或变得过载（例如，两个大客户最终位于同一个单元），一些客户需要迁移到另一个单元。实际的样子将取决于路由和数据分区，但总体思路是：
+
+1. 确定要迁移到的单元（要么是具有容量的现有单元，要么是新创建的一个）。
+
+2. 从旧单元的数据库复制任何所需数据到目标单元。
+3. 更新路由器配置，使目标单元对相关客户生效。
+
+还需要与路由层集成，以确保在正确的时间将请求路由到正确的单元。
+
+![](https://p.ipic.vip/22gdhz.jpg)
+
+复制可能由单元故障触发，或者复制单元以便另一个单元始终准备就绪。这复制到底是什么样子将取决于单元的数据模式、恢复点目标（RPO）和恢复点目标（RTO）需求：数据库级复制、消息传递和S3都是选项。见[AWS上的灾难恢复工作负载白皮书](https://docs.aws.amazon.com/whitepapers/latest/disaster-recovery-workloads-on-aws/disaster-recovery-workloads-on-aws.html)以获取更多关于恢复策略的讨论。
+
+### 2.5 避免云资源限制
+
+如果系统每个单元消耗大量云资源，可能会遇到云提供商施加的[软限制或硬限制](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html?ref=wellarchitected)。软限制可以请求增加，但硬限制可能由服务或硬件限制施加，并且是固定的。
+
+在AWS上，许多限制可以通过每个单元使用[单独的账户](https://docs.aws.amazon.com/whitepapers/latest/organizing-your-aws-environment/benefits-of-using-multiple-aws-accounts.html)来避免。
+
+### 2.6 平衡逻辑和数据的复制
+
+在保持单元尽可能隔离与避免服务之间逻辑和数据复制之间存在权衡。与微服务一样，存在“不要重复自己”（DRY）原则的相同权衡。
+
+随着系统的发展，通过在不同单元的服务之间复制代码来避免紧密耦合和促进隔离可能更好，甚至在有意义的情况下复制数据。这个问题没有通用的对错答案：应该根据具体情况进行评估。进行[故障模式分析](https://learn.microsoft.com/en-us/azure/architecture/resiliency/failure-mode-analysis)可以帮助识别单元之间的依赖关系何时可能成为问题，以及何时应该被移除，可能通过复制来实现。
+
+## 3 采用指南
+
+你已经决定单元化架构是一个不错的选择——现在怎么办？
+
+### 3.1 迁移
+
+引用Martin Fowler的话：[如果你进行大爆炸式重写，唯一确定的事情就是大爆炸](https://twitter.com/GOTOber/status/1232995046959566848)。
+
+将现有的微服务架构迁移为单元化架构可能会很棘手。常见的第一步是将第一个单元定义为现有系统，并在顶部放置一个路由器，然后像进行单体到微服务迁移一样剥离服务到新的单元。
+
+![](https://p.ipic.vip/fne2v3.jpg)
+
+组织可用许多单体到微服务策略。如：
+
+1. 使用领域驱动设计（DDD）定义有界上下文，帮助决定什么放入新的单元。
+2. 首先将服务逻辑迁移到单独的单元，然后在后续阶段将共享数据分割到单元特定的数据库。
+3. 考虑在决定首先分割到单元的业务领域时，哪些业务领域会从更大的弹性中受益。
+4. 确保有足够的自动化和可观察性来管理新的、更复杂的系统。
+
+### 3.2 部署
+
+在单元化架构中，部署单元是部署的单位。新应用程序版本应该首先部署到单个单元，以测试它们如何与系统的其余部分交互，同时最小化广泛故障的风险。使用像金丝雀或蓝/绿部署这样的技术进行增量更改，并在继续推出之前验证系统仍然按预期运行（通常在[波](https://aws.amazon.com/builders-library/automating-safe-hands-off-deployments/)中）。 
+
+如果新版本有问题，应该回滚更改，并暂停部署，直到进一步调查可以确定问题。
+
+“烘焙时间”的概念也很重要，以确保新单元有足够的时间来服务真实流量，以便监控可以检测问题。确切的时间将根据系统类型、风险承受能力和复杂性而有所不同。
+
+### 3.3 可观察性
+
+除了[正确监控微服务](https://www.infoq.com/articles/microservice-monitoring-right-way/)之外，还应该增加单元监控和仪表板，以查看聚合和单元级别的视图：
+
+1. 单元的数量。
+2. 单元的健康状况。
+3. 部署波的状态。
+4. 任何对单元重要的SLO指标。
+
+这些都可以从标准云指标中派生出来，但可能需要额外的标记标准来获得单元级别的视图。
+
+由于单元化架构可能会增加云使用量，因此跟踪资源使用情况和每个单元的成本至关重要。目标是允许团队提出问题，如“我的单元成本是多少？”、“我如何更有效地使用资源？”以及“单元大小是否优化？”。
+
+### 3.4 扩展
+
+在单元化架构中，扩展单元是扩展的单位：根据负载水平可以水平部署更多。确切的扩展标准将取决于工作负载，但可能包括请求数量、资源使用情况、客户大小等。扩展可以进行到什么程度将取决于单元的隔离程度——任何共享资源都将限制可扩展性。
+
+架构还应该小心知道单元的限制，并避免发送超出其资源处理能力的流量，例如通过路由器或单元本身进行负载卸载。
+
+### 3.5 单元大小
+
+决定每个单元的大小是一个关键的权衡。许多较小的单元意味着较小的爆炸半径，因为每个单元处理的用户请求较少。小单元也更容易测试和管理（例如，更快的部署时间）。
+
+另一方面，较大的单元可能更好地利用可用容量，更容易将大客户放入单个单元，并使整个系统更容易管理，因为单元较少。
+
+![](https://p.ipic.vip/kcxf6m.jpg)
+
+考虑：
+
+1. 爆炸半径。
+2. 性能。一个单元可以容纳多少流量，以及它如何影响其性能？
+3. 预留空间，以防现有单元需要开始处理来自失败单元的流量。
+4. 平衡分配的资源，以确保单元不会因处理预期负载而功能不足，但也不会功能过强，成本过高。
+
+较小单元的优点是：
+
+1. 它们有较小的爆炸半径，因此任何故障都会影响较小比例的用户。
+2. 它们不太可能达到任何云提供商的配额限制。
+3. 降低测试新部署的风险，因为针对较小的用户集合更容易。
+4. 每个单元的用户较少意味着迁移和故障转移可以更快。
+
+较大单元的优点是：
+
+1. 它们更容易操作和复制，因为它们较少。
+2. 它们更有效地利用容量。
+3. 减少必须将大用户分割到多个单元的风险。
+
+正确的选择将严重依赖于正在构建的确切系统。许多组织从较大的单元开始，随着信心和工具的改进而转向较小的单元。
+
+### 3.6 数据分区
+
+与单元大小密切相关的是分区数据和决定客户流量应该路由到哪个单元。许多因素可以通知分区方法，包括业务需求、数据属性的基数和单元的最大大小。
+
+分区键可以是客户ID，如果请求可以分割成不同的客户。每个单元被分配一定比例的客户，以便同一个客户始终由同一个单元服务。如果某些客户比其他客户大，则需要确保没有单个客户比单元的最大大小大。
+
+其他选项是地理区域、市场类型、轮询或基于负载。
+
+无论采用哪种方法，覆盖路由器并手动将客户放置在特定单元中进行测试和隔离某些工作负载也可能是有益的。
+
+### 3.7 映射
+
+使用客户ID意味着路由器将需要将客户映射到单元。存储映射数据的最简单方法可能是一个表格，该表格将每个客户映射到单元：
+
+![](https://p.ipic.vip/ke89o1.jpg)
+
+其显著优点是它非常容易实现，并简化了在单元之间迁移客户：只需更新数据库中的映射。
+
+这种方法的缺点是它需要一个数据库，这可能是单点故障，并引起性能问题。
+
+其他方法是[一致性哈希](https://en.wikipedia.org/wiki/Consistent_hashing)和将一系列键映射到单元。然而，它们都不够灵活，因为它们有热单元的风险，使迁移更具挑战性。
+
+### 3.8 衡量成功
+
+理想情况下，组织应该考虑采用单元化架构来实现特定的业务目标，例如通过提高技术平台的稳定性来提高客户满意度。
+
+通过迁移，应该可以衡量朝着这些目标取得的进展。通常，目标是在面对故障时的弹性，其中一些定量措施是有用的：
+
+1. 健康指标，包括错误率或正常运行时间（例如，当EBS迁移到单元时，错误率大幅下降）。
+2. MTTR（平均修复时间）。
+3. 性能指标，包括p75、p95和p99的请求处理时间，以查看额外的层是否对延迟产生不利影响。如果客户现在由比之前系统更小的单元服务，性能可能会提高！
+4. 资源使用情况，以确保成本没有失控，如果必要，可以优化。
+
+这些都意味着良好的可观察性，以衡量性能、可靠性和成本。
+
+## 4 结论
+
+单元化架构可能令人生畏且复杂，但许多好的做法对微服务开发人员来说很熟悉。任何在这个规模上的架构都应该包括部署自动化、可观察性、扩展和故障恢复；单元化架构也不例外。这些在设计单元大小时、单元隔离、数据所有权和从故障中恢复的策略时必须考虑。
+
+也许需要做出的关键决策是关于数据分区的，以及密切相关的，如何分配和映射请求流量到单元。更简单的方法可能更容易实现，但它们通常缺乏运行单元所需的灵活性。
+
+公共云提供商提供许多高可用性服务，可以利用这些服务来提高可靠性，同时简化设计。AWS在单元化架构方面在线上占有最多的份额，有关他们如何将这种模式应用于自己的系统以及使用AWS服务实现的建议的讨论。
+
+组织必须确保单元化架构适合他们，并且迁移不会造成比解决的问题更多的问题。将现有系统迁移到单元化架构可以分步骤进行，以最小化干扰，并验证更改按预期工作，然后再继续。
+
+构建现代、可靠和可理解的分布式系统的挑战持续增长，单元化架构是接受、隔离和面对故障保持可靠的有价值方式。
\ No newline at end of file
diff --git a/docs/md/java/java2024.md b/docs/md/java/java2024.md
new file mode 100644
index 000000000..e1179d84e
--- /dev/null
+++ b/docs/md/java/java2024.md
@@ -0,0 +1,130 @@
+# 01-Java开发生态2024年度总结报告
+
+## 1 关键要点
+
+![关键要点](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/2a0d5a1deeec3a4d80c2360d1fc12f69.png)
+
+- 尽管数据显示 Java 17 是最常用 JDK，但其用户占比并未超过半数。根据 [New Relic 2024 Java 生态系统状态报告](https://newrelic.com/resources/report/2024-state-of-the-java-ecosystem)，Java 17、11 和 8 的用户比例分别为 35%、33% 和 29%
+- New Relic 数据中所谓“快速采用”指 Java 21 的采用率仅为 1.4%。虽相较 Java 8 以来的所有 LTS，增长速度更快，但这比例仍较低
+- Java 已超越了其“缓慢”和“过时”的传统形象，当前正显现出明显创新动力
+- 2024 年初关于 AI 的“狂热探索期”现象有所平息，但 AI 仍然是热点话题。现在态度更冷静，认为 AI 并非“万能锤”，而是需根据具体问题合理应用
+- 一个名为 Commonhaus Foundation 的新非营利组织致力于开源库和框架的可持续发展，为自主管理的开源项目提供继任规划和财政支持
+- WebAssembly 在 Java 领域终于开始获得关注，逐渐赶上 Go 和 Rust 等语言的生态系统
+
+本报告总结了 InfoQ Java 编辑团队对 Java 语言及其相关生态的观察，包括 Java 核心技术的进步、新版本的采纳情况，以及 [Spring Framework](https://spring.io/projects/spring-framework)、[Jakarta EE](https://jakarta.ee/)等框架的演进。
+
+还可收听由 Karakun 高级开发者 [Ixchel Ruiz](https://www.linkedin.com/in/ixchelruiz/) 和 Decodable 软件工程师 [Gunnar Morling](https://www.linkedin.com/in/gunnar-morling/) 主持的[播客讨论](http://www.infoq.com/podcasts/insights-java-trends-report-2024)，获取关于 2024 Java 趋势的更多见解。
+
+本报告有两个主要目标：
+
+- 帮助技术领导者做出中长期技术投资决策。
+- 帮助个人开发者选择学习和技能发展的重点领域，合理分配宝贵的时间和资源。
+
+这是第六份 Java 趋势报告。自 2006 年以来，我们已开始内部追踪 Java 和 JVM 的趋势，并对此进行了广泛新闻报道。
+
+为帮助读者更好理解当前和未来技术趋势，采用了 Geoffrey Moore 在其[同名书籍](https://www.amazon.com/Crossing-Chasm-3rd-Disruptive-Mainstream/dp/0062292986)中提出的“跨越鸿沟”模型。试图识别出符合 Moore 所定义的“早期市场”的创新：*“这一市场主要由技术爱好者和愿景者组成，他们希望抢占先机以抓住机会或应对紧迫问题。”*
+
+正如 [2023](https://www.infoq.com/articles/java-trends-report-2023/)、[2022](https://www.infoq.com/articles/java-jvm-trends-2022/)、[2021](https://www.infoq.com/articles/java-jvm-trends-2021/)、[2020](https://www.infoq.com/articles/java-jvm-trends-2020/)、和 [2019](https://www.infoq.com/articles/java-jvm-trends-2019/) 的 Java 趋势报告中所做的一样，为 2024 年提供了以下内部主题图：
+
+![2024主题图](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/2a0d5a1deeec3a4d80c2360d1fc12f69.png)
+
+以下是 2023 年的参考主题图：
+
+![2023主题图](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/2a0d5a1deeec3a4d80c2360d1fc12f69.png)
+
+- 计划于 2024 年 11 月正式发布的 *Jakarta EE 11* 进入 **创新者**类别，因为其 16 项规范目前正在积极开发，并已在今年通过了审查。自 2024 年 6 月发布 *Jakarta EE 11-M4* 版本以来，开发者已经可以尝试 [Jakarta Security 4.0](https://jakarta.ee/specifications/security/4.0/)、[Jakarta Validation 3.1](https://jakarta.ee/specifications/bean-validation/3.1/)、以及 [Jakarta Data 1.0](https://jakarta.ee/specifications/data/1.0/) 等新特性。
+- 因此，2022 年 9 月发布的 *Jakarta EE 10*、2020 年 12 月发布的 *Jakarta EE 9* 和 2019 年 9 月发布的 *Jakarta EE 8* 分别移动至 **早期采用者**、**早期多数** 和 **晚期多数**类别。
+- *GraalPy* 和 *GraalWasm* 进入 **创新者**类别。这两个项目在 [GraalVM for JDK 23](https://medium.com/graalvm/welcome-graalvm-for-jdk-23-203928491b2b) 发布后，已被视为稳定且适合生产使用。
+- 随着更多框架（如 Spring、Jakarta EE 和 Helidon）以 Java 21 为基础，*Java 21* 转至 **早期采用者**类别，同时 *Java 17* 进入 **早期多数**类别。
+- Helidon 和 Vert.x 框架在最新版本中实现了虚拟线程服务器，*虚拟线程框架（Helidon Nima 和 Vert.x）* 被转移至 **早期采用者**类别。
+- 由于 Helidon 支持虚拟线程并发布了 [Helidon 4.0](https://medium.com/helidon/helidon-4-is-released-a06756e1562a)，*Helidon* 移至 **早期多数**类别，而 Helidon 3.0 和 2.0 仍支持反应式服务器。
+- 由于 Scala 3 开发进展缓慢，2021 年 5 月发布的 *Scala 3* 移至 **晚期多数**类别。
+- Azul 和 BellSoft 实现了 CRaC 技术，*快速 JVM 启动（CRaC）* 转至 **早期采用者**类别，同时 *快速 JVM 启动（GraalVM）* 被转至 **早期多数**类别。
+
+## 2 AI 与 Java
+
+AI 在过去一年发生了重大变化，仍然是一个热门话题。越来越多的工具和集成正在帮助 Java 开发者更高效地完成代码开发。
+
+虽然 2024 年初的 AI 热潮有所缓解，但相关讨论依然热烈。开发者已从“必须切换到 Python”转变为“仍然可以用 Java 进行 AI 开发”。像 LangChain4j 这样的库大大提升了 Java 在 AI 开发中的可用性。
+
+## 3 Commonhaus基金会
+
+[Commonhaus基金会](https://www.commonhaus.org/)，一个专注于开源库和框架可持续发展的新非营利组织，于 2024 年 Devnexus 大会上首次向 Java 社区亮相，旨在为自主管理的开源项目提供继任规划和财政支持。
+
+其使命是：
+
+> 通过共同管理和社区协作，赋能多元化的开发者、贡献者和用户群体，共同创建、维护和发展开源库和框架，确保其长期增长和稳定。
+
+创始人 [Erin Schnabel](https://www.linkedin.com/in/erinschnabel/)、[Ken Finnigan](https://www.linkedin.com/in/kenfinnigan/) 和 [Cesar Saavedra](https://www.linkedin.com/in/saavedracesar/) 分别担任主席、秘书和财务主管。
+
+Java 开源项目正经历动态变化。一些知名项目转向商业源代码许可（BLS），但与此同时，Commonhaus Foundation 则展示了更开放的新趋势。
+
+很高兴像 Hibernate 和 JBang 等项目得到了基金会的支持，这将确保它们长期发展，为开发者提供更多信心。
+
+Commonhaus 提供了云时代的开源模式，帮助解决关键项目的资金问题。
+
+## 4 Spring Framework 6 和 Spring Boot
+
+Spring 6 和 Spring Boot 3+ 的采用率显著提高。在我们公司中，几乎所有应用都已经迁移到了 Spring Boot 3+。Spring Boot 和 Quarkus 似乎正在成为云原生应用开发的首选框架。
+
+Quarkus 的崛起势不可挡，其市场份额逐渐从 Spring Boot 手中夺过，并巩固了微服务框架中的第二名地位。
+
+## 5 Java 17 及更高版本
+
+过去一年中，Java 的改进更加关注现代应用需求，包括提升云环境中的性能和加强安全性。围绕启动时间改进的技术（如 Liberty 的 [InstantOn](https://openliberty.io/docs/latest/instanton.html)、[CRIU](https://criu.org/Main_Page) 和 [CRaC](https://openjdk.org/projects/crac/)）尤其令人瞩目，使 Java 应用更加适合云端和无服务器计算。
+
+虚拟线程的引入为 Java 并发编程带来了重要突破，尽管该技术仍在持续改进中，并且在某些场景下存在 [性能挑战](https://www.infoq.com/articles/java-virtual-threads-a-case-study/)。在安全性方面，支持最新 [FIPS 140-3](https://csrc.nist.gov/pubs/fips/140-3/final) 标准的加密模块的普及，使 Java 在受监管行业中的应用更加广泛。
+
+随 Oracle JDK 17 的免费商业使用授权在今年 9 月结束，用户需迁移至 Oracle Java SE Universal 订阅以继续使用，这对用户成本产生了一定影响。许多用户因此转向基于 OpenJDK 的 Java 替代品，如 [IBM Semeru Runtimes](https://developer.ibm.com/articles/awb-where-do-you-get-your-java/)，其最近已支持最新的 FIPS 140-3 标准。据 Azul 报告，[70%以上](https://www.azul.com/report/2023-state-of-java/) 的受访者正在考虑非 Oracle Java 替代品。观察这些授权变化如何影响开源 Java 的发展和创新将是非常有趣的。
+
+Java 已经超越了“缓慢”和“过时”的刻板印象。Java 现在显现出明确的创新动力，同时保持了强大的向后兼容性和修复能力。之前对“破坏性变更”的恐惧已被一种平衡的创新方式取代，这种方式既推动进步，又不牺牲稳定性。此外，Java 正在增强与其他生态系统的兼容性，使其与不同语言和技术的交互更加轻松，从而提升了灵活性和吸引力。
+
+Java 21 的快速采用令人瞩目，尽管多数公司仍在使用 Java 17。然而，与往年相比，现在有更多公司开始从旧版本的 JDK 迁移到新版本。
+
+Java 17 正在成为新的基线，其流行度持续增长。过去，项目可能以 Java 8 为最低兼容版本；如今，这一角色正越来越多地被 Java 17 取代。虚拟线程、新模式和后续特性正在逐步推出（尽管目前仍是预览版）。
+
+## 6 Jakarta EE
+
+在 Jakarta EE 领域，有大量努力致力于 JDK 21 的采纳。因此，人们对 Jakarta EE 11 的期待非常高。
+
+为即将发布的 Jakarta EE 11 所做的更新工作极其庞大，共涉及 16 项 Jakarta EE 规范。在此次升级中，移除了对已弃用 `SecurityManager` 类的引用，并引入了对 Java Records 的支持。
+
+我期待以 [Garden State Java 用户组](https://gsjug.org/) 的代表身份参与 2024 年 7 月成立的 [Jakarta EE Future Directions](https://projects.eclipse.org/interest-groups/jakarta-ee-future-directions) 兴趣小组。该小组的目标是开展研究并制定优先建议，这些建议将及时提交给 Jakarta EE 和 MicroProfile 工作组，以抓住市场方向带来的机会。
+
+## 7 Java 社区的声音
+
+AI 在 Java 社区中主导了许多讨论。我们应该如何在 Java 中利用 AI？AI 能为我们编写多少代码？另外，关于 Project Leyden 的讨论也非常热烈，这是一个具有潜在重大性能提升的有趣架构。
+
+关于 AI 的讨论仍然非常活跃，既涉及技术层面，也探讨了它对开发者的影响。目前，更多的讨论集中在如何使用这些新工具，而不是像年初那样担忧 AI 会取代开发者的工作。
+
+Java 社区和技术行业一样，对 AI 的热情高涨。Java 正在不断适应并在 AI 领域发现新机遇。新的工具正在涌现，使得 AI 在 Java 应用中的集成更加方便。凭借多年的技术积累，Java 有能力迎接未来的挑战，并在多种场景中保持价值。
+
+关于虚拟线程的讨论非常活跃，许多公司开始采用 JDK 21 并分享了各种用例。尽管反馈大多是正面的，但也存在一些问题，例如 Netflix 曾遇到过类似死锁的情况。
+
+关于 OpenTelemetry 的讨论越来越多，它不断壮大，并巩固了自己作为 Java 领域领先可观测性技术的地位。
+
+Java 社区中有许多令人兴奋的趋势，但我特别喜欢 [Gunnar Morling](https://www.linkedin.com/in/gunnar-morling/) 发起的 [十亿行挑战](https://www.morling.dev/blog/one-billion-row-challenge/)。这项挑战要求用 Java 编写程序，从全球气象站获取温度数据并计算每站点的最低、最高和平均温度。在 [164 个参赛作品](https://github.com/gunnarmorling/1brc#results) 中，由 [Thomas Wuerthinger](https://www.linkedin.com/in/thomaswue/) 团队完成的时间仅为 1.5 秒多一点，获得最快成绩。
+
+## 8 新的令人兴奋的发展
+
+LangChain4j 是一个令人激动的新工具，它意味着开发者不需要学习 Python 就能利用 AI，并大幅减少与不同 AI 提供商的专有 API 集成所需的工作量。
+
+平台工程的崛起为 Java 开发者引入了新的工具，如 [Backstage](https://backstage.io/) 和 [Red Hat Developer Hub](https://developers.redhat.com/rhdh/overview)，这些工具帮助简化应用交付并减轻开发者的认知负荷。某些项目进一步推出了针对特定运行时和框架的 SaaS 服务，期望通过减轻开发团队的压力来应对不断扩展的开发生命周期任务。
+
+AI 的迅速崛起超出了预期。尽管年初时似乎没有什么比 AI 更重要的事情，但到下半年，这种热潮有所降温。
+
+六个月的 Java 发布周期已成功稳固，这打破了对变化的恐惧，并激发了整个生态系统的创新浪潮。库和框架维护者借此模式更加积极地采用新特性和改进，同时在需要时保持稳定性。
+
+JDK 21 和虚拟线程的采纳正在推动 Jakarta EE 社区加快拥抱 JDK 21 的步伐。
+
+JSpecify 1.0.0 的发布及 Java 语言层级即将引入空指针标记是开发者的长期愿望。OpenTelemetry Profiling 达到实验阶段也令人关注。
+
+JEP 465（字符串模板）的撤回令人意外，但其撤回背后的原因表明了团队对开发者需求的谨慎考量。
+
+## 9 Java 社区
+
+Java 社区正在通过更多合作不断壮大，例如 OpenTelemetry 标准的扩展及 MicroProfile 和 Jakarta EE 的共同项目。这种合作提升了开发效率，并推动了社区的发展。
+
+## 10 结论
+
+本报告应被视为 Java 生态系统方向讨论的起点，期待您的参与和反馈，共同塑造 Java 的未来。
\ No newline at end of file
diff --git "a/docs/md/kafka/00-Kafka\344\270\223\346\240\217\345\244\247\347\272\262.md" "b/docs/md/kafka/00-Kafka\344\270\223\346\240\217\345\244\247\347\272\262.md"
index 656e34f94..4ee840ea9 100644
--- "a/docs/md/kafka/00-Kafka\344\270\223\346\240\217\345\244\247\347\272\262.md"
+++ "b/docs/md/kafka/00-Kafka\344\270\223\346\240\217\345\244\247\347\272\262.md"
@@ -33,4 +33,68 @@ Kafka 是 LinkedIn 开发并开源的一套分布式的高性能消息引擎服
 
 第五部分，**管理与监控**。这部分涵盖 Kafka 运维与监控的内容，将讨论如何高效运维 Kafka 集群，并分享有效监控 Kafka 的实战经验。
 
-第六部分，**高级 Kafka 应用之流处理**。最后这一部分将会介绍 Kafka 流处理组件 Kafka Streams 的实战应用，并带你从头开发一个 demo 项目。
\ No newline at end of file
+第六部分，**高级 Kafka 应用之流处理**。最后这一部分将会介绍 Kafka 流处理组件 Kafka Streams 的实战应用，并带你从头开发一个 demo 项目。
+
+
+
+开篇词 | 为什么要学习 Kafka？
+
+## Kafka 入门
+
+1. 消息引擎系统 ABC
+2. 一篇文章带你快速搞定 Kafka 术语
+3. Apache Kafka 真的只是消息引擎系统吗？
+4. 我应该选择哪种 Kafka？
+5. 聊聊 Kafka 的版本号
+
+## Kafka 的基本使用
+
+6. Kafka 线上集群部署方案怎么做？
+7. 最最最重要的集群参数配置（上）
+8. 最最最重要的集群参数配置（下）
+
+## 客户端实践及原理剖析
+
+9. 生产者消息分区机制原理剖析
+10. 生产者压缩算法面面观
+11. 无消息丢失配置怎么实现？
+12. 客户端都有哪些不常见但是很高级的功能？
+13. Java 生产者是如何管理 TCP 连接的？
+14. 幂等生产者和事务生产者是一回事吗？
+15. 消费者组到底是什么？
+16. 揭开神秘的“位移主题”面纱
+17. 消费者组重平衡能避免吗？
+18. Kafka 中位移提交那些事儿
+19. CommitFailedException 异常怎么处理？
+20. 多线程开发消费者实例
+21. Java 消费者是如何管理 TCP 连接的？
+22. 消费者组消费进度监控都是怎么实现？
+
+## 深入 Kafka 内核
+
+23. Kafka 备份机制详解
+24. 请求是怎么处理的？
+25. 消费者组重平衡全流程解析
+26. 你一定不能错过的 Kafka 控制器
+27. 关于高水位和 Leader Epoch 的讨论
+
+## 管理与监控
+
+28. 主题管理知多少？
+29. Kafka 动态配置了解下？
+30. 怎么重设消费者组位移？
+31. 常见工具脚本大汇总
+32. KafkaAdminClient：Kafka 的运维利器
+33. Kafka 认证机制用哪家？
+34. 云环境下的授权该怎么做？
+35. 跨集群备份解决方案 MirrorMaker
+36. 你应该怎么监控 Kafka？
+37. 主流监控框架你知道多少？
+38. 调优 Kafka 你做到了吗？
+39. 从 0 搭建基于 Kafka 的企业级实时日志流处理平台
+
+## 高级 Kafka 应用之流处理
+
+40. Kafka Streams 与其他流处理平台的差异在哪？
+41. Kafka Streams DSL 开发实例
+42. Kafka Streams 在金融领域的应用
\ No newline at end of file
diff --git a/docs/md/monitor/performance-optimization-guide.md b/docs/md/monitor/performance-optimization-guide.md
new file mode 100644
index 000000000..cc6f2bf05
--- /dev/null
+++ b/docs/md/monitor/performance-optimization-guide.md
@@ -0,0 +1,189 @@
+# 超全性能调优标准制定指南，你一定不能错过！
+
+## 0 前言
+
+我有个朋友说他们国企的系统从未性能调优，功能测试完就上线，线上也没性能问题，何必还做性能调优？
+
+本文搞清：
+
+- 为什么要做性能调优？
+- 啥时开始做？
+- 做性能调优是不是有标准？
+
+## 1 为啥做性能调优？
+
+- 有些性能问题是慢慢产生，到了时间就自爆
+- 更多性能问题是由访问量波动导致，如活动或公司产品用户量上升
+- 也可能一款产品上线后就半死不活，一直没有大访问量，所以还没有引发这颗定时炸弹
+
+现在假设你的系统要做一次活动，老板告诉你预计几十万的用户访问量，询问系统能否承受得住这次活动的压力。如果你不清楚自己系统的性能情况，也只能战战兢兢地回答老板，可能没问题吧。
+
+### 要不要做性能调优
+
+所有的系统开发完都有性能问题，先把问题暴露，如压测、模拟可能操作，再性能调优去解决。
+
+- 如用某款 App 查询某条信息，需等待十几s
+- 抢购活动中，无法进入活动页面
+- ...
+
+系统响应就是体现系统性能最直接的一个参考因素。若系统在线上没出现响应问题，就不用做性能优化了？有位大神在公司一年只做一件事：把服务器数量缩减到原来一半，系统性能指标，还提升了。
+
+好的系统性能调优不仅可提高系统性能，还能为公司节省资源。这也是性能调优的最直接目的。
+
+## 2 啥时调优？
+
+### 项目初期
+
+没必要性能优化，这反让我们疲于性能优化，不仅不能性能提升，还影响进度，甚至给系统带新问题。
+
+只需代码层保证有效编码，如减少磁盘 I/O 操作、降低竞争锁使用及使用高效算法等。遇到复杂业务，充分利用设计模式优化业务代码。如设计商品价格，有很多折扣活动，可用装饰模式去设计这个业务。
+
+### 系统编码完成
+
+就可对系统进行性能测试。这时，产品经理一般提供线上预期数据，我们在提供的参考平台上进行压测，通过性能分析、统计工具统计各项性能指标，看是否在预期范围内。
+
+### 项目成功上线
+
+还要根据线上实际情况，依照日志监控及性能统计日志，观测系统性能问题，发现问题，就日志分析并及时修复。
+
+## 3 啥能体现系统性能？
+
+性能指标到底有啥？
+
+### 3.0 计算机资源
+
+得先知啥计算机资源会成为系统性能瓶颈。
+
+**CPU**：有的应用需要大量计算，他们会长时间、不间断地占用 CPU 资源，导致其他资源无法争夺到 CPU 而响应缓慢，从而带来系统性能问题。例如，代码递归导致的无限循环，正则表达式引起的回溯，JVM 频繁的 FULL GC，以及多线程编程造成的大量上下文切换等，这些都有可能导致 CPU 资源繁忙。
+
+**内存**：Java 程序一般通过 JVM 对内存进行分配管理，主要是用 JVM 中的堆内存来存储 Java 创建的对象。系统堆内存的读写速度非常快，所以基本不存在读写性能瓶颈。但是由于内存成本要比磁盘高，相比磁盘，内存的存储空间又非常有限。所以当内存空间被占满，对象无法回收时，就会导致内存溢出、内存泄露等问题。
+
+**磁盘 I/O**：磁盘相比内存来说，存储空间要大很多，但磁盘 I/O 读写的速度要比内存慢，虽然目前引入的 SSD 固态硬盘已经有所优化，但仍然无法与内存的读写速度相提并论。
+
+**网络**：网络对于系统性能来说，也起着至关重要的作用。如果你购买过云服务，一定经历过，选择网络带宽大小这一环节。带宽过低的话，对于传输数据比较大，或者是并发量比较大的系统，网络就很容易成为性能瓶颈。
+
+**异常**：Java 应用中，抛出异常需要构建异常栈，对异常进行捕获和处理，这个过程非常消耗系统性能。如果在高并发的情况下引发异常，持续地进行异常处理，那么系统的性能就会明显地受到影响。
+
+**数据库**：大部分系统都会用到数据库，而数据库的操作往往是涉及到磁盘 I/O 的读写。大量的数据库读写操作，会导致磁盘 I/O 性能瓶颈，进而导致数据库操作的延迟性。对于有大量数据库读写操作的系统来说，数据库的性能优化是整个系统的核心。
+
+**锁竞争**：在并发编程中，我们经常会需要多个线程，共享读写操作同一个资源，这个时候为了保持数据的原子性（即保证这个共享资源在一个线程写的时候，不被另一个线程修改），我们就会用到锁。锁的使用可能会带来上下文切换，从而给系统带来性能开销。JDK1.6 之后，Java 为了降低锁竞争带来的上下文切换，对 JVM 内部锁已经做了多次优化，例如，新增了偏向锁、自旋锁、轻量级锁、锁粗化、锁消除等。而如何合理地使用锁资源，优化锁资源，就需要你了解更多的操作系统知识、Java 多线程编程基础，积累项目经验，并结合实际场景去处理相关问题。
+
+这样，便可得到如下指标衡量系统性能。
+
+### 3.1 响应时间
+
+响应时间是衡量系统性能的重要指标之一，响应时间越短，性能越好，一般一个接口的响应时间是在毫秒级。在系统中，我们可以把响应时间自下而上细分为以下几种：
+
+
+- 数据库响应时间：数据库操作所消耗的时间，往往是整个请求链中最耗时的；
+- 服务端响应时间：服务端包括 Nginx 分发的请求所消耗的时间以及服务端程序执行所消耗的时间；
+- 网络响应时间：这是网络传输时，网络硬件需要对传输的请求进行解析等操作所消耗的时间；
+- 客户端响应时间：对于普通的 Web、App 客户端来说，消耗时间是可以忽略不计的，但如果你的客户端嵌入了大量的逻辑处理，消耗的时间就有可能变长，从而成为系统的瓶颈。
+
+### 3.2 吞吐量
+
+在测试中，我们往往会比较注重系统接口的 TPS（每秒事务处理量），因为 TPS 体现了接口的性能，TPS 越大，性能越好。在系统中，我们也可以把吞吐量自下而上地分为两种：磁盘吞吐量和网络吞吐量。
+
+我们先来看**磁盘吞吐量**，磁盘性能有两个关键衡量指标。
+
+一种是 IOPS（Input/Output Per Second），即每秒的输入输出量（或读写次数），这种是指单位时间内系统能处理的 I/O 请求数量，I/O 请求通常为读或写数据操作请求，关注的是随机读写性能。适应于随机读写频繁的应用，如小文件存储（图片）、OLTP 数据库、邮件服务器。
+
+另一种是数据吞吐量，这种是指单位时间内可以成功传输的数据量。对于大量顺序读写频繁的应用，传输大量连续数据，例如，电视台的视频编辑、视频点播 VOD（Video On Demand），数据吞吐量则是关键衡量指标。
+
+接下来看**网络吞吐量**，这个是指网络传输时没有帧丢失的情况下，设备能够接受的最大数据速率。网络吞吐量不仅仅跟带宽有关系，还跟 CPU 的处理能力、网卡、防火墙、外部接口以及 I/O 等紧密关联。而吞吐量的大小主要由网卡的处理能力、内部程序算法以及带宽大小决定。
+
+### 3.3 计算机资源分配使用率
+
+通常由 CPU 占用率、内存使用率、磁盘 I/O、网络 I/O 来表示资源使用率。这几个参数好比一个木桶，如果其中任何一块木板出现短板，任何一项分配不合理，对整个系统性能的影响都是毁灭性的。
+
+### 3.4 负载承受能力
+
+当系统压力上升时，你可以观察，系统响应时间的上升曲线是否平缓。这项指标能直观地反馈给你，系统所能承受的负载压力极限。例如，当你对系统进行压测时，系统的响应时间会随着系统并发数的增加而延长，直到系统无法处理这么多请求，抛出大量错误时，就到了极限。
+
+## 4 总结
+
+性能调优可使系统稳定，用户体验更佳，甚至在较大系统，还能帮公司节约资源。
+
+但项目初期，没必要过早介入性能优化，只需编码时保证其优秀、高效及良好程序设计。
+
+完成项目后，就可系统测试，可将以下性能指标，作为性能调优的标准：响应时间、吞吐量、计算机资源分配使用率、负载承受能力。
+
+电商系统、支付系统及游戏充值计费系统，都是千万级用户，且要承受各种大型抢购活动，所以我对系统性能要求苛刻。
+
+大家还可将迭代之前版本的系统性能指标作为参考标准，通过自动化性能测试，校验迭代发版之后的系统性能是否出现异常，这里就不仅仅是比较吞吐量、响应时间、负载能力等直接指标了，还需要比较系统资源的 CPU 占用率、内存使用率、磁盘 I/O、网络 I/O 等几项间接指标的变化。
+
+## 其它性能指标
+
+除本文常见性能参考指标，还有啥可衡量系统性能的指标？
+
+#### 1. **错误率（Error Rate）**
+
+- **含义**：指系统请求中出现错误的比例。通常用百分比表示。
+- **应用**：错误率过高可能暗示系统存在严重问题，如代码逻辑错误、资源配置不足或外部服务不可用。
+- **示例**：HTTP 状态码 5xx、数据库超时错误等。
+
+#### 2. **并发用户数（Concurrent Users）**
+
+- **含义**：在同一时间内，使用系统的用户数量。
+- **应用**：并发用户数越多，对系统的压力越大。需要结合响应时间和吞吐量综合分析系统性能。
+- **示例**：电商大促期间同时下单的用户数。
+
+#### 3. **延迟（Latency）**
+
+- **含义**：指网络请求从发出到收到响应的总时间，包括客户端到服务器、服务器到客户端的时间。
+- **应用**：延迟直接影响用户体验，尤其是实时性要求较高的应用，如直播、游戏等。
+- **示例**：在游戏中，玩家的动作延迟超过 100ms，体验可能大幅下降。
+
+#### 4. **队列长度（Queue Length）**
+
+- **含义**：指等待处理的请求数量。
+- **应用**：队列过长通常意味着系统的处理能力不足，可能需要扩容或优化。
+- **示例**：高并发情况下，消息队列中未处理的任务数。
+
+#### 5. **连接数（Connections）**
+
+- **含义**：指系统当前保持的 TCP/IP 连接数。
+- **应用**：对于高并发系统，连接数的管理尤为关键，过多的连接可能导致系统资源耗尽。
+- **示例**：WebSocket 长连接数量。
+
+#### 6. **垃圾回收（GC）频率与时间**
+
+- **含义**：JVM 管理内存时，垃圾回收操作会暂停其他线程，影响系统性能。
+- **应用**：高频或长时间的垃圾回收可能导致系统响应时间变长。
+- **示例**：Full GC 导致服务响应时间超过 1 秒。
+
+#### 7. **事务完成率（Transaction Completion Rate）**
+
+- **含义**：在一定时间内成功完成的事务比例。
+- **应用**：衡量系统处理请求的成功率和稳定性。
+- **示例**：支付系统中，完成支付的交易占总交易数的百分比。
+
+#### 8. **线程池状态**
+
+- **含义**：包括活跃线程数、队列任务数和线程池容量。
+- **应用**：线程池配置不当可能导致任务堆积或线程资源浪费。
+- **示例**：线程池满时，新任务无法执行。
+
+#### 9. **系统高峰负载情况（Peak Load Handling）**
+
+- **含义**：系统在短时间内处理突发高负载的能力。
+- **应用**：用于评估系统弹性和扩展能力。
+- **示例**：秒杀活动瞬间访问量暴增时系统的表现。
+
+#### 10. **可用性（Availability）**
+
+- **含义**：系统在规定时间内能够正常提供服务的时间占比。
+- **应用**：高可用性是系统稳定性的重要体现。
+- **示例**：全年系统可用性达到 99.99%（每年允许停机 52 分钟以内）。
+
+#### 11. **冷启动时间（Cold Start Time）**
+
+- **含义**：系统从启动到完全提供服务所需的时间。
+- **应用**：对于容器化或 Serverless 系统，冷启动时间是关键性能指标。
+- **示例**：某云函数冷启动时间为 300ms。
+
+#### 12. **服务级别目标（SLO）达成率**
+
+- **含义**：实际服务性能达到预定义服务目标（如响应时间、可用性等）的比例。
+- **应用**：SLO 达成率直接影响服务的用户满意度。
+- **示例**：API 响应时间低于 200ms 的请求比例为 98%。
\ No newline at end of file
diff --git "a/docs/md/security/03-OAuth2.0\345\256\236\346\210\230-\350\275\273\346\235\276\345\255\246\344\274\232\344\275\277\347\224\250JWT\357\274\214\350\256\251\344\275\240\347\232\204OAuth2.0\345\256\236\347\216\260\346\233\264\345\212\240\345\256\211\345\205\250\351\253\230\346\225\210\357\274\201.md" "b/docs/md/security/03-OAuth2.0\345\256\236\346\210\230-\350\275\273\346\235\276\345\255\246\344\274\232\344\275\277\347\224\250JWT\357\274\214\350\256\251\344\275\240\347\232\204OAuth2.0\345\256\236\347\216\260\346\233\264\345\212\240\345\256\211\345\205\250\351\253\230\346\225\210\357\274\201.md"
new file mode 100644
index 000000000..e197e3c29
--- /dev/null
+++ "b/docs/md/security/03-OAuth2.0\345\256\236\346\210\230-\350\275\273\346\235\276\345\255\246\344\274\232\344\275\277\347\224\250JWT\357\274\214\350\256\251\344\275\240\347\232\204OAuth2.0\345\256\236\347\216\260\346\233\264\345\212\240\345\256\211\345\205\250\351\253\230\346\225\210\357\274\201.md"
@@ -0,0 +1,413 @@
+# 03-OAuth2.0实战-轻松学会使用JWT，让你的OAuth2.0实现更加安全高效！
+
+## 0 前言
+
+授权服务的核心：颁发访问令牌（accessToken），而OAuth 2.0规范未约束accessToken内容生成规则，只要符合：
+
+- 唯一性
+- 不连续性
+- 不可猜性
+
+可灵活选择令牌形式：
+
+- 既可为无内部结构 && 不含任何信息含义的随机字符串
+- 也可为有内部结构 && 含有信息含义的字符串 
+
+以前生成令牌都是默认一个随机字符串。而结构化令牌，目前用得最多是JWT令牌。
+
+- 加密token
+
+- 无状态token
+
+- 低截取风险
+
+  经过加密的
+
+- 支持跨域：无需存储到 cookie，而是在 header 里传输
+
+- 无CSRF
+
+
+## 1 简介
+
+JSON Web Token（JWT）是个开放标准（RFC 7519），定义一种紧凑、自包含方式，作为JSON对象在各方之间安全地传输信息，结构化封装的方式生成token。
+结构化后的token可被赋予丰富含义，与无意义随机字符串token的最大区别。
+
+## 2 JWT结构
+
+如：
+
+```bash
+eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
+```
+
+在https://jwt.io/解码：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/05/b419e34461dbcb0ff25ec11c5b53b7ce.png)
+
+### 2.1 HEADER
+
+装载令牌类型和算法等信息：
+
+- typ 表示第二部分PAYLOAD是JWT类型
+- alg 表示用HS256对称签名算法
+
+### 2.2 PAYLOAD（数据体）
+
+代表一组数据：
+
+- sub：令牌主体，一般设为资源拥有者的唯一标识
+- exp：令牌的过期时间戳
+- iat：令牌颁发的时间戳
+
+
+是JWT规范性的声明，PAYLOAD表示的一组数据允许我们自定义声明。
+
+### 2.3 SIGNATURE（签名）
+
+签名后的JWT整体结构，被`.`分割的三段内容：`header.payload.signature`。JWT令牌肉眼看也无意义，拷贝到 https://jwt.io/  在线校验，即可看到解码后有意义数据。
+
+`SIGNATURE`表示对JWT信息的签名。
+
+#### 作用
+
+有了`HEADER`和`PAYLOAD`就可让令牌携带信息在网络中传输，但网络中传输这样的信息体不安全。须加密签名，`SIGNATURE`就是对信息的签名结果，当受保护资源接收到三方软件的签名后需要验证令牌的签名是否合法。
+
+## 3 令牌内检
+
+### 3.1 定义
+
+既然授权服务颁发令牌，受保护资源服务就要验证令牌。而受保护资源调用授权服务提供的检验令牌的服务的这种校验令牌方式就叫令牌内检。
+
+### 3.2 特点
+
+有时授权服务依赖DB，然后受保护资源服务也依赖该DB，即“共享DB”。
+
+微服务架构下，不同系统间依靠服务而非DB通信，如【授权服务】给【受保护资源服务】提供一个RPC服务：
+
+![](https://img-blog.csdnimg.cn/20201019174105826.png#pic_center)
+
+JWT令牌本身包含了之前所要依赖DB或依赖RPC服务才能拿到的信息，如某用户为某软件进行授权等信息。
+
+## 4 JWT实现方案
+
+有JWT令牌后的通信方式：
+
+![](https://img-blog.csdnimg.cn/20201019174832919.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_1,color_FFFFFF,t_70#pic_center)
+
+授权服务发个令牌，受保护资源服务接令牌，然后开始解析令牌所含信息，无需再去查询DB或RPC调用。即实现了令牌内检。
+
+### 4.1 HMAC 流程
+
+Hash-based Message Authentication Code，基于哈希函数的消息认证码。验证数据完整性和真实性，通常使用一个共享密钥来计算并验证消息认证码。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/05/f624246b830b9f96d9f58b730ffccb7c.png)
+
+1. 使用Base64编码header和payload，并用"."串联成一个字符串
+2. 使用secret key对上一步得到的字符串进行HMAC签名操作，生成一个签名值
+3. Base64编码签名值，与JWT的header和payload一起组成最终的JWT
+
+接收方在验证JWT时需按照相同的流程计算签名值并将其与JWT中的签名值进行比较，如相同，表明JWT有效。由于签名值的生成过程需要使用密钥，因此只有持有密钥的人才能正确地计算签名值，从而保证JWT安全性。
+
+### 4.2 RSA 流程
+
+Rivest-Shamir-Adleman，一种公钥加密算法，也可用于数字签名。
+
+基于两个大质数的乘积难以分解这一数学难题，利用公钥和私钥配对实现信息的加密和解密，广泛应用于网络安全、数字签名、电子商务等领域。
+
+![](https://img-blog.csdnimg.cn/202101111740200.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_1,color_FFFFFF,t_70)
+
+
+
+1. 使用Base64算法将header和payload进行编码，并用"."串联成字符串
+2. 使用private key对上一步得到的字符串进行RSA签名操作，生成一个签名值
+3. 将签名值进行Base64编码，与JWT的header和payload一起组成最终的JWT。
+
+接收方验证JWT时：
+
+1. 从JWT解析出签名值
+2. 使用public key对JWT的header和payload进行RSA验签操作，得到一个验证结果
+3. 将该结果与JWT中的签名值进行比较，如果相同则表明JWT是有效的
+
+由于私钥只有签发者拥有，因此只有签发者才能正确地给JWT进行签名，而任何人都可以使用公钥进行验签，从而保证了JWT的安全性和可信度。
+
+## 5 为啥令牌要编码且签名？
+
+授权服务颁发JWT后给到xx软件，xx拿着令牌请求受保护资源服务（我在公众号里的文章）。显然令牌要在公网传输。所以传输过程，令牌要做到：
+
+- 编码，防乱码
+- 签名及加密，防数据信息泄露
+
+[jjwt](https://github.com/jwtk/jjwt) 开源的JWT工具，封装了Base64URL编码和对称HMAC、非对称RSA等一系列签名算法，可方便生成一个签名的JWT令牌及解析一个JWT令牌。
+
+```java
+// 密钥
+String sharedTokenSecret="hellooauthhellooauthhellooauthhellooauth";
+Key key = new SecretKeySpec(sharedTokenSecret.getBytes(),
+                SignatureAlgorithm.HS256.getJcaName());
+
+// 生成JWT令牌
+String jwts=
+Jwts.builder()
+ .setHeaderParams(headerMap)
+ .setClaims(payloadMap)
+ .signWith(key,SignatureAlgorithm.HS256)
+ .compact()
+
+// 解析JWT令牌
+Jws<Claims> claimsJws =Jwts.parserBuilder()
+  .setSigningKey(key)
+  .build()
+  .parseClaimsJws(jwts);
+
+JwsHeader header = claimsJws.getHeader();
+Claims body = claimsJws.getBody();
+```
+
+## 6 优点
+
+### 6.1 计算代替存储
+
+时间换空间。
+这种计算并结构化封装，减少了“共享DB” 因远程调用而带来的网络传输性能损耗，所以可能节省时间。
+
+### 6.2 加密
+
+因JWT令牌内部已包含重要信息，所以传输过程都必须被要求密文传输，被强制要求加密也保障了传输安全性。
+
+### 6.3 增强系统可用性和可伸缩性
+
+JWT令牌通过“自编码”包含身份验证所需信息，无需服务端额外存储，所以每次的请求都是无状态会话。符合尽可能遵循无状态架构设计原则，增强了系统可用性和伸缩性。
+
+### 6.4 降低 AuthServer 压力
+
+客户端获取令牌后，后续资源服务器可做自校验，无需到AuthServer校验。
+
+### 6.5 简化AuthServer实现
+
+无需对用户状态会话进行维护和管理
+
+## 7 缺点
+
+### 7.1 无状态和吊销无法两全
+
+无法在使用过程中修改令牌状态。比如我在使用xx时，可能莫须有原因修改了在公众号平台的密码或突然取消了给xx的授权。这时，令牌状态就该有变更，将原来对应令牌置无效。但使用JWT时，每次颁发的令牌都不会存在服务端，无法改变令牌状态。这表示JWT令牌在有效期内都会畅通无阻。
+
+
+
+那可以把JWT令牌存储在一个分布式内存数据库，如Redis吗？
+NO！这违背JWT意义 - **将信息结构化存入令牌本身**。通常有两种方案：
+
+1. 将每次生成JWT令牌时的密钥粒度缩小到用户级别，即一个用户一个密钥
+   如此，当用户取消授权或修改密码，可让该密钥一起修改。这种方案一般还需配套单独密钥管理服务
+2. 在不提供用户主动取消授权的环境里面，若只考虑修改密码场景，即可把用户密码作为JWT的密钥。这也是用户粒度。这样用户修改密码也就相当于修改了密钥。
+
+### 7.2 网络传输开销
+
+随 claims 增多而增大。
+
+## 8 令牌的生命周期
+
+令牌都有【有效期】，只是JWT可将有效期的信息存在自身结构中。
+
+OAuth 2.0的令牌生命周期：
+
+1. 令牌自然过期
+
+![](https://img-blog.csdnimg.cn/20201019193446950.png#pic_center)
+
+该过程不排除**主动销毁令牌**的可能，比如令牌被泄露，授权服务可让令牌失效。
+
+2. 访问令牌失效后可使用刷新令牌请求新令牌，提高用户使用三方软件的体验。
+
+3. 让三方软件比如xx，主动发起令牌失效请求，然后授权服务收到请求后让令牌立即失效。
+
+## 9 何时需要该机制?
+
+比如用户和三方软件存在订购关系：我购买xx软件，到期或退订时且我授权的token还未到期时，就需这样一种令牌撤回协议，支持xx主动发起令牌失效请求。作为开放平台，有责任的三方软件也应遵守这样的令牌撤回协议。
+
+![](https://img-blog.csdnimg.cn/20201019202136483.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_1,color_FFFFFF,t_70#pic_center)
+
+## 10 引入jjwt依赖
+
+###  ≤ 0.10.0
+
+它将所有的功能都打包在一个单独的 `jjwt` artifact 中。
+
+```xml
+<dependency>
+    <groupId>io.jsonwebtoken</groupId>
+    <artifactId>jjwt</artifactId>
+    <version>0.9.1</version>
+</dependency>
+```
+
+### ≥  0.11.x
+
+```xml
+<dependency>
+    <groupId>io.jsonwebtoken</groupId>
+    <artifactId>jjwt-api</artifactId>
+    <version>0.11.5</version>
+</dependency>
+<dependency>
+    <groupId>io.jsonwebtoken</groupId>
+    <artifactId>jjwt-impl</artifactId>
+    <version>0.11.5</version>
+    <scope>runtime</scope>
+</dependency>
+<dependency>
+    <groupId>io.jsonwebtoken</groupId>
+    <artifactId>jjwt-jackson</artifactId> <!-- or jjwt-gson if Gson is preferred -->
+    <version>0.11.5</version>
+    <scope>runtime</scope>
+</dependency>
+```
+
+ jjwt 库在 0.10.0 版本之后推荐的引入方式。它将 jjwt 库拆分成了三个独立的模块：
+
+- **`jjwt-api`:** 包含 JWT 规范的接口和抽象类，定义了 JWT 的基本操作，但不包含任何具体实现。这是你**必须**引入的依赖。
+- **`jjwt-impl`:** 包含了 `jjwt-api` 中接口的具体实现，负责 JWT 的生成、解析、签名和验证等核心逻辑。`scope` 设置为 `runtime`，意味着在编译时不需要，但在运行时是必需的。
+- **`jjwt-jackson` (或 `jjwt-gson`):** 提供了使用 Jackson (或 Gson) 库进行 JSON 处理的功能。用于将 JWT 的 payload 部分转换为 Java 对象，或将 Java 对象转换为 JWT 的 payload。同样，`scope` 设置为 `runtime`。
+
+###  区别
+
+1. **模块化：** 0.10.0 版本之后引入了模块化设计，将 jjwt 库拆分为 `jjwt-api`、`jjwt-impl` 和 `jjwt-jackson` (或 `jjwt-gson`) 三个模块：
+   - **更小的依赖体积：** 只引入需要的模块，减少了最终应用程序的体积。
+   - **更好的依赖管理：** 更清晰的依赖关系，避免了潜在的冲突。
+   - **更灵活的配置：** 可以根据需要选择不同的 JSON 处理库 (Jackson 或 Gson)。
+2. **性能和安全性改进：** 0.10.0 及以上版本通常包含性能优化和安全修复。使用较新的版本可以获得更好的性能和更高的安全性。
+3. **API 变更：** 0.10.0 版本引入了一些 API 变更，因此使用 0.9.1 版本的代码可能需要进行修改才能在新版本上运行。
+4. **维护状态：** 0.9.1 版本已经非常老旧，不再维护。使用最新版本可以获得 bug 修复和安全更新。
+
+### 生成 JWT
+
+
+
+```java
+// 1. 对密钥执行base64编码
+String base64 = new BASE64Encoder().encode(USER_KEY.getBytes());
+
+// 2. 对base64生成一个秘钥对象
+SecretKey secretKey = Keys.hmacShaKeyFor(base64.getBytes());
+
+// 3. 通过jwt生成token字符串
+Stu stu = new Stu(1001, "编程严选网", 18);
+String stuJson = new Gson().toJson(stu);
+
+String myJWT = Jwts.builder()
+        // 设置用户自定义数据
+        .setSubject(stuJson)
+        // 使用哪个秘钥对象进行jwt的生成
+        .signWith(secretKey)
+        // 压缩并且生成jwt
+        .compact();
+
+System.out.println(myJWT);
+}
+```
+
+### 校验JWT
+
+
+
+```java
+@Test
+public void checkJWT() {
+    // 前端传来的jwt
+    String jwt = "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ7XCJpZFwiOjEwMDEsXCJuYW1lXCI6XCJpbW9vYyDmhZXor77nvZFcIixcImFnZVwiOjE4fSJ9.THFIuA6VxihfflzDFE0u3_E2gFeeWrH-qQjFnpCgof4";
+
+    // 1. 对秘钥进行base64编码
+    String base64 = new BASE64Encoder().encode(USER_KEY.getBytes());
+
+    // 2. 对base64生成一个秘钥的对象
+    SecretKey secretKey = Keys.hmacShaKeyFor(base64.getBytes());
+
+    // 3. 校验jwt
+
+    // 构造解析器
+    JwtParser jwtParser = Jwts.parserBuilder()
+            .setSigningKey(secretKey)
+            .build();
+    // 解析成功，可以获得Claims，从而去get相关的数据，如果此处抛出异常，则说明解析不通过，也就是token失效或者被篡改
+    // 解析jwt
+    Jws<Claims> jws = jwtParser.parseClaimsJws(jwt);
+
+    String stuJson = jws.getBody().getSubject();
+    Stu stu = new Gson().fromJson(stuJson, Stu.class);
+
+    System.out.println(stu);
+}
+```
+
+ 创建属性配置文件：
+
+![](https://img-blog.csdnimg.cn/178cef41820949968241ff836dafcad1.png)
+
+代码引用它：
+
+```java
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.stereotype.Component;
+
+@Component
+@Data
+@PropertySource("classpath:jwt.properties")
+@ConfigurationProperties(prefix = "auth")
+public class JWTProperties {
+    private String key;
+}
+```
+
+万一 auth.key 泄露了呢？防止内鬼，定期更新 key，就需要动态配置中心。
+
+【hire-api】服务
+
+![](https://img-blog.csdnimg.cn/53ed5c1871504bf5ac9bdd35fb6917ff.png)
+
+新建配置：
+
+![](https://img-blog.csdnimg.cn/5d2f7814f4ec4531a23ddc5ce8680718.png)
+
+业务服务都启动完成后，修改配置，重新发布：
+
+![](https://img-blog.csdnimg.cn/5bae1b8b3668428599e0d604c97bd26f.png)
+
+这是通过 @RefreshScope 注解实现的
+
+```java
+@Component
+@Slf4j
+@RefreshScope
+public class JWTUtils {
+
+    public static final String at = "@";
+
+    @Autowired
+    private JWTProperties jwtProperties;
+
+    @Value("${jwt.key}")
+    public String JWT_KEY;
+  	
+  	...
+}
+```
+
+## 11 总结
+
+OAuth 2.0 的核心是授权服务，没有令牌就没有OAuth，令牌表示授权后的结果。令牌在OAuth 2.0系统中对于第三方软件都是不透明的。需要关心令牌的，是授权服务和受保护资源服务。
+
+1. JWT默认不加密，但也可加密。生成原始 Token 后，可用密钥再加密一次
+2. JWT不加密时，不能将秘密数据写入JWT
+3. JWT不仅可用于认证，也可以用于交换信息。有效使用 JWT，可降低服务器查询数据库的次数
+4. JWT 的最大缺点是，由于服务器不保存 session 状态，因此无法在使用过程中废止某个 token，或者更改 token 的权限。即一旦 JWT 签发了，在到期之前就会始终有效，除非服务器部署额外逻辑
+5. JWT本身包含认证信息，一旦泄露，任何人都能获得该令牌的所有权限。为了减少盗用，JWT 的有效期应该设置得比较短。对于一些比较重要的权限，使用时应该再次对用户进行认证
+6. 为减少盗用，JWT 不应使用 HTTP 协议明码传输，要使用 HTTPS 协议传输
+
+参考：
+
+- [JSON Web Token 入门教程](http://www.ruanyifeng.com/blog/2018/07/json_web_token-tutorial.html)
+- 在OAuth 2.0中，如何使用JWT结构化令牌？
+- https://tools.ietf.org/html/rfc6749#section-4.4
\ No newline at end of file
diff --git "a/docs/md/security/07-\344\275\240\347\241\256\345\256\232\346\207\202OAuth 2.0\347\232\204\344\270\211\346\226\271\350\275\257\344\273\266\345\222\214\345\217\227\344\277\235\346\212\244\350\265\204\346\272\220\346\234\215\345\212\241\357\274\237.md" "b/docs/md/security/07-\344\275\240\347\241\256\345\256\232\346\207\202OAuth 2.0\347\232\204\344\270\211\346\226\271\350\275\257\344\273\266\345\222\214\345\217\227\344\277\235\346\212\244\350\265\204\346\272\220\346\234\215\345\212\241\357\274\237.md"
new file mode 100644
index 000000000..d81e121d8
--- /dev/null
+++ "b/docs/md/security/07-\344\275\240\347\241\256\345\256\232\346\207\202OAuth 2.0\347\232\204\344\270\211\346\226\271\350\275\257\344\273\266\345\222\214\345\217\227\344\277\235\346\212\244\350\265\204\346\272\220\346\234\215\345\212\241\357\274\237.md"	
@@ -0,0 +1,139 @@
+# 07-你确定懂OAuth 2.0的三方软件和受保护资源服务？
+
+## 0 前言
+
+本文旨在阐明 OAuth2.0 体系中第三方软件和受保护资源服务的职责。
+
+## 1 构建第三方软件应用
+
+若基于公众号开放平台构建一个xx文章排版软件的轻应用，需要先到公众号开放平台申请注册成为开发者，再创建个应用就可以开始开发了。
+
+### 1.1 开发过程的关键节点
+
+#### 1.1.1 注册信息
+
+xx软件须先有身份，才能参与 OAuth 2.0 流程。即xx需要拥有 `app_id` 、 `app_serect`、自己的回调地址 `redirect_uri`、申请权限等信息。这称为**静态注册**，即xx开发人员提前登录到公众号开放平台手动注册，以便后续使用这些注册的相关信息来请求访问令牌。
+
+#### 1.1.2 引导授权
+
+当用户要用三方软件操作在受保护资源上的数据，就需要三方软件引导授权。我要用xx来对我公众号里的文章排版时，我首先访问的一定是xx软件，而不是授权服务&受保护资源服务。
+
+但xx又需要我的授权，只有授权服务才能允许我的操作。所以xx需要将我引导至授权服务
+
+```java
+String oauthUrl = "http://localhost:8081/Oauth?reqType=oauth";
+response.sendRedirect(toOauthUrl);
+```
+
+让用户我来为三方软件授权，得到授权后，三方软件才可代表用户去访问数据。即xx获得授权后，就能代表我去排版文章。
+
+#### 1.1.3 使用访问令牌（accessToken）
+
+**第三方软件的最终目的：拿到令牌后去使用令牌**。目前OAuth 2.0 令牌只支bearer类型令牌，即任意字符串格式的令牌。
+
+官方规范给出的使用accessToken请求的方式，有如下：
+
+##### ① Form-Encoded Body Parameter（表单参数）
+
+
+
+![](https://img-blog.csdnimg.cn/20201020221534153.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_1,color_FFFFFF,t_70#pic_center)
+
+##### ② URI Query Parameter（URI 查询参数）
+
+
+
+![](https://img-blog.csdnimg.cn/20201020221551723.png#pic_center)
+
+##### ③ Authorization Request Header Field（授权请求头部字段）
+
+
+
+![](https://img-blog.csdnimg.cn/20201020221605988.png#pic_center)
+
+##### 选型
+
+- OAuth 2.0 官方建议，系统在接入 OAuth 2.0 前信息传递的请求载体是 JSON，若继续采用表单参数提交，令牌就无法加入
+- 若采用参数传递，URI 会被整体复制，安全性最差
+- 请求头部字段无上述顾虑，因此被官方推荐
+
+但我推荐采用表单提交 POST 方式提交令牌，类似代码如下。毕竟官方建议指在接入 OAuth 2.0 前，若你已采用 JSON 请求体条件下，才不建议使用表单提交。倘若一开始三方软件和平台都一致采用表单提交，就没问题了。因为**表单提交在保证安全传输同时，无需处理 Authorization 头部信息。**
+
+```java
+String protectedURl="http://localhost:8081/ProtectedServlet";
+Map<String, String> paramsMap = new HashMap<String, String();
+paramsMap.put("app_id","APPID_XX);
+paramsMap.put("app_secret","APPSECRET_XX");
+paramsMap.put("token",accessToken);
+
+String result = HttpURLClient.doPost(protectedURl,HttpURLClient.mapToStr(paramsMap));
+```
+
+#### 1.1.4 使用刷新令牌
+
+Q：若访问令牌过期了，xx总不能立马提示让我这客户重新授权吧！？
+
+A：就需要刷新令牌。需注意何时决定使用刷新令牌。
+
+xx排版软件收到accessToken同时，也会收到accessToken的过期时间 `expires_in`。优秀的三方软件应将 `expires_in` 值保存并定时检测；若发现 `expires_in` 即将过期，则需利用 `refresh_token` 重新请求授权服务，获取新的有效accessToken。
+
+除定时检测提前发现访问令牌是否快过期，还有“现场”发现。如xx访问我的公众号文章时，突然收到accessToken已失效响应，此时xx立即使用 `refresh_token` 请求一个访问令牌，以便继续代表我使用我的这些文章数据。
+
+综上：
+
+- 定时检测方案，需开发定时任务
+- “现场”发现，就没这额外工作咯
+
+还是推荐定时检测，因带来“提前量”，以便更好掌握主动权。
+
+刷新令牌是一次性的，使用后就失效，但其有效期会比accessToken长。
+
+**若刷新令牌也过期呢？**需将刷新令牌和accessToken都放弃，几乎回到系统初始状态，只能让用户重授权。
+
+### 1.2  服务市场
+
+啥是服务市场？
+
+![](https://img-blog.csdnimg.cn/2020102022540819.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_1,color_FFFFFF,t_70#pic_center)
+
+三方开发者开发的软件，都发布到这样一个“市场”里售卖。
+
+## 2 构建受保护资源服务
+
+受保护资源最终指向 API，比如排版软件中的受保护资源就是文章查询 API、批量查询 API 等及公众号头像、昵称的 API。授权服务最终保护的就是这些 API。
+
+构建受保护资源服务时，除检查令牌的合法性，更关键是权限范围。校验权限的占比大。肯定要看该令牌到底能操作啥、能访问啥数据。
+
+### 2.1 不同权限对应不同操作
+
+**操作**对应 API，如公众号平台提供有查询、新增、删除文章 API。若xx请求过来的一个access_token的 scope 权限范围只对应查询、新增 API，那包含该 access_token 值的请求，无法执行删除文章 API。
+
+### 2.2 不同权限对应不同数据
+
+数据，指某 API 里包含的字段信息。如有一个查询我的信息的API，返回值包括 Contact（email、phone、qq）、Like（Basketball、Swimming）、Personal Data（sex、age、nickname）。若xx请求过来的一个访问令牌 access_token 的 scope 权限范围只对应 Personal Data，那么包含该 access_token 值的请求就不能获取到 Contact 和 Like 的信息。
+
+这种权限范围的粒度要比“不同的权限对应不同的操作”的粒度要小，遵循最小权限范围原则。
+
+### 2.3 不同用户对应不同数据
+
+这种权限实际上只是换了一种维度，将其定位到用户。
+
+一些基础类信息，比如获取地理位置、天气预报，不带用户归属属性，即这些并不归属某用户，是公有信息。这样信息，平台提供出去的 API 接口都是“中性”的，没有用户属性。
+
+但更多场景却是基于用户属性。用户每次推送文章，xx都要知道文章是哪个用户的。用户为xx授权，xx获取的 access_token 实际上就包含公众号用户的这个用户属性。
+公众号开放平台的受保护资源服务每次接收到xx的请求，都会根据该请求中
+access_token 的值找到对应的用户 ID，继而根据用户 ID 查询到该用户的文章，即不同用户对应不同文章数据。
+
+## 3 微服务的API GATEWAY意义
+
+若有很多受保护资源服务，如提供：
+
+- 用户信息查询的用户资源服务
+- 文章查询的文章资源服务
+- 视频查询的视频资源服务
+
+每个受保护资源服务岂不是都要把上述权限范围校验执行一遍，不就大量重复？为解决这问题，应有统一网关层处理校验，所有请求都经过，再跳转到不同受保护资源服务。如此无需在每个受保护资源服务上都做权限校验，只在 API GATEWAY 做即可。
+
+参考：
+
+- 如何安全、快速地接入OAuth 2.0
\ No newline at end of file
diff --git a/docs/md/spring/mastering-multi-tenancy-with-spring-multi-tenancy-library.md b/docs/md/spring/mastering-multi-tenancy-with-spring-multi-tenancy-library.md
new file mode 100644
index 000000000..43b2b66aa
--- /dev/null
+++ b/docs/md/spring/mastering-multi-tenancy-with-spring-multi-tenancy-library.md
@@ -0,0 +1,464 @@
+# 利用 Spring 多租户库掌握多租户技术
+
+驾驭现代软件平台中租户隔离的复杂性：
+
+![](https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*ikcqGAC9JkUHTosOfHitfw.png)
+
+## 0 前言
+
+Spring 多租户库为实施多租户应用程序提供了标准化方法。本指南将引导您使用 Spring 多租户库创建一个稳健、可扩展的游戏平台。
+
+## 1 项目依赖
+
+
+
+```xml
+<dependencies>
+    <dependency>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-web</artifactId>
+    </dependency>
+    <dependency>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-data-jpa</artifactId>
+    </dependency>
+    <dependency>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-multitenancy</artifactId>
+        <version>3.2.0</version>
+    </dependency>
+    <dependency>
+        <groupId>org.postgresql</groupId>
+        <artifactId>postgresql</artifactId>
+    </dependency>
+</dependencies>
+```
+
+## 2 核心理念
+
+
+
+### 2.1 解决租户问题
+
+```java
+@Component
+public class AdvancedTenantResolver implements TenantResolver {
+    // Multiple resolution strategies
+    @Override
+    public DataSource resolveDataSource(TenantResolveRequest request) {
+        // Resolution strategies prioritized:
+        // 1. Header-based
+        // 2. Subdomain-based
+        // 3. Path-based
+        // 4. Fallback mechanism
+    }
+}
+```
+
+主要解决策略：
+
+- 基于头信息：通过 HTTP 标头识别租户
+
+```bash
+Uses custom HTTP header X-Game-Tenant
+Ideal for API-driven applications
+Example: curl -H "X-Game-Tenant: aggregator1" https://api.gameplatform.com/games
+```
+
+- 基于子域：租户来自子域
+
+```bash
+Extracts tenant from subdomain
+Common in SaaS platforms
+Example: https://aggregator1.gameplatform.com
+```
+
+- 基于路径：从 URL 路径提取租户
+
+```bash
+Tenant identified in URL path
+Suitable for REST-like architectures
+Example: https://gameplatform.com/game-platform/games
+```
+
+- 查询参数解析
+
+```bash
+Tenant specified as query parameter
+Flexible for various use cases
+Example: https://gameplatform.com/games?tenant=aggregator1
+```
+
+- 后备机制：无法解决时的默认租户
+
+#### 所有策略的代码
+
+```java
+import org.springframework.multitenancy.core.TenantResolver;
+import org.springframework.multitenancy.core.TenantResolveRequest;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+
+import javax.sql.DataSource;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+@Component
+public class MultiTenantResolutionStrategies implements TenantResolver {
+    // Simulated tenant data sources
+    private static final Map<String, DataSource> TENANT_DATA_SOURCES = new ConcurrentHashMap<>() {{
+        put("aggregator1", createMockDataSource("aggregator1"));
+        put("aggregator2", createMockDataSource("aggregator2"));
+        put("game-platform", createMockDataSource("game-platform"));
+    }};
+
+    // 1. Header-Based Tenant Resolution
+    private String resolveByHeader(TenantResolveRequest request) {
+        // Resolve tenant from custom HTTP header
+        String tenantHeader = request.getHttpServletRequest()
+            .getHeader("X-Game-Tenant");
+        
+        if (StringUtils.hasText(tenantHeader)) {
+            System.out.println("Tenant Resolved via Header: " + tenantHeader);
+            return tenantHeader;
+        }
+        return null;
+    }
+
+    // 2. Subdomain-Based Tenant Resolution
+    private String resolveBySubdomain(TenantResolveRequest request) {
+        // Extract tenant from subdomain
+        String host = request.getHttpServletRequest().getServerName();
+        String[] subdomains = host.split("\\.");
+        
+        if (subdomains.length > 1) {
+            String subdomain = subdomains[0];
+            System.out.println("Tenant Resolved via Subdomain: " + subdomain);
+            return subdomain;
+        }
+        return null;
+    }
+
+    // 3. Path-Based Tenant Resolution
+    private String resolveByPath(TenantResolveRequest request) {
+        // Extract tenant from URL path
+        String requestURI = request.getHttpServletRequest().getRequestURI();
+        String[] pathSegments = requestURI.split("/");
+        
+        // Assuming tenant is the first path segment after root
+        if (pathSegments.length > 1 && 
+            !pathSegments[1].isEmpty() && 
+            TENANT_DATA_SOURCES.containsKey(pathSegments[1])) {
+            
+            String tenantFromPath = pathSegments[1];
+            System.out.println("Tenant Resolved via Path: " + tenantFromPath);
+            return tenantFromPath;
+        }
+        return null;
+    }
+
+    // 4. Query Parameter-Based Tenant Resolution
+    private String resolveByQueryParam(TenantResolveRequest request) {
+        // Extract tenant from query parameter
+        String tenantParam = request.getHttpServletRequest()
+            .getParameter("tenant");
+        
+        if (StringUtils.hasText(tenantParam)) {
+            System.out.println("Tenant Resolved via Query Param: " + tenantParam);
+            return tenantParam;
+        }
+        return null;
+    }
+
+    // Main resolution method - combines all strategies
+    @Override
+    public DataSource resolveDataSource(TenantResolveRequest request) {
+        // Resolution order: 
+        // 1. Header
+        // 2. Subdomain
+        // 3. Path
+        // 4. Query Parameter
+        // 5. Fallback to default
+        
+        String resolvedTenant = 
+            resolveByHeader(request) != null 
+                ? resolveByHeader(request) 
+                : resolveBySubdomain(request) != null 
+                    ? resolveBySubdomain(request)
+                    : resolveByPath(request) != null 
+                        ? resolveByPath(request)
+                        : resolveByQueryParam(request) != null 
+                            ? resolveByQueryParam(request)
+                            : "default-aggregator";
+
+        // Retrieve and return the corresponding DataSource
+        DataSource tenantDataSource = TENANT_DATA_SOURCES.getOrDefault(
+            resolvedTenant, 
+            TENANT_DATA_SOURCES.get("default-aggregator")
+        );
+
+        System.out.println("Final Resolved Tenant: " + resolvedTenant);
+        return tenantDataSource;
+    }
+
+    // Utility method to create mock DataSource
+    private static DataSource createMockDataSource(String tenantId) {
+        return new MockDataSource(tenantId);
+    }
+
+    // Inner class for mock DataSource
+    private static class MockDataSource implements DataSource {
+        private final String tenantId;
+
+        public MockDataSource(String tenantId) {
+            this.tenantId = tenantId;
+        }
+
+        // Implement DataSource methods (simplified for demonstration)
+        @Override
+        public java.sql.Connection getConnection() {
+            System.out.println("Connecting to tenant database: " + tenantId);
+            return null; // Mock implementation
+        }
+
+        // Other DataSource method implementations would go here
+        // (Omitted for brevity)
+    }
+}
+```
+
+### 2.2 租户背景管理
+
+
+
+```java
+public class TenantContextManager {
+    // Thread-local storage of tenant information
+    private static final ThreadLocal<TenantContext> currentTenant = new ThreadLocal<>();
+    // Methods to manage tenant context
+    public void setTenantContext(TenantContext context) {
+        currentTenant.set(context);
+    }
+    public TenantContext getCurrentTenant() {
+        return currentTenant.get();
+    }
+    public void clearTenantContext() {
+        currentTenant.remove();
+    }
+}
+```
+
+情境管理功能：
+
+- 线程安全租户信息存储
+- 动态租户切换
+- 自动清理上下文
+
+### 2.3 高级配置
+
+
+
+```java
+@Configuration
+@EnableMultitenancy
+public class MultitenancyAdvancedConfiguration {
+    @Bean
+    public MultitenancyConfigurer multitenancyConfigurer() {
+        return MultitenancyConfigurer.builder()
+            .tenantResolver(customTenantResolver())
+            .defaultTenant("primary-aggregator")
+            .tenantValidation(this::validateTenant)
+            .dataSourceProvider(customDataSourceProvider())
+            .build();
+    }
+private boolean validateTenant(String tenantId) {
+        // Comprehensive tenant validation
+        return StringUtils.hasText(tenantId) && 
+               tenantId.matches("^[a-zA-Z0-9-]+$") && 
+               tenantId.length() <= 50 &&
+               isValidBusinessTenant(tenantId);
+    }
+    private DataSourceProvider customDataSourceProvider() {
+        return new DataSourceProvider() {
+            @Override
+            public DataSource getDataSource(String tenantId) {
+                // Custom data source creation logic
+                return createTenantSpecificDataSource(tenantId);
+            }
+        };
+    }
+}
+```
+
+高级配置组件：
+
+- 自定义租户解析器
+- 租户验证
+- 动态数据源供应
+- 灵活的配置生成器
+
+### 2.4 租户意识实体
+
+
+
+```java
+@Entity
+@MultitenantEntity
+public class GamePlatformEntity {
+    @Id
+    @GeneratedValue
+    private Long id;
+    @TenantColumn
+    private String tenantId;
+    // Tenant-specific fields and logic
+    @Column(name = "tenant_specific_config")
+    private String tenantConfiguration;
+    // Automatic tenant assignment
+    @PrePersist
+    public void setTenantBeforeCreate() {
+        this.tenantId = TenantContextHolder.getCurrentTenant();
+    }
+}
+```
+
+实体多租户功能：
+
+- 自动分配租户 ID
+- 租户专栏
+- 预存租户上下文捕捉
+
+### 2.5 动态租户供应
+
+
+
+```java
+@Service
+public class TenantProvisioningService {
+    @Autowired
+    private MultitenancyConfigurer multitenancyConfigurer;
+
+    public void createNewTenant(TenantProvisionRequest request) {
+            // Comprehensive tenant creation process
+            DataSource tenantDataSource = createTenantDataSource(request);
+            
+            multitenancyConfigurer.addTenant(
+                request.getTenantId(), 
+                tenantDataSource
+            );
+        }
+        private DataSource createTenantDataSource(TenantProvisionRequest request) {
+            HikariDataSource dataSource = new HikariDataSource();
+            dataSource.setJdbcUrl(generateTenantDatabaseUrl(request.getTenantId()));
+            dataSource.setUsername(request.getUsername());
+            dataSource.setPassword(request.getPassword());
+            
+            // Additional configuration
+            dataSource.setMaximumPoolSize(10);
+            dataSource.setConnectionTimeout(30000);
+            
+            return dataSource;
+        }
+}
+```
+
+调配功能：
+
+- 动态增加租户
+- 可配置的数据源创建
+- 连接池管理
+
+### 2.6 安全考虑因素
+
+
+
+```java
+@Configuration
+public class TenantSecurityConfiguration {
+    @Bean
+    public SecurityFilterChain tenantSecurityFilterChain(HttpSecurity http) throws Exception {
+        http
+            .authorizeHttpRequests(authz -> authz
+                .requestMatchers("/tenant/**").hasRole("TENANT_ADMIN")
+                .requestMatchers("/api/**").authenticated()
+            )
+            .tenantValidation(validator -> 
+                validator.addTenantValidator(this::customTenantValidator)
+            );
+        
+        return http.build();
+    }
+    private boolean customTenantValidator(String tenantId) {
+            // Advanced tenant validation
+            return tenantRepository.existsByTenantId(tenantId) &&
+                   !tenantRepository.isSuspended(tenantId);
+        }
+    }
+```
+
+安全机制：
+
+- 基于角色的租户访问
+- 自定义租户验证
+- 全面的安全过滤器
+
+### 2.7 性能优化
+
+
+
+```java
+@Configuration
+public class MultitenancyPerformanceConfig {
+    @Bean
+    public CacheManager tenantCacheManager() {
+        return CacheManagerBuilder
+            .newCacheManagerBuilder()
+            .withCache("tenantCache", 
+                CacheConfigurationBuilder
+                    .newCacheConfigurationBuilder(String.class, DataSource.class)
+                    .withExpiry(ExpiryPolicy.CREATED)
+                    .build()
+            )
+            .build();
+    }
+}
+```
+
+性能提升：
+
+- 租户解析缓存
+- 连接池优化
+- 高效的上下文管理
+
+## 3 主要优势
+
+### 标准化多租户
+
+- 连贯一致的实施
+- 轻松配置
+- 灵活的租户管理
+
+### 性能
+
+- 高效解决租户问题
+- 最低管理费用
+- 可扩展架构
+
+### 安全
+
+- 稳健的租户隔离
+- 全面验证
+- 灵活的访问控制
+
+## 4 潜在挑战
+
+1. 配置复杂性
+2. 租户多时的性能开销
+3. 系统复杂性增加
+
+## 5 最佳实践
+
+1. 实施全面的租户验证
+2. 使用连接池
+3. 实施强大的日志记录功能
+4. 定期进行安全审计
+5. 考虑缓存策略
\ No newline at end of file
diff --git "a/docs/md/vue/05-\346\225\231\344\275\240\345\277\253\351\200\237\346\220\255\345\273\272Vue3\345\267\245\347\250\213\345\214\226\351\241\271\347\233\256.md" "b/docs/md/vue/05-\346\225\231\344\275\240\345\277\253\351\200\237\346\220\255\345\273\272Vue3\345\267\245\347\250\213\345\214\226\351\241\271\347\233\256.md"
index 6b13d1eea..bb569bd6f 100644
--- "a/docs/md/vue/05-\346\225\231\344\275\240\345\277\253\351\200\237\346\220\255\345\273\272Vue3\345\267\245\347\250\213\345\214\226\351\241\271\347\233\256.md"
+++ "b/docs/md/vue/05-\346\225\231\344\275\240\345\277\253\351\200\237\346\220\255\345\273\272Vue3\345\267\245\347\250\213\345\214\226\351\241\271\347\233\256.md"
@@ -79,11 +79,9 @@ npm init @vitejs/app
 
 ### 2.3 store/index.js
 
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/07/2684c1adca1bd76b97dd381ef8b760ba.png)
 
-
-![](https://p.ipic.vip/r68ds9.png)
-
-- 通过 按需导入的createStore 万江来来构建store 实例
+- 通过按需导入的createStore来构建store实例
 - 无需再通过 Vue.use(vuex) 形式挂载
 
 ### 2.4 route/index.js
@@ -132,11 +130,9 @@ vue3 的初始化项目中，与 vue2 对比的最大差异其实就是：
 - 使用Vite作为工程化工具
 - 使用Chrome进行调试
 
-都是Vue 3工程化体系的必备工具。
-
-![image-20231012142759413](https://p.ipic.vip/rcfu0k.png)
-
+都是Vue3工程化体系的必备工具。
 
+![](https://p.ipic.vip/rcfu0k.png)
 
 开发项目是多页面，所以vue-router和Vuex也成为必选：
 
@@ -154,7 +150,7 @@ npm install vue-router@next vuex@next
 
 ## 3 规范
 
-无规矩不成方圆，团队项目中的规范尤其重要。我们先对几个文件夹的分层进行规定，便于管理，下面是src目录的组织结构。
+团队项目的规范。先规定几个文件夹的分层，便管理，如src目录的组织结构：
 
 ```bash
 ├── src
@@ -171,43 +167,36 @@ npm install vue-router@next vuex@next
 
 ```js
 import {
-    createRouter,
-    createWebHashHistory,
-  } from 'vue-router'
-  import Home from '../pages/home.vue'
-  import About from '../pages/about.vue'
-
-  const routes = [
-    {
-      path: '/',
-      name: 'Home',
-      component: Home
-    },
-    {
-      path: '/about',
-      name: 'About',
-      component: About
-    }
-  ]
-
-  const router = createRouter({
-    history: createWebHashHistory(),
-    routes
-  })
-
-  export default router
+  createRouter,
+  createWebHashHistory,
+} from 'vue-router'
+import Home from '../pages/home.vue'
+import About from '../pages/about.vue'
+
+// 引入两个组件：about、home
+const routes = [
+  {
+    path: '/',
+    name: 'Home',
+    component: Home
+  },
+  {
+    path: '/about',
+    name: 'About',
+    component: About
+  }
+]
+
+// createRouter，新建路由实例
+const router = createRouter({
+  // createWebHashHistory，配置我们内部使用hash模式的路由，即url上会通过 `#` 区分
+  history: createWebHashHistory(),
+  routes
+})
+
+export default router
 ```
 
-先引入两个函数：
-
-- createRouter，新建路由实例
-- createWebHashHistory，配置我们内部使用hash模式的路由，即url上会通过 `#` 区分
-
-再引入两个组件：
-
-- about
-- home
-
 根据不同访问地址：
 
 - `/` 
@@ -215,7 +204,7 @@ import {
 
 渲染不同的组件，最后返回router。
 
-现在页面报错：找不到about和home组件。去pages下新建两个文件，分别输入：
+现页面报错：找不到about和home组件。去pages下新建两个文件，分别输入：
 
 ```vue
 <template>
diff --git "a/docs/md/vue/Vuex\350\256\276\350\256\241Vue3\351\241\271\347\233\256\347\232\204\346\225\260\346\215\256\346\265\201.md" "b/docs/md/vue/Vuex\350\256\276\350\256\241Vue3\351\241\271\347\233\256\347\232\204\346\225\260\346\215\256\346\265\201.md"
index 9dfde77ac..97950cace 100644
--- "a/docs/md/vue/Vuex\350\256\276\350\256\241Vue3\351\241\271\347\233\256\347\232\204\346\225\260\346\215\256\346\265\201.md"
+++ "b/docs/md/vue/Vuex\350\256\276\350\256\241Vue3\351\241\271\347\233\256\347\232\204\346\225\260\346\215\256\346\265\201.md"
@@ -1,4 +1,4 @@
-# Vuex设计Vue3项目的数据流
+# 10-Vuex设计Vue3项目的数据流
 
 ## 1 前端数据管理
 
diff --git a/docs/md/vue/router.md b/docs/md/vue/router.md
new file mode 100644
index 000000000..574de948b
--- /dev/null
+++ b/docs/md/vue/router.md
@@ -0,0 +1,493 @@
+# 11-Vue3最新Router带来哪些颠覆性变化？
+
+## 1 前后端开发模式的演变
+
+jQuery时代对大部分Web项目，前端都不能控制路由，要依赖后端项目的路由系统。通常，前端项目也部署在后端项目的模板里，项目执行示意图：
+
+![](https://p.ipic.vip/ex9q3u.png)
+
+jQuery时代前端都要学会在后端模板如JSP里写代码。此时，前端工程师无需了解路由。对每次的页面跳转，都由后端负责重新渲染模板。
+
+前端依赖后端，且前端无需负责路由，有很多优点，如开发速度快、后端也承担部分前端任务，所以至今很多内部管理系统还这样。
+
+也有缺点，如：
+
+- 前后端项目无法分离
+- 页面跳转由于需重新刷新整个页面、等待时间较长，让交互体验下降
+
+为提高页面交互体验，很多前端做不同尝试。前端开发模式变化，项目结构也变化。目前前端开发中，用户访问页面后代码执行的过程：
+
+![](https://p.ipic.vip/nunekr.png)
+
+- 用户访问路由后，无论URL地址，都直接渲染一个前端的入口文件index.html，然后在index.html文件中加载JS、CSS
+- 之后，js获取当前页面地址及当前路由匹配的组件
+- 再去动态渲染当前页面
+
+用户在页面上点击时，也不需刷新页面，而直接通过JS重新计算出匹配的路由渲染。
+
+前后两个示意图中，绿色的部分表示的就是前端负责的内容。后面这架构下，前端获得路由的控制权，在js中控制路由系统。也因此，页面跳转时就不需刷新页面，网页浏览体验提高。 这种所有路由都渲染一个前端入口文件的方式，是单页面应用程序（SPA）的雏形。
+
+通过js动态控制数据去提高用户体验的方式并不新奇，Ajax让数据获取不需刷新页面，SPA应用让路由跳转也不需要刷新页面。这种开发模式在jQuery时代就出来，浏览器路由的变化可以通过pushState来操作，这种纯前端开发应用的方式，以前称Pjax （pushState+ Ajax）。之后，这种开发模式在MVVM框架时代放异彩，现在大部分使用Vue/React/Angular应用都这种架构。
+
+SPA应用相比于模板的开发方式，对前端更友好，如：
+
+- 前端对项目控制权更大
+- 交互体验更丝滑
+- 前端项目终于可独立部署
+
+完成了前后端系统完全分离。
+
+## 2 前端路由的实现原理
+
+通过URL区分路由的机制，有两种实现：
+
+- hash模式，通过URL中#后面的内容做区分，hash-router
+- history模式，路由看起来和正常URL一致
+
+对应vue-router的函数：
+
+- createWebHashHistory
+- createWebHistory
+
+![](https://p.ipic.vip/upar9u.png)
+
+### 2.1 hash 模式
+
+单页应用在页面交互、页面跳转上都是无刷新的，极大提高用户访问网页的体验。 为实现单页应用，前端路由的需求也变重要。
+
+类似服务端路由，前端路由实现也简单，就是匹配不同 URL 路径，进行解析，然后动态渲染出区域 HTML 内容。但URL每次变化都会造成页面的刷新。解决思路：改变 URL 时保证页面的不刷新。
+
+2014年前，大家通过 hash 实现前端路由，URL hash 中的 # 类似下面这种 # ：
+
+```plain
+http://www.xxx.com/#/login
+```
+
+之后，在进行页面跳转操作时，hash 值变化并不会导致浏览器页面刷新，只会触发hashchange事件。在下面的代码中，通过对hashchange事件的监听，就可在fn函数内部进行动态地页面切换。
+
+```javascript
+window.addEventListener('hashchange',fn)
+```
+
+### 2.2 history 模式
+
+2014年后HTML5标准发布，浏览器多API：pushState 和 replaceState。可改变 URL 地址，并且浏览器不会向后端发送请求，就能用另外一种方式实现前端路由。
+
+监听popstate事件，可监听到通过pushState修改路由的变化。并且在fn函数中，我们实现了页面的更新
+
+```js
+window.addEventListener('popstate', fn)
+```
+
+## 3 手写vue-router
+
+- src/router目录新建grouter文件夹
+- 并在grouter文件夹内部新建index.js
+
+手写Vuex的基础，在index.js写代码。
+
+先用Router类去管理路由，并用createWebHashHistory返回hash模式相关的监听代码及返回当前URL和监听hashchange事件的方法
+
+```javascript
+import {ref,inject} from 'vue'
+const ROUTER_KEY = '__router__'
+
+function createRouter(options){
+    return new Router(options)
+}
+
+function useRouter(){
+    return inject(ROUTER_KEY)
+}
+function createWebHashHistory(){
+    function bindEvents(fn){
+        window.addEventListener('hashchange',fn)
+    }
+    return {
+        bindEvents,
+        url:window.location.hash.slice(1) || '/'
+    }
+}
+class Router {
+    constructor(options) {
+        this.history = options.history
+        this.routes = options.routes
+        this.current = ref(this.history.url)
+
+        this.history.bindEvents(()=>{
+            this.current.value = window.location.hash.slice(1)
+        })
+    }
+   	// 通过Router类install方法注册Router实例
+    install(app) {
+        app.provide(ROUTER_KEY,this)
+    }
+}
+// 暴露createRouter方法创建Router实例
+// 暴露useRouter方法，获取路由实例
+export {createRouter,createWebHashHistory,useRouter}
+```
+
+回到src/router/index.js：
+
+```javascript
+import {createRouter, createWebHashHistory} from './grouter/index'
+
+const router = createRouter({
+  history: createWebHashHistory(),
+  // 使用routes作为页面参数传递给createRouter函数
+  routes
+})
+```
+
+注册两个内置组件router-view和router-link。在createRouter创建的Router实例上，current返回当前路由地址，并用ref包裹成响应式数据。
+
+router-view组件功能，就是current变化时，去匹配current地址对应组件，然后动态渲染到router-view。
+
+### 实现RouterView组件
+
+src/router/grouter新建RouterView.vue。
+
+```vue
+<template>
+ 		4. 在template内部使用component组件动态渲染
+    <component :is="comp"></component>
+</template>
+<script setup>
+
+import {computed } from 'vue'
+import { useRouter } from '../grouter/index'
+// 1. 先用useRouter获取当前路由的实例
+let router = useRouter()
+
+// 3. 最后通过计算属性返回comp变量
+const comp = computed(()=>{
+  	// 2. 通过当前的路由，即router.current.value值，在用户路由配置route中计算出匹配的组件
+    const route = router.routes.find(
+        (route) => route.path === router.current.value
+    )
+    return route?route.component : null
+})
+</script>
+```
+
+### 实现router-link组件
+
+grouter下新建RouterILink.vue。template依然是渲染一个a标签，只是把a标签的href属性前面加了个一个#， 就实现了hash的修改。
+
+```vue
+<template>
+    <a :href="'#'+props.to">
+        <slot />
+    </a>
+</template>
+
+<script setup>
+import {defineProps} from 'vue'
+let props = defineProps({
+    to:{type:String,required:true}
+})
+
+</script>
+```
+
+然后，回到grouter/index.js中，我们注册router-link和router-view这两个组件, 这样hash模式的迷你vue-router就算实现了。这里我演示了支持hash模式迷你vue-router，那你不妨进一步思考一下，history模式又该如何实现。
+
+```javascript
+import {ref,inject} from 'vue'
+import RouterLink from './RouterLink.vue'
+import RouterView from './RouterView.vue'
+class Router{
+    ....
+    install(app){
+        app.provide(ROUTER_KEY,this)
+        app.component("router-link",RouterLink)
+        app.component("router-view",RouterView)
+    }
+}
+
+```
+
+**实际上，vue-router还需要处理很多额外的任务，比如路由懒加载、路由的正则匹配等等**。在今天了解了vue-router原理之后，等到课程最后一部分剖析vue-router源码的那一讲时，你就可以真正感受到“玩具版”的router和实战开发中的router的区别。
+
+## 4 vue-router实战
+
+ **路由匹配的语法** 上，vue-router支持动态路由。有一用户页面使用User组件，但每个用户的信息不一，需给每个用户配置单独的路由入口，就可按下面代码样式配置路由。
+
+冒号开头的id就是路由的动态部分，会同时匹配/user/dasheng和/user/javaedge， 详见 [官方文档的路由匹配语法部分](https://next.router.vuejs.org/zh/guide/essentials/route-matching-syntax.html)。
+
+```javascript
+const routes = [
+  { path: '/users/:id', component: User },
+]
+```
+
+有些页面，只有管理员才可访问，普通用户访问提示无权限。得用vue-router的 **导航守卫功能** ，即访问路由页面之前进行权限认证，做到页面级控制，只允许某些用户访问。
+
+项目庞大后，如果首屏加载文件太大，就可能影响性能。可用vue-router的 **动态导入功能**，把不常用的路由组件单独打包，当访问到这个路由的时候再进行加载，这也是vue项目常见优化方式。
+
+## 5 总结
+
+回顾前后端开发模式的演变，也即前端项目经历的从最初的嵌入到后端内部发布，再到现在的前后端分离的过程，而这一过程也见证了前端SPA应用的发展。
+
+前端路由实现的两种方式，即通过监听不同的浏览器事件，实现hash模式和history模式。之后，根据这个原理，手写vue-router，通过createRouter创建路由实例，并在app.use函数内部执行router-link和router-view组件的注册，最后在router-view组件内部动态的渲染组件。
+
+### Vue Router 路由实现步骤
+
+**路由配置**：
+
+```js
+import { createRouter, createWebHistory } from 'vue-router'
+
+const routes = [
+  {
+    path: '/login',
+    name: 'Login',
+    component: () => import('@/views/user/login.vue')
+  },
+  {
+    path: '/',
+    name: 'Home',
+    component: () => import('@/views/Home.vue'),
+    meta: { requiresAuth: true } // 需要登录权限
+  }
+]
+
+const router = createRouter({
+  history: createWebHistory(),
+  routes
+})
+```
+
+**路由守卫**：
+
+```js
+router.beforeEach((to, from, next) => {
+  const token = localStorage.getItem('token')
+  
+  if (to.meta.requiresAuth && !token) {
+    // 需要登录但未登录，重定向到登录页
+    next({ 
+      path: '/login',
+      query: { redirect: to.fullPath }
+    })
+  } else {
+    next()
+  }
+})
+```
+
+
+
+1. **登录组件中使用路由**
+
+```js
+<script setup>
+import { useRouter, useRoute } from 'vue-router'
+
+const router = useRouter()
+const route = useRoute()
+
+const login = async () => {
+  try {
+    await doLogin()
+    // 登录成功后跳转
+    const redirect = route.query.redirect || '/'
+    router.push(redirect)
+  } catch (error) {
+    handleError(error)
+  }
+}
+
+const logout = async () => {
+  localStorage.removeItem('token')
+  router.push('/login')
+}
+</script>
+```
+
+1. **主应用挂载路由**
+
+```js
+import { createApp } from 'vue'
+import router from './router'
+import App from './App.vue'
+
+const app = createApp(App)
+app.use(router)
+app.mount('#app')
+```
+
+1. **路由视图渲染**
+
+```js
+<template>
+  <router-view></router-view>
+</template>
+```
+
+路由流程:
+
+1. 配置路由表
+2. 设置路由守卫
+3. 组件中注入路由
+4. 应用挂载路由
+5. 视图渲染组件
+
+使用方式:
+
+- 声明式: `<router-link to="/login">`
+- 编程式: `router.push('/login')`
+
+## FAQ
+
+60行代码实现hash模式的迷你vue-router，支持history模式的迷你vue-router咋实现？
+
+实现支持 **history 模式** 的迷你 Vue Router 的核心是利用 HTML5 提供的 `pushState` 和 `replaceState` API，以及监听 `popstate` 事件来响应浏览器的回退、前进等操作。以下是支持 history 模式的迷你 Vue Router 的实现步骤：
+
+------
+
+### 实现 history 模式的 createWebHistory 方法
+
+在 `src/router/grouter/index.js` 中修改或新增以下代码，用于返回 history 模式相关的监听逻辑：
+
+```javascript
+function createWebHistory() {
+    function bindEvents(fn) {
+        window.addEventListener('popstate', fn);
+    }
+
+    function push(url) {
+        history.pushState(null, '', url); // 修改浏览器地址但不刷新页面
+    }
+
+    return {
+        bindEvents,
+        push,
+        url: window.location.pathname || '/', // 获取当前路径
+    };
+}
+```
+
+------
+
+### 修改 Router 类
+
+扩展 Router 类，支持 history 模式的路由变化处理：
+
+```javascript
+class Router {
+    constructor(options) {
+        this.history = options.history;
+        this.routes = options.routes;
+        this.current = ref(this.history.url);
+
+        this.history.bindEvents(() => {
+            this.current.value = window.location.pathname;
+        });
+    }
+
+    // 编程式导航（例如 router.push('/path')）
+    push(url) {
+        this.history.push(url);
+        this.current.value = url;
+    }
+
+    install(app) {
+        app.provide(ROUTER_KEY, this);
+        app.component('router-link', RouterLink);
+        app.component('router-view', RouterView);
+    }
+}
+```
+
+------
+
+### 修改 RouterLink 组件
+
+支持 `history` 模式的 RouterLink 组件不需要 `#` 前缀，使用编程式导航：
+
+```vue
+<template>
+    <a @click.prevent="navigate">{{ $slots.default() }}</a>
+</template>
+
+<script setup>
+import { defineProps, inject } from 'vue';
+
+const props = defineProps({
+    to: { type: String, required: true },
+});
+
+const router = inject('__router__');
+
+function navigate() {
+    router.push(props.to);
+}
+</script>
+```
+
+------
+
+### 注册 Vue Router
+
+在 `src/router/index.js` 中注册使用 `createWebHistory` 的路由实例：
+
+```javascript
+import { createRouter, createWebHistory } from './grouter/index';
+
+const routes = [
+    { path: '/', component: Home },
+    { path: '/about', component: About },
+];
+
+const router = createRouter({
+    history: createWebHistory(),
+    routes,
+});
+
+export default router;
+```
+
+------
+
+### 配置 Web 服务
+
+要支持 history 模式，需要配置服务器以处理所有的路径。以 Nginx 为例，配置如下：
+
+```nginx
+server {
+    listen 80;
+    server_name yourdomain.com;
+
+    location / {
+        root /path/to/your/app;
+        index index.html;
+        try_files $uri /index.html;
+    }
+}
+```
+
+------
+
+### 扩展内容
+
+对比 `hash` 模式和 `history` 模式的特点：
+
+| 特点           | Hash 模式                   | History 模式              |
+| -------------- | --------------------------- | ------------------------- |
+| URL 格式       | `http://example.com/#/path` | `http://example.com/path` |
+| 浏览器刷新处理 | 不需后端额外支持            | 需服务器配置支持          |
+| SEO            | 不友好                      | 更友好                    |
+| 实现复杂度     | 简单                        | 较复杂                    |
+
+------
+
+**思考扩展**
+ 在实现基础的 `history` 模式后，可以尝试支持以下功能：
+
+1. 动态路由加载（按需加载）。
+2. 路由守卫的实现（`beforeEach` 等）。
+3. 嵌套路由的实现。
+
+通过实现这些功能，能够更全面掌握 Vue Router 的设计原理和核心机制！
\ No newline at end of file
diff --git a/docs/md/vue/table.md b/docs/md/vue/table.md
new file mode 100644
index 000000000..61781f89f
--- /dev/null
+++ b/docs/md/vue/table.md
@@ -0,0 +1,524 @@
+# 22-设计Element UI表单组件居然如此简单！
+
+## 0 前言
+
+上文讲解了Jest框架对组件库测试，TypeScript和Jest都为代码质量和研发效率。之前实现Container和Button组件以渲染功能为主，可根据不同属性渲染不同样式去实现布局和不同格式的按钮。
+
+本文的表单组件，除了要渲染页面组件，还支持很好页面交互，从Element3的表单组件开始。
+
+## 1 表单组件
+
+[Element表单组件](https://e3.shengxinjing.cn/#/component/form) 页面里，可见表单种类的组件类型很多，输入框、单选框和评分组件等都算表单组件系列。
+
+Element3官方演示表单的Template，整体表单页面分三层：
+
+- el-form负责最外层的表单容器
+- el-form-item负责每个输入项的label和校验管理
+- el-input或el-switch负责具体的输入组件
+
+```xml
+<el-form
+  :model="ruleForm"
+  :rules="rules"
+  ref="form"
+  label-width="100px"
+  class="demo-ruleForm"
+>
+  <el-form-item label="活动名称" prop="name">
+    <el-input v-model="ruleForm.name"></el-input>
+  </el-form-item>
+  <el-form-item label="活动区域" prop="region">
+    <el-select v-model="ruleForm.region" placeholder="请选择活动区域">
+      <el-option label="区域一" value="shanghai"></el-option>
+      <el-option label="区域二" value="beijing"></el-option>
+    </el-select>
+  </el-form-item>
+  <el-form-item label="即时配送" prop="delivery">
+    <el-switch v-model="ruleForm.delivery"></el-switch>
+  </el-form-item>
+  <el-form-item label="活动性质" prop="type">
+    <el-checkbox-group v-model="ruleForm.type">
+      <el-checkbox label="美食/餐厅线上活动" name="type"></el-checkbox>
+      <el-checkbox label="地推活动" name="type"></el-checkbox>
+      <el-checkbox label="线下主题活动" name="type"></el-checkbox>
+      <el-checkbox label="单纯品牌曝光" name="type"></el-checkbox>
+    </el-checkbox-group>
+  </el-form-item>
+  <el-form-item label="特殊资源" prop="resource">
+    <el-radio-group v-model="ruleForm.resource">
+      <el-radio label="线上品牌商赞助"></el-radio>
+      <el-radio label="线下场地免费"></el-radio>
+    </el-radio-group>
+  </el-form-item>
+  <el-form-item label="活动形式" prop="desc">
+    <el-input type="textarea" v-model="ruleForm.desc"></el-input>
+  </el-form-item>
+  <el-form-item>
+    <el-button type="primary" @click="submitForm('ruleForm')"
+      >立即创建</el-button
+    >
+    <el-button @click="resetForm('ruleForm')">重置</el-button>
+  </el-form-item>
+</el-form>
+```
+
+把上面代码简化为最简单形式，只留el-input作输入项，可清晰看到表单组件工作的模式：
+
+- el-form组件使用:model提供数据绑定；使用rules提供输入校验规则，规范用户的输入内容
+- el-form-item作为输入项的容器，对输入进行校验，显示错误信息
+
+```xml
+<el-form :model="ruleForm" :rules="rules" ref="form">
+  <el-form-item label="用户名" prop="username">
+    <el-input v-model="ruleForm.username"></el-input>
+    <!-- <el-input :model-value="" @update:model-value=""></el-input> -->
+  </el-form-item>
+  <el-form-item label="密码" prop="passwd">
+    <el-input type="textarea" v-model="ruleForm.passwd"></el-input>
+  </el-form-item>
+  <el-form-item>
+    <el-button type="primary" @click="submitForm()">登录</el-button>
+  </el-form-item>
+</el-form>
+```
+
+## rules和model工作流程
+
+用reactive返回用户输入的数据，username和passwd输入项对应，然后rules使用reactive包裹用户输入项校验的配置。
+
+具体校验规则，主流用async-validator库，详细校验规则访问 [async-validator的官网](https://github.com/yiminghe/async-validator)。而表单Ref上额外新增一个validate方法，执行所有的校验逻辑来显示用户的报错信息，下图即用户输入不符合rules配置后，页面的报错提示效果。
+
+```typescript
+const ruleForm = reactive<UserForm>({
+  username:"",
+  passwd:""
+})
+
+// 1. 定义验证规则
+const rules = reactive({
+  rules: {
+    username: { required: true,min: 1, max: 20, message: '长度在 1 到 20 个字符', trigger: 'blur' },
+    passwd: [{ required: true, message: '密码', trigger: 'blur' }]
+  }
+})
+
+function submitForm() {
+  form.value.validate((valid) => {
+    if (valid) {
+      alert('submit!')
+    } else {
+      console.log('error submit!!')
+      return false
+    }
+  })
+}
+```
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/a30dd03b01d041028a3ae4c088cc7796.png)
+
+## 表单组件实现
+
+进入src/components目录，新建Form.vue去实现el-form组件，该组件是整个表单组件的容器，负责管理每一个el-form-item组件的校验方法，自身还提供一个检查所有输入项的validate方法。
+
+如下代码注册了传递的属性的格式，并注册了validate方法使其对外暴露使用：
+
+```typescript
+interface Props {
+  label?: string
+  prop?: string
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  label: "",
+  prop: ""
+})
+
+const formData = inject(key)
+
+const o: FormItem = {
+  validate,
+}
+
+defineExpose(o)
+```
+
+在 el-form 组件中咋管理el-form-item组件？
+
+新建FormItem.vue文件，该组件加载完毕后去通知el-form组件自己加载完毕，在el-form中就可使用数组管理所有内部的form-item组件。
+
+```typescript
+import { emitter } from "../../emitter"
+const items = ref<FormItem[]>([])
+
+emitter.on("addFormItem", (item) => {
+  items.value.push(item)
+})
+```
+
+然后el-form-item还要负责管理内部的input输入标签，并且从form组件中获得配置的rules，通过rules的逻辑，来判断用户的输入值是否合法。
+
+el-form还要管理当前输入框的label，看看输入状态是否报错，以及报错的信息显示，这是一个承上启下的组件。
+
+```typescript
+onMounted(() => {
+  if (props.prop) {
+    emitter.on("validate", () => {
+      validate()
+    })
+    emitter.emit("addFormItem", o)
+  }
+})
+function validate() {
+  if (formData?.rules === undefined) {
+    return Promise.resolve({ result: true })
+  }
+  const rules = formData.rules[props.prop]
+  const value = formData.model[props.prop]
+  const schema = new Schema({ [props.prop]: rules })
+  return schema.validate({ [props.prop]: value }, (errors) => {
+    if (errors) {
+      error.value = errors[0].message || "校验错误"
+    } else {
+      error.value = ""
+    }
+  })
+}
+
+```
+
+form、form-item和input三组件之间是 **嵌套使用** 关系：
+
+- form提供了所有的数据对象和配置规则
+- input负责具体的输入交互
+- form-item负责中间的数据和规则管理及显示具体的报错信息
+
+这就需要一个强有力的组件通信机制，Vue的
+
+## 组件之间的通信
+
+### 父子组件通信
+
+通过props和emits来通信。父元素通过props把需要的数据传递给子元素，子元素通过emits通知父元素内部的变化，并且还可以通过defineDepose的方式暴露给父元素方法，可以让父元素调用自己的方法。
+
+#### form和input组件咋通信？
+
+这种祖先元素和后代元素，中间可能嵌套很多层关系，Vue提供provide、inject API。
+
+在组件中可用provide函数向所有子组件提供数据，子组件内部通过inject注入使用。provide提供的只是普通数据，未做响应式处理，若子组件内部需响应式数据，需在provide函数内部用ref或reative包裹。
+
+prvide和inject的类型系统，可用Vue的InjectiveKey声明。在form目录下新建type.ts专门管理表单组件用到的相关类型。
+
+如下定义了表单form和表单管理form-item的上下文，并通过InjectionKey管理提供的类型。
+
+```typescript
+import { InjectionKey } from "vue"
+import { Rules, Values } from "async-validator"
+
+export type FormData = {
+  model: Record<string, unknown>
+  rules?: Rules
+}
+
+export type FormItem = {
+  validate: () => Promise<Values>
+}
+
+export type FormType = {
+  validate: (cb: (isValid: boolean) => void) => void
+}
+
+export const key: InjectionKey<FormData> = Symbol("form-data")
+```
+
+而如下代码通过provide向所有子元素提供form组件的上下文。子组件内部通过inject获取，很多组件都是嵌套成对出现。
+
+```typescript
+provide(key, {
+  model: props.model,
+  rules?: props.rules,
+})
+
+# 子组件
+const formData = inject(key)
+```
+
+### input实现逻辑
+
+下面代码，input 的核心逻辑就是对v-model支持。
+
+v-mode是:mode-value="x"和@update:modelValute两个写法简写，组件内部获取对应的属性和modelValue方法即可。
+
+需关注的代码是我们输入完成之后的事件，输入的结果校验是由父组件el-form-item来实现的，只需通过emit对外广播。
+
+```vue
+<template>
+  <div
+    class="el-form-item"
+  >
+    <label
+      v-if="label"
+    >{{ label }}</label>
+    <slot />
+    <p
+      v-if="error"
+      class="error"
+    >
+      {{ error }}
+    </p>
+  </div>
+</template>
+<script lang="ts">
+export default{
+  name:'ElFormItem'
+}
+</script>
+
+<script setup lang="ts">
+import Schema from "async-validator"
+import { onMounted, ref, inject } from "vue"
+import { FormItem, key } from "./type"
+import { emitter } from "../../emitter"
+
+interface Props {
+  label?: string
+  prop?: string
+}
+const props = withDefaults(defineProps<Props>(), { label: "", prop: "" })
+// 错误
+const error = ref("")
+
+const formData = inject(key)
+
+const o: FormItem = {
+  validate,
+}
+
+defineExpose(o)
+
+onMounted(() => {
+  if (props.prop) {
+    emitter.on("validate", () => {
+      validate()
+    })
+    emitter.emit("addFormItem", o)
+  }
+})
+
+function validate() {
+  if (formData?.rules === undefined) {
+    return Promise.resolve({ result: true })
+  }
+  const rules = formData.rules[props.prop]
+  const value = formData.model[props.prop]
+  const schema = new Schema({ [props.prop]: rules })
+  return schema.validate({ [props.prop]: value }, (errors) => {
+    if (errors) {
+      error.value = errors[0].message || "校验错误"
+    } else {
+      error.value = ""
+    }
+  })
+}
+</script>
+
+<style lang="scss">
+@import '../styles/mixin';
+@include b(form-item) {
+  margin-bottom: 22px;
+  label{
+    line-height:1.2;
+    margin-bottom:5px;
+    display: inline-block;
+  }
+  & .el-form-item {
+    margin-bottom: 0;
+  }
+}
+.error{
+  color:red;
+}
+</style>
+```
+
+点击按钮时，在最外层的form标签内部会对所有的输入项进行校验。由于我们管理着所有的form-item，只需要遍历所有的form-item，依次执行即可。
+
+下面的代码就是表单注册的validate方法，我们遍历全部的表单输入项，调用表单输入项的validate方法，有任何一个输入项有报错信息，整体的校验就会是失败状态。
+
+```typescript
+function validate(cb: (isValid: boolean) => void) {
+  const tasks = items.value.map((item) => item.validate())
+  Promise.all(tasks)
+    .then(() => { cb(true) })
+    .catch(() => { cb(false) })
+}
+```
+
+上面代码实际执行的是每个表单输入项内部的validate方法，这里我们使用的就是async-validate的校验函数。在validate函数内部，我们会获取表单所有的ruls，并且过滤出当前输入项匹配的输入校验规则，然后通过AsyncValidator对输入项进行校验，把所有的校验结果放在model对象中。如果errors\[0\].message非空，就说明校验失败，需要显示对应的错误消息，页面输入框显示红色状态。
+
+```javascript
+import Schema from "async-validator"
+
+function validate() {
+  if (formData?.rules === undefined) {
+    return Promise.resolve({ result: true })
+  }
+  const rules = formData.rules[props.prop]
+  const value = formData.model[props.prop]
+  const schema = new Schema({ [props.prop]: rules })
+  return schema.validate({ [props.prop]: value }, (errors) => {
+    if (errors) {
+      error.value = errors[0].message || "校验错误"
+    } else {
+      error.value = ""
+    }
+  })
+}
+```
+
+## 总结
+
+本文设计实现了复杂的组件类型——表单组件。在组件库中作用，就是收集和获取用户的输入值，并提供用户的输入校验，如输入长度、邮箱格式等，符合校验规则后，就可获取用户输入内容，提交给后端。
+
+要实现三类组件：
+
+- el-form提供表单的容器组件，负责全局的输入对象model和校验规则rules的配置，在用户点击提交时，可执行全部输入项的校验规则
+
+- input类组件，输入内容的输入框、下拉框、滑块等都属这类。主要负责显示对应的交互组件，并且监听所有的输入项，用户在交互的同时通知执行校验
+
+- 介于form和input中间的form-item组件，负责每一个具体输入的管理，从form组件中获取校验规则，从input中获取用户输入的内容，通过async-validator校验输入是否合法后显示对应的输入状态，并且还能把校验方法提供给form组件，form可很方便地管理所有form-item。
+
+组件设计需考虑：
+
+- 内部交互逻辑
+- 对子组件提供什么数据
+- 对父组件提供什么方法
+- 需不需要通过provide或inject来进行跨组件通信等
+
+### 表单验证流程
+
+**1. 定义验证规则**
+
+```js
+const rules = reactive({
+  username: [
+    { required: true, message: '请输入用户名', trigger: 'blur' },
+    { min: 3, max: 20, message: '长度在 3 到 20 个字符', trigger: 'blur' },
+    { validator: validateUsername, trigger: 'blur' }
+  ],
+  password: [
+    { required: true, message: '请输入密码', trigger: 'blur' },
+    { min: 6, max: 20, message: '长度在 6 到 20 个字符', trigger: 'blur' }
+  ]
+})
+```
+
+
+
+**2. 绑定规则到表单**
+
+```js
+<el-form 
+  :model="loginForm"    <!-- 绑定数据模型 -->
+  :rules="rules"        <!-- 绑定验证规则 -->
+  ref="loginFormRef"    <!-- 表单引用 -->
+>
+```
+
+
+
+**3. 自定义验证方法**
+
+```js
+async function validateUsername(rule, value, callback) {
+  if (value === '') {
+    callback(new Error('请输入用户名'))
+  } else {
+    callback() // 验证通过
+  }
+}
+```
+
+
+
+**4. 触发验证**
+
+```js
+const login = async () => {
+  if (!loginFormRef.value) return
+  
+  try {
+    // 触发表单验证
+    const valid = await loginFormRef.value.validate()
+    if (valid) {
+      // 验证通过,执行登录
+      await doLogin()
+    }
+  } catch (error) {
+    // 验证失败处理
+    handleError(error)
+  }
+}
+```
+
+**验证规则说明:**
+
+- `required`: 必填项
+- `min/max`: 长度限制
+- `trigger`: 触发方式(blur/change)
+- `validator`: 自定义验证方法
+- `message`: 错误提示信息
+
+**验证流程:**
+
+1. 用户输入触发验证
+2. 执行验证规则检查
+3. 显示错误提示(如果有)
+4. 验证通过则提交表单
+
+类比 Java:
+
+- 类似 `@Valid` 注解验证
+- 类似 JSR-303 验证规则
+- 类似 BindingResult 结果处理
+
+## FAQ
+
+Q：表单组件设计上能否通过Vue 2流行的event-bus实现？
+
+A：Vue 2 时代，`event-bus`（事件总线）是一个较为流行的解决组件通信的方式。通过在全局创建一个 Vue 实例作为事件总线，子组件可以通过 `$emit` 触发事件，父组件通过 `$on` 监听事件，从而实现跨组件的通信。
+
+对于本例中的表单组件，理论上可以通过 `event-bus` 来实现组件之间的通信，但从现代 Vue 的架构和最佳实践来看，这种方式已经不推荐，主要原因包括以下几点：
+
+------
+
+### **1. 可维护性差**
+
+- **问题**：`event-bus` 是一种松散的事件驱动通信方式，依赖于事件的触发和监听，但事件本身没有强类型约束或明确的调用链，难以调试和维护。
+- **改进**：Vue 3 的 `provide/inject` 或者 Vuex/Pinia 等状态管理工具，可以更清晰地定义数据流和逻辑职责。
+
+------
+
+### **2. 性能问题**
+
+- **问题**：使用 `event-bus` 可能导致事件在全局广播，尤其在大型项目中，大量事件会增加性能开销。
+- **改进**：本例中，通过 `provide/inject` 实现的数据共享仅限于组件树中的父子组件或兄弟组件之间，数据传递范围清晰且高效。
+
+------
+
+### **3. 复杂性控制**
+
+- **问题**：`event-bus` 的事件管理随着项目复杂度增加会导致难以跟踪。例如，在表单校验中，需管理每个 `form-item` 的校验状态并与 `form` 同步，如果使用 `event-bus`，需要手动处理事件的订阅与销毁。
+- **改进**：本例中，使用 Vue 的生命周期钩子（如 `onMounted` 和 `onUnmounted`）配合 `provide/inject` 机制，自动管理组件的注册和销毁逻辑，代码更加直观。
+
+------
+
+### **4. 与现代 Vue 设计理念不符**
+
+- **问题**：`event-bus` 属于 Vue 2 时代的过渡方案，而 Vue 3 的 Composition API 提供了更优雅的通信机制（如响应式 `reactive`、`ref` 数据，以及组合函数）。
+- **改进**：在本例中，`provide/inject` 结合响应式数据实现了父组件与子组件的通信，使代码风格更加符合现代 Vue 的声明式设计思想。
+
+------
+
+### **总结**
+
+虽然 `event-bus` 可以实现类似的功能，但它在代码结构、性能和可维护性上都存在明显的缺陷，已经逐渐被 Vue 3 的现代通信机制所取代。对于表单组件这种较为复杂的场景，推荐使用 `provide/inject` 结合响应式数据的方式来管理组件通信，以提高代码的健壮性和可扩展性。
\ No newline at end of file
diff --git a/docs/md/vue/vue2-to-vue3.md b/docs/md/vue/vue2-to-vue3.md
new file mode 100644
index 000000000..2625f3220
--- /dev/null
+++ b/docs/md/vue/vue2-to-vue3.md
@@ -0,0 +1,171 @@
+# 04-可以无脑将Vue2项目升级到Vue3吗？
+
+Vue 3 如此优秀，是不是应该赶紧把项目都升级到Vue 3？但不是所有项目都适合升级。
+
+## 1 应该从2升到3吗？
+
+如开启一个新项目，直接使用Vue 3最佳选择。
+
+以前独立使用Vue 2 开发应用，不管咋组织代码，无法避免在data、template、methods中上下反复横跳，这种弊端在项目规模上来后更明显。
+
+由于vue-cli基于Webpack开发，当项目规模上来后，每执行一下，调试环境就要1min，大项目之痛！
+
+Vue 3 Composition API带来代码组织方式更利封装代码，维护不再上下横跳。Vite带来更好调试体验。
+
+Vue 3 正式版已发布三年，无论辅助工具，还是周边库都已完善，胜任各种大型项目开发。越来越多公司尝试和体验Vue 3。新项目可直接拥抱Vue 3。
+
+对于Vue 2，官方不再维护，问题和需求，官方不承诺修复和提供解答了。
+
+## 2 兼容问题
+
+Vue 3由于新的响应式系统用Proxy，存在兼容性问题。即如你的应用被要求兼容IE11，就选Vue 2。Vue团队已放弃 Vue 3 对IE11支持。一开始官方是有计划 Vue 3 支持IE11，但由于复杂度和优先级的问题，计划就搁置。
+
+如今浏览器和JavaScript本身已有巨大发展。大部分的前端项目都在直接使用现代语言特性，微软本身也废弃IE了。所以 Vue 3 全面拥抱未来，原来准备投入到Vue 3 上支持IE11的精力转投给Vue 2.7。
+
+## 3 Vue 2.7 有啥？
+
+Vue 2.7 会移植Vue 3 的一些新特性，让你在Vue 2 的生态中，也能享受Vue 3部分新特性。在Vue 3 发布之前，Vue 2 项目中就可以基于@vue/composition-api插件，使用Composition API语法，Vue 2 会直接内置这个插件，在Vue 2 中默认也可以用Compositon来组合代码。
+
+<script setup>语法也在Vue 2得到支持。如想用更精简的方式组织代码，也没问题，因为Vite也支持Vue 2。
+
+
+综上，要不要使用Vue 3，要“因地制宜”。
+
+![image-20230906221203933](https://p.ipic.vip/eeturu.png)
+
+## 4 Vue 3 不兼容的写法
+
+兼容性变更，官方有 [迁移指南](https://v3-migration.vuejs.org/)。
+
+主要针对有Vue 2开发经验，希望更快适应Vue 3的。全面实战Vue 3 之前，不必完整阅读官方指南，因为Vue 3大部分 API 兼容Vue 2 。
+
+Vue 2 使用new Vue()新建应用，有一些全局配置直接挂在 Vue，如：
+
+- Vue.use使用插件
+- Vue.component注册全局组件
+
+```js
+// 注册一个el-counter组件，全局可用
+Vue.component('el-counter', {
+  data(){
+    return {count: 1}
+  },
+  // 直接渲染一个按钮，点击按钮时，按钮内的数字会累加
+  template: '<button @click="count++">Clicked {{ count }} times.</button>'
+})
+
+let VueRouter = require('vue-router')
+Vue.use(VueRouter)
+```
+
+然后要注册路由插件，即Vue 2使用vue-router。形式直接，但由于全局Vue只有一个，所以当我们在一个页面的多个应用中独立使用Vue就难了。
+
+### 案例
+
+
+
+```js
+// 在Vue上先注册一个组件el-counter
+Vue.component('el-counter',...)
+// 创建两个Vue的实例
+new Vue({el:'#app1'})
+new Vue({el:'#app2'})
+```
+
+这两个实例都自动都拥有el-couter这组件，但易混淆。为解决这问题，Vue 3 引入一个新API createApp，即新增了App的概念。
+
+全局的组件、插件都独立地注册在这App内部，解决了俩实例易混淆的问题。
+
+### 使用 createApp
+
+```js
+const { createApp } = Vue
+const app = createApp({})
+app.component(...)
+app.use(...)
+app.mount('#app1')
+
+const app2 = createApp({})
+app2.mount('#app2')
+```
+
+createApp移除了很多常见写法，如在createApp中，就不支持filter、$on、$off、$set、$delete等API。当然都能实现类似功能。
+
+Vue 3的v-model 用法也改了。讲到组件化需深度使用v-model时细讲。
+
+Vue 3 还有很多小细节的更新，如slot和slot-scope两者实现合并，而directive注册指令的API等也有变化。
+
+## 5 Vue3生态现状
+
+Vue生态现所有官方库工具都全面支持Vue3，但仍有生态库处候选或刚发布状态。 所以，升级Vue3过程，除了Vue3本身语法变化，生态也要注意选择。有些周边生态库可能还存在不稳定情况，时刻关注GitHub。
+
+Vue-cli4已提供内置选项，当然可选择它支持的 Vue 2。如你对 Vite 不放心，Vue-cli4 也全面支持 Vue 3。
+
+vue-router是复杂项目必不可少的路由库，包含写法变化，如从 new Router变 createRouter；全面拥抱 Composition API 风格，提供方法：
+
+- useRouter
+- useRoute
+
+Vuex 4.0 也支持 Vue3。Vue 官方成员还发布 Pinia，Pinia API 接近 Vuex5 设计，且对 Composition API 特别友好，更优雅。
+
+其他生态如 Nuxt、组件库Ant-design-vue、Element都有 Vue3 版。
+
+## 6 使用自动化升级工具进行Vue的升级
+
+Vue 2 升级到 Vue 3 后，对语法的改变之处，挨个替换写法即可。 **但对于复杂项目，我们需要借助几个自动化工具来帮我们过渡。**
+
+Vue 3项目有个 @vue/compat 库，这是一个 Vue 3 的构建版本，提供兼容 Vue 2 的行为。这版本默认运行在 Vue 2 下，它的大部分 API 和 Vue 2 保持一致。当使用那些在 Vue 3 发生变化或废弃的特性时，这版本会警告，从而避免兼容性问题，帮你很好迁移项目。通过升级的提示信息，@vue/compat还很好帮助你学习版本差异。
+
+
+
+先把项目依赖的 Vue 版本换成3并引入@vue/compat 。
+
+```diff
+"dependencies": {
+-  "vue": "^2.6.12",
++  "vue": "^3.2.19",
++  "@vue/compat": "^3.2.19"
+   ...
+},
+"devDependencies": {
+-  "vue-template-compiler": "^2.6.12"
++  "@vue/compiler-sfc": "^3.2.19"
+}
+
+```
+
+给 vue 设置别名@vue/compat，也就是以 compat 作为入口，代码如下：
+
+```js
+// vue.config.js
+module.exports = {
+  chainWebpack: config => {
+    config.resolve.alias.set('vue', '@vue/compat')
+    ......
+  }
+}
+```
+
+这时就会在控制台看到很多警告及优化建议。
+
+在 @vue/compat 提供很多建议后，自己还要慢慢修改。但另一个角度看，“偷懒”是优秀程序员的标志，社区就有能够做自动化替换的工具，好用的就是“阿里妈妈”的 gogocode， [官方文档](https://gogocode.io/zh/docs/vue/vue2-to-vue3) 。
+
+### 自动化替换工具的原理
+
+和 Vue 的 Compiler 优化的原理一样，利用编译原理做代码替换。
+
+如下图利用 babel 分析左边 Vue 2 的源码，解析成 AST，然后根据Vue 3 的写法对 AST 进行转换，最后生成新的 Vue 3 代码：
+
+![image-20230906223444275](https://p.ipic.vip/sv36o7.png)
+
+对替换过程的中间编译成的 AST，可理解为用 JavaScript 的对象去描述这段代码，这和虚拟 DOM 的理念有一些相似，我们基于这个对象去做优化，最终映射生成新的Vue 3代码。
+
+## 7 总结
+
+何时该升级 Vue 3，什么时候该继续使用 Vue 2的兼容版本。
+
+现在，Vue 3官方生态整体稳定，新项目完全可直接Vue 3。那些需长期维护的项目，也很有必要升级。Vue 2很快停止更新，如项目需兼容 IE11，就继续用 Vue 2.7。这样保持好项目兼容性前提下，还可体验到 Composition API 便利。
+
+升级Vue过程中，可利用官方和社区工具，帮助高效升级。可使用compat给出提醒，项目中设置@vue/compat作为 vue 的别名，这样内部就会把所有和 Vue 2 的语法相关的升级信息提示出来，逐个替换即可或直接使用 gogocode 进行自动化批量替换。
+
+全面拥抱 Vue 3 也是离开舒适圈的挑战，带来不只新框架体验，也可能更好潜力与待遇。
\ No newline at end of file

From f5ed55c5bb86883a9eab53e32cb2a38742c2ec41 Mon Sep 17 00:00:00 2001
From: JavaEdge <sss2855845850@gmail.com>
Date: Tue, 4 Feb 2025 00:03:02 +0800
Subject: [PATCH 03/20] =?UTF-8?q?docs:=E6=9B=B4=E6=96=B0=E4=B8=93=E6=A0=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .vscode/.server-controller-port.log           |   4 +-
 docs/.vuepress/config.js                      |  37 +++-
 ...ble-more-flexible-translation-workflows.md | 125 +++++++++++
 docs/md/AI/llm/what-is-llmops.md              | 118 +++++++++++
 .../md/career/Java-reading-list.md            |   2 +-
 .../efficient-professional-reading-list.md    |  47 +++++
 docs/md/career/life-beyond-career-growth.md   |  81 ++++++++
 docs/md/career/moat-of-rd.md                  | 194 ++++++++++++++++++
 .../md/career/must-have-soft-skills-for-rd.md | 176 ++++++++++++++++
 docs/md/career/no-tech-no-future-for-rd.md    | 165 +++++++++++++++
 .../md/career/performance-review-guideline.md | 193 +++++++++++++++++
 ...35\345\262\201\345\215\261\346\234\272.md" |   0
 ...25\346\230\257\345\225\245\357\274\237.md" | 156 ++++++++++++++
 13 files changed, 1292 insertions(+), 6 deletions(-)
 create mode 100644 docs/md/AI/llm/integrate-dify-and-aws-services-to-enable-more-flexible-translation-workflows.md
 create mode 100644 docs/md/AI/llm/what-is-llmops.md
 rename "docs/md/career/01-Java\345\267\245\347\250\213\345\270\210\345\277\205\350\257\273\344\271\246\345\215\225.md" => docs/md/career/Java-reading-list.md (99%)
 create mode 100644 docs/md/career/efficient-professional-reading-list.md
 create mode 100644 docs/md/career/life-beyond-career-growth.md
 create mode 100644 docs/md/career/moat-of-rd.md
 create mode 100644 docs/md/career/must-have-soft-skills-for-rd.md
 create mode 100644 docs/md/career/no-tech-no-future-for-rd.md
 create mode 100644 docs/md/career/performance-review-guideline.md
 rename "docs/md/career/02-\344\270\272\344\273\200\344\271\210\344\270\255\345\233\275\347\232\204\347\250\213\345\272\217\345\221\230\346\234\21135\345\262\201\345\215\261\346\234\272.md" => "docs/md/career/\344\270\272\344\273\200\344\271\210\344\270\255\345\233\275\347\232\204\347\250\213\345\272\217\345\221\230\346\234\21135\345\262\201\345\215\261\346\234\272.md" (100%)
 create mode 100644 "docs/md/career/\347\240\224\345\217\221\347\232\204\347\253\213\350\266\263\344\271\213\346\234\254\345\210\260\345\272\225\346\230\257\345\225\245\357\274\237.md"

diff --git a/.vscode/.server-controller-port.log b/.vscode/.server-controller-port.log
index 75136fd16..5f690f808 100644
--- a/.vscode/.server-controller-port.log
+++ b/.vscode/.server-controller-port.log
@@ -1,5 +1,5 @@
 {
-  "port": 9149,
-  "time": 1737701531002,
+  "port": 9146,
+  "time": 1738581319562,
   "version": "0.0.3"
 }
\ No newline at end of file
diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index c690b8fbe..3f3a0fe9d 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -809,7 +809,7 @@ module.exports = {
                         text: '职业',
                         items: [{
                                 text: '职业规划',
-                                link: '/md/career/01-Java工程师必读书单.md'
+                                link: '/md/career/为什么中国的程序员有35岁危机'
                             },
                             {
                                 text: '晋升',
@@ -821,6 +821,11 @@ module.exports = {
                                 link: '/md/career/经常被压缩开发时间，延期还要背锅，如何破局？'
                             },
 
+                            {
+                                text: '书单',
+                                link: '/md/career/Java-reading-list'
+                            },
+
                             {
                                 text: '00-如何学习项目管理专栏',
                                 link: '/md/mgr/00-如何学习项目管理专栏.md'
@@ -1959,8 +1964,7 @@ module.exports = {
                             collapsable: false,
                             sidebarDepth: 0,
                             children: [
-                                "01-Java工程师必读书单",
-                                "02-为什么中国的程序员有35岁危机",
+                                "为什么中国的程序员有35岁危机",
                                 "03-新人程序员入行忠告",
                                 "04-外企也半夜发布上线吗？",
                                 "05-中外程序员到底有啥区别？",
@@ -1975,6 +1979,11 @@ module.exports = {
                                 "workplace-jargon",
                                 "workplace-rule",
                                 "big-company-work-style",
+                                "研发的立足之本到底是啥？",
+                                "must-have-soft-skills-for-rd",
+                                "no-tech-no-future-for-rd",
+                                "moat-of-rd",
+                                "life-beyond-career-growth",
                             ]
                         },
 
@@ -1985,6 +1994,7 @@ module.exports = {
                             children: [
                                 "p6-promotion-guide",
                                 "why-hard-work-didnt-get-you-promoted-the-overlooked-truth",
+                                "performance-review-guideline",
                             ]
                         },
 
@@ -1997,6 +2007,17 @@ module.exports = {
                             ]
                         },
 
+
+                        {
+                            title: "书单",
+                            collapsable: false,
+                            sidebarDepth: 0,
+                            children: [
+                                "Java-reading-list",
+                                "efficient-professional-reading-list",
+                            ]
+                        },
+
                     ],
 
                     "/md/vue/": [{
@@ -2134,6 +2155,16 @@ module.exports = {
                                 "02-常用Prompt",
                             ]
                         },
+                        
+                        {
+                            title: "Dify",
+                            collapsable: false,
+                            sidebarDepth: 0,
+                            children: [
+                                "what-is-llmops",
+                                "integrate-dify-and-aws-services-to-enable-more-flexible-translation-workflows",
+                            ]
+                        },
                     ],
 
                     "/md/AI/ml/": [{
diff --git a/docs/md/AI/llm/integrate-dify-and-aws-services-to-enable-more-flexible-translation-workflows.md b/docs/md/AI/llm/integrate-dify-and-aws-services-to-enable-more-flexible-translation-workflows.md
new file mode 100644
index 000000000..8847e3a83
--- /dev/null
+++ b/docs/md/AI/llm/integrate-dify-and-aws-services-to-enable-more-flexible-translation-workflows.md
@@ -0,0 +1,125 @@
+# 集成 Dify 和 AWS Service 实现更具灵活性的翻译工作流
+## 0 前言 
+
+基于Dify现有能力，已能对不少业务场景提供帮助，但对一些特定诉求，还要借助其扩展机制，本文利用翻译场景举例详细说明。
+
+## 1 翻译场景复杂性分析
+
+翻译是从简单到复杂各级都存在的场景，比较简单的翻译可能一句简单 Prompt，但对复杂、效果要求较高翻译场景，可能需要一些复杂 LLM 编排，如吴恩达开源的 Translation Agent 工作。
+
+从效果层面看，有些翻译要求比较高的意译水平，比如广告词的翻译，需要理解原文的深层含义，而非逐字翻译。类似场景实践，采用多轮调用 COT 的技巧，还需不断反思修正，得最优答案。这种场景往往要求灵活 LLM 编排能力。这种场景是 Dify 擅长。
+
+也有另外一些翻译场景，要求非常高的场景化和专业化，比如游戏论坛的评论翻译，需要通过 Prompt 给出目标受众期待的语气和翻译风格，同时还需要专词映射机制，来支持一些专业的游戏词汇（角色/道具/活动）或者黑话。
+
+参考栏中的一文中介绍了专词翻译的方案，其中借助分词器进行专词提取和 KV 数据库存贮映射关系，方案中包含的 DynamoDB & Glue 服务，其服务能力是目前 Dify 所不具备的，单纯依靠 Dify 无法支持这种翻译诉求。
+
+### 方案的问题
+
+它是基于代码实现，未提供友好的界面来调整 Prompt，对于复杂的 LLM 编排仅仅只能通过修改代码实现，没有足够的灵活性去应对各种各样的具体场景，也缺乏通用能力的支持，比如想要实现 stream response 则比较麻烦，而 Dify 的 API 发布能力则可以很轻松的弥补这一点，同时还可以利用 Dify API 监控等一系列通用能力。
+
+为结合两者的优势，本文尝试了对两者进行集成实践。
+
+## 2 Dify与外部工具集成
+
+Dify社区版文档中，目前主要提供 2 种集成：
+
+- HTTP 节点：允许通过 Restful API 与外部接口进行交互。
+- 自定义工具：通过自定义工具添加一种新的节点类型，可以编排在工作流中。
+
+AWS的能力从原则上可与 Dify 通过这两种方式进行集成，但依然存在一些
+
+### 2.1 问题
+
+#### 2.1.1 HTTP 方式存在鉴权问题
+
+鉴权步骤较麻烦，且需要用到 AK/SK，可能受安全方面限制。
+
+可通过自定义工具来对接 AWS 的能力，自定义工具本质上是运行在 Dify docker 运行的实例中的，无需 AK/SK 的配置，直接通过实例上 AWS IAM Role 来获得执行权限。
+
+#### 2.1.2 AWS的一些能力
+
+并非直接可访问的 SAAS API 服务，需预先私有化部署，如一直没人用或使用过少，可能存在闲置率率过高问题。其它类似案例设计方案时，主要基于 serverless 服务搭建，大大降低空置问题，其中 Lambda 的接口设计时，也提供多种接口，除了直接翻译，还可以支持获取专词映射和切词结果。
+
+### 2.2 集成过程
+
+#### 2.2.1 部署 Dify
+
+采用社区版 – Docker Compose 方式进行部署。
+
+#### 2.2.2 编辑自定义工具
+
+参考Dify文档定义工具，一个工具一般对应两个文件：
+
+##### ① python 文件
+
+为对接 AWS 服务的连接器，一般利用 boto3 来访问 AWS 服务，Dify 的 Docker 环境中已集成 boto3 的依赖。参考实现：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/70978988bea0a796b69ebe11a695c845.png)
+
+##### ② yaml 文件
+
+为该工具的输入输出的界面定义文件，参考代码，注意 name 字段需要和真实文件名保持一致，否则加载时会出现问题。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/e2504b5de83fe524aab040af28ac0999.png)
+
+#### 2.2.3 构建自定义 Docker 镜像
+
+参考下面伪代码：
+
+```bash
+# 按照下面步骤把工具对应的代码文件置入指定位置
+cp -r ${tool_folder} ~/dify/api/core/tools/provider/builtin/
+
+# 构建新镜像
+cd ~/dify/api
+sudo docker build -t dify-api:${tag} .
+
+# 指定启动镜像
+cd ../dify/docker/
+vim docker-compose.yaml
+# 修改image
+# image: langgenius/dify-api:0.6.11 => image: langgenius/dify-api:${tag}
+
+# 停止docker （也可以只更新修改过镜像的Container）
+sudo docker compose down
+
+# 启动docker
+sudo docker compose up -d
+```
+
+#### 2.2.4 添加自定义工具到工作流
+
+检查自定义工具是否安装成功。
+
+若安装成功，可在 dify 首页的 Tools Tab 中看到新增的工具集：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/3c8c664942e76c359bc0fe66fac50e59.png)
+
+工作流编排的时候，右键添加节点，可在 Tools/Built-in 中看到添加的自定义工具：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/3d4cbb271630c0a977637503dc924bb7.png)
+
+#### 2.2.5 调试自定义 Tool
+
+当工具没有正确加载不可见时。参考下面伪代码，查看服务的日志，根据日志来修改代码：
+
+```bash
+# 查看dify-api所在的container id
+sudo docker ps -a
+
+# 查看dify-api 这个container的日志
+sudo docker logs <container_id_or_name>
+```
+
+## 3 总结
+
+至此，即可基于Dify强大功能，构建高效、智能翻译服务，满足各种复杂可定制化的翻译需求。通过实践此集成：
+
+- 简化开发过程
+- 充分发挥Dify在 LLMOps 优势，为用户提供高质量的翻译体验
+- 大大扩展了 Dify 的能力边界，让它具备了专词召回的能力
+- 对其他复杂AIGC相关场景提供参考
+
+参考：
+
+- https://aws.amazon.com/cn/blogs/china/implementing-llm-translation-with-word-mapping-capabilities-based-on-aws-services/
\ No newline at end of file
diff --git a/docs/md/AI/llm/what-is-llmops.md b/docs/md/AI/llm/what-is-llmops.md
new file mode 100644
index 000000000..6f46a1c39
--- /dev/null
+++ b/docs/md/AI/llm/what-is-llmops.md
@@ -0,0 +1,118 @@
+# 什么是 LLMOps？
+
+## 0 前言
+
+LLMOps（Large Language Model Operations），管理和运维大语言模型 (LLM) 所涉及的实践和流程，涵盖了大型语言模型（如GPT系列）开发、部署、维护和优化的一整套实践和流程。
+
+## 1 目标
+
+确保高效、可扩展和安全地使用这些强大的 AI 模型来构建和运行实际应用程序。它涉及到模型训练、部署、监控、更新、安全性和合规性等方面。
+
+LLMOps（即大语言模型运维）是指。LLM 是一种基于大型文本和代码数据集训练的人工智能 (AI) 模型，能够执行各种与语言相关的任务，例如文本生成、翻译和问答。
+
+## 2 LLMOps能做啥？
+
+LLMOps 涉及一系列全面的活动，包括：
+
+- **模型部署和维护**：在云平台或本地基础设施上部署和管理 LLM
+- **数据管理**：挑选和准备训练数据，以及监控和维护数据质量
+- **模型训练和微调**：训练和优化 LLM 以提升其在特定任务上的表现
+- **监控和评估**：跟踪 LLM 性能、找出错误并优化模型
+- **安全与合规性**：确保 LLM 运维的安全性和法规遵从性
+
+### LLMOps V.S MLOps
+
+LLMOps 是 MLOps（机器学习运维）的一个专业子集，主要侧重于管理 LLM 时遇到的挑战和要求。虽然 MLOps 涵盖管理机器学习模型的一般原则和实践，但 LLMOps 处理 LLM 的独特特征，例如大小较大、训练要求复杂和计算需求高。
+
+## 3 LLMOps 如何运作？
+
+LLMOps 涉及许多不同的步骤，包括：
+
+**数据收集和准备**：LLM 需要大量数据才能进行训练。这些数据必须以适合训练模型的方式进行收集和准备。
+
+**模型开发**：使用各种技术开发 LLM，包括非监督式学习、监督式学习和强化学习。
+
+**模型部署**：LLM 开发完成后，必须部署到生产环境。这涉及设置必要的基础设施，以及将模型配置为在特定平台上运行。
+
+**模型管理**：LLM 需要持续管理，以确保其按预期运行。这包括监控模型的性能、根据需要重新训练模型，以及确保模型的安全性。
+
+## 4 优势
+
+LLMOps为希望有效管理和部署 LLM（大语言模型）的组织提供了诸多好处。这些好处包括：
+
+### 性能
+
+LLMOps 工具和技术通过找出并解决瓶颈、微调模型参数以及实现高效的部署策略，可帮助组织优化其 LLM 的性能。这可以提高准确率、缩短回答时间并改善整体用户体验。
+
+### 可伸缩性
+
+LLMOps 提供了一个可伸缩且灵活的框架来管理 LLM，使组织能够轻松适应不断变化的需求和要求。
+
+### 降低风险
+
+LLMOps 可帮助组织降低与部署和运维 LLM 相关的风险。通过实施强大的监控系统、制定灾难恢复计划并进行定期安全审核，LLMOps 可降低服务中断、数据泄露和其他中断的可能性。这种主动式方法可最大限度地降低潜在风险的影响，并确保 LLM 的持续可用性和可靠性。
+
+### 提升效率
+
+LLMOps 可简化 LLM 的整个生命周期，从数据准备和模型训练到部署和监控。自动化工具和标准化流程可减少手动任务、优化资源利用率并最大限度地缩短模型开发和部署所需的时间，从而提高效率。
+
+## 5最佳实践
+
+LLMOps（大语言模型运维）最佳实践是一系列准则和建议，可帮助组织高效地管理和部署 LLM（大语言模型）。这些最佳实践涵盖 LLMOps 生命周期的各个方面，包括数据管理、模型训练、部署和监控。
+
+### 5.1 数据管理
+
+- **使用高质量数据**：LLM 需要大量高质量的数据才能有效训练。组织应确保用于训练的数据干净、准确，并且与预期应用场景相关。
+- **高效管理数据**：LLM 可以在训练和推理期间生成大量数据。组织应实施高效的数据管理策略（例如数据压缩和数据分区），以优化存储和检索。
+- **建立数据治理机制**：应制定清晰的数据治理政策和流程，以确保在整个 LLMOps 生命周期中，以安全且负责任的方式使用数据。
+
+### 5.2 模型训练
+
+- **选择合适的训练算法**：不同的训练算法适用于不同类型的 LLM 和任务。组织应仔细评估可用的训练算法，并选择最符合其具体要求的算法。
+- **优化训练参数**：超参数调优对于优化 LLM 性能非常重要。尝试不同的训练参数（例如学习速率和批次大小），以找到模型的最佳设置。
+- **监控训练进度**：定期监控训练进度对于发现潜在问题并进行必要的调整至关重要。组织应实现指标和信息中心来跟踪关键训练指标，例如损失和准确率。
+
+### 5.3 部署
+
+- **选择合适的部署策略**：LLM 可以通过多种方式进行部署，例如基于云的服务、本地基础设施或边缘设备。请仔细考虑 LLM 的具体要求，并选择最符合其需求的部署策略。
+- **优化部署性能**：部署后，应监控并优化 LLM，以提升性能。这可能涉及扩缩资源、调整模型参数或实现缓存机制以缩短回答时间。
+- **确保安全性**：应实施强有力的安全措施来保护 LLM 及其处理的数据。包括访问权限控制、数据加密和定期安全审核。
+
+### 5.4 监控
+
+- **制定监控指标**：应制定关键绩效指标 (KPI) 来监控 LLM 的健康状况和性能。这些指标可能包括准确率、延迟时间和资源利用率。
+- **实施实时监控**：应实施实时监控系统，以检测和应对运维期间可能出现的任何问题或异常情况。
+- **分析监测数据**：应定期分析监测数据，以发现趋势、模式和潜在的改进方面。这项分析有助于优化 LLMOps 流程，并确保持续交付高质量的 LLM。
+
+## 6 用 Dify 前后开发 AI 应用差异
+
+
+
+| 步骤               | 未使用 LLMOps 平台                            | 使用 Dify LLMOps 平台                              | 时间差异 |
+| ------------------ | --------------------------------------------- | -------------------------------------------------- | -------- |
+| 开发应用前&后端    | 集成和封装 LLM 能力，花费较多时间开发前端应用 | 直接使用 Dify 的后端服务，可基于 WebApp 脚手架开发 | -80%     |
+| Prompt Engineering | 仅能通过调用 API 或 Playground 进行           | 结合用户输入数据所见即所得完成调试                 | -25%     |
+| 数据准备与嵌入     | 编写代码实现长文本数据处理、嵌入              | 在平台上传文本或绑定数据源即可                     | -80%     |
+| 应用日志与分析     | 编写代码记录日志，访问数据库查看              | 平台提供实时日志与分析                             | -70%     |
+| 数据分析与微调     | 技术人员进行数据管理和创建微调队列            | 非技术人员可协同，可视化模型调整                   | -60%     |
+| AI 插件开发与集成  | 编写代码创建、集成 AI 插件                    | 平台提供可视化工具创建、集成插件能力               | -50%     |
+
+在使用 LLMOps 平台如 Dify 之前，基于 LLM 开发应用的过程可能会非常繁琐和耗时。开发者需要自行处理各个阶段的任务，这可能导致效率低下、难以扩展和安全性问题。以下是使用 LLMOps 平台前的开发过程：
+
+1. 数据准备：手动收集和预处理数据，可能涉及到复杂的数据清洗和标注工作，需要编写较多代码。
+2. Prompt Engineering：开发者只能通过调用 API 或 Playground 进行 Prompt 编写和调试，缺乏实时反馈和可视化调试。
+3. 嵌入和上下文管理：手动处理长上下文的嵌入和存储，难以优化和扩展，需要不少编程工作，熟悉模型嵌入和向量数据库等技术。
+4. 应用监控与维护：手动收集和分析性能数据，可能无法实时发现和处理问题，甚至可能没有日志记录。
+5. 模型微调：自行处理微调数据准备和训练过程，可能导致效率低下，需要编写更多代码。
+6. 系统和运营：需要技术人员参与或花费成本开发管理后台，增加开发和维护成本，缺乏多人协同和对非技术人员的友好支持。
+
+引入 Dify 这样的 LLMOps 平台后，基于 LLM 开发应用的过程将变得更加高效、可扩展和安全。以下是使用像 Dify 这样的 LLMOps 进行 LLM 应用开发的优势：
+
+1. 数据准备：平台提供数据收集和预处理工具，简化了数据清洗和标注的工作，最小化甚至消除了编码工作。
+2. Prompt Engineering：所见即所得的 Prompt 编辑和调试，可根据用户输入的数据进行实时优化和调整。
+3. 嵌入和上下文管理：自动处理长上下文的嵌入、存储和管理，提高效率和扩展性，无需编写大量代码。
+4. 应用监控与维护：实时监控性能数据，快速发现和处理问题，确保应用程序的稳定运行，提供完整的日志记录。
+5. 微调数据准备：提供人工标注知识库的批量导出，在应用运营过程中收集线上反馈数据持续改善模型效果。
+6. 系统和运营：易用的界面，非技术人员也可参与，支持多人协同，降低开发和维护成本。与传统开发方式相比，Dify 提供了更加透明和易于监控的应用管理，让团队成员更好地了解应用的运行情况。
+
+另外，Dify 将提供 AI 插件开发和集成的功能，使得开发者可以轻松地为各种应用创建和部署基于 LLM 的插件，进一步提升了开发效率和应用的价值。
\ No newline at end of file
diff --git "a/docs/md/career/01-Java\345\267\245\347\250\213\345\270\210\345\277\205\350\257\273\344\271\246\345\215\225.md" b/docs/md/career/Java-reading-list.md
similarity index 99%
rename from "docs/md/career/01-Java\345\267\245\347\250\213\345\270\210\345\277\205\350\257\273\344\271\246\345\215\225.md"
rename to docs/md/career/Java-reading-list.md
index 7e3a1efd9..7bcc7a128 100644
--- "a/docs/md/career/01-Java\345\267\245\347\250\213\345\270\210\345\277\205\350\257\273\344\271\246\345\215\225.md"
+++ b/docs/md/career/Java-reading-list.md
@@ -1,4 +1,4 @@
-# 01-Java工程师必读书单
+# Java工程师必读书单
 
  以下皆出自本人亲自翻阅过的书籍，体验良好，豆瓣大众也以为然，遂列举，以供后浪规划学习。
 
diff --git a/docs/md/career/efficient-professional-reading-list.md b/docs/md/career/efficient-professional-reading-list.md
new file mode 100644
index 000000000..2029eef1f
--- /dev/null
+++ b/docs/md/career/efficient-professional-reading-list.md
@@ -0,0 +1,47 @@
+# 高效职场人书单
+
+## 《高效人士的七个习惯》
+
+![](https://p.ipic.vip/2tyryo.png)
+
+帮助人们提高效率和个人影响力的七个习惯。这些习惯涵盖了从个人成长到与他人协作的核心原则：
+
+### **1：个人成功（从依赖到独立）**
+1. **积极主动（Be Proactive）**  
+   - 主动掌控自己的生活，而非被外界环境左右。  
+   - 关注“影响圈”（可控的事情）而非“关注圈”（不可控的事情）。  
+   - 你有权选择自己的态度、行为和反应。
+
+2. **以终为始（Begin with the End in Mind）**  
+   - 明确自己的目标和核心价值观，设定人生方向。  
+   - 通过制定个人使命宣言，确保所有行动与目标一致。  
+   - 把每一天当作实现长期目标的步骤。
+
+3. **要事第一（Put First Things First）**  
+   - 确定优先事项，专注于重要但不紧急的事情（如规划、学习、健康）。  
+   - 学会说“不”，避免被琐事或紧急但不重要的事情牵绊。  
+   - 将时间和精力用在对长期成功最有意义的地方。
+
+### **2：公众成功（从独立到互赖）**
+4. **双赢思维（Think Win-Win）**  
+   - 在人际关系中寻求互利互惠，合作共赢，而不是竞争或损人利己。  
+   - 建立信任，关注双方的利益和长期关系。  
+   - 追求“丰盈心态”（相信资源充足，人人都能成功）。
+
+5. **知彼解己（Seek First to Understand, Then to Be Understood）**  
+   - 学会倾听，真正理解他人的观点、需求和感受，而不是急于表达自己。  
+   - 运用同理心沟通，避免只从自己的角度出发。  
+   - 在理解对方后，再清晰表达自己的意见。
+
+6. **协作增效（Synergize）**  
+   - 尊重并运用多样性，通过团队合作产生“1+1>2”的效果。  
+   - 接受不同观点，寻找创新解决方案。  
+   - 利用集体智慧和资源，实现个人无法单独完成的目标。
+
+### **3：持续改进**
+7. **不断更新（Sharpen the Saw）**  
+   - 持续提升身体、心智、情感和精神四个方面的能力。  
+   - 定期锻炼、学习新知识、发展人际关系、实践反思。  
+   - 保持精力充沛，避免倦怠，通过更新自己实现长期成长。
+
+---
\ No newline at end of file
diff --git a/docs/md/career/life-beyond-career-growth.md b/docs/md/career/life-beyond-career-growth.md
new file mode 100644
index 000000000..3c42e0efa
--- /dev/null
+++ b/docs/md/career/life-beyond-career-growth.md
@@ -0,0 +1,81 @@
+# 人生不止于职业发展
+
+## 0 你的问题，我知道！
+
+工作意义到底是啥？或职业发展在人生这场表演到底啥角色？
+
+## 1 工作的意义
+
+农村人努力学习考上大学，得好工作，为逃离同村同龄人十几岁就工厂打工命运，过不凡人生，实现改命的唯一途径。毕业就进入自带光环的大厂，有份让所有亲戚羡慕的公司和薪水。我认为工作价值是让自己自立，改变命运。
+
+但现实挑战才开始。
+
+工作前几年，职场战战兢兢，如履薄冰，尽心尽力做靠谱人靠谱事。交代任务二话不说就是干，加班熬夜不敢喊累。
+
+这时，工作好像为证明自己价值。升职加薪像考试：
+
+- 通过，证明我还优秀
+- 没通过，自己还不行，还得努力
+
+很快被现实冲垮。有时拼尽全力，却发现塌方。整月还在加班赶项目，月底公司突然说战略调整，项目延期或作废。有些门，无论咋努力，就打不开。就像曾死磕要成为技术佬，后发现对技术佬理解过片面，且自己也确实不是技术极客料。
+
+渐渐发现我不是无所不能：
+
+- 有些事可能顺手
+- 而太多事一听就头麻
+
+外人眼中我顺风顺水，而只有我知心翻江倒海。某天开完巨长会议，瘫坐抬头看，问自己，今天开这么大会，给社会创造啥价值了？无，无丝毫可聊以安慰的价值。
+
+就想起马斯克说：如果你明显没在创造价值，请立即退出会议或挂断电话。这种离开不是一种粗鲁行为，让别人留下来浪费时间，那才是粗鲁。显然，那天我缺乏这勇气，那明天？后天？难道人生就这样继续？这就是自己愿意在这破公司干一辈子的工作？
+
+工作占据绝大人成年的一半时光，我们一直追问意义，在20、30、40甚至父母的50、60时都有不同答案。答案不重要，重要在追问过程，重新梳理了自己与世界，自己与自己的联系。
+
+现在的我28了，才体会到工作的意义应该给社会创造一些我认可的价值，助世界更好，贡献自己哪怕一丁价值。才不枉费人界一趟。
+
+大多人从最开始向外求，在乎名利title，在乎优渥薪水开始，到慢慢关注工作本身价值。因为生命的时间余额很贵，人生是无价的，我们希望把时间花在我们自己觉得有意义的事。
+
+## 2 热爱与工作的关系
+
+IT要求严密逻辑，不容半点自我感受，只能把那种“伤春悲秋”文字编码弃如敝履。
+
+职场最艰难时，在华为那半年每天工作十一二点，却还坚持博客日更。半夜两三点写完，第二天又九点到岗。最终，写作帮我从职场泥沼走出，完成重回软件人生。
+
+在之后，我开始想全职自媒体，内向不擅自我推销，不会运营。又是写作，帮我把真切感受、真实思考展示，完成转型冷启动。
+
+而如今，博客已助我链接很多同频、优秀人，就像通过博客认识屏幕前的你一样，世界再次被拓宽和凝缩。
+
+你的热爱可能手工，养花养草。它们可能没法立即养家糊口，但能以不同方式滋养我们。
+
+不论何时，花时间与自己在一起，认真对待热爱。
+
+## 3 幸福
+
+很长一段时间，学业和工作占绝对重心，即使有其它更多安排。多年不回家和父母亲戚过年，才意识到工作已入侵我生活太多，我已成工作奴隶！如果说工作为自己过更幸福生活，那我现在就还在背道而驰。
+
+我还想和你分享一个类似的故事。朋友家有个青春期的孩子，有厌学倾向，就带着孩子去看心理医生。心理医生跟孩子、孩子的爸爸和我的朋友都聊完之后说，我觉得他们都挺好的，倒是你，可能需要心理咨询。
+
+如果人生这座大厦有几根柱子，那你只有一根，就是工作，这根柱子特别粗，其余什么都看不见。一旦工作这根柱子塌了，你的人生大厦就崩塌了！当人生大厦只有一柱，这座大厦就是“尖塔式”，遇到不确定性强事就几乎没有转圜的空间，这种人生何来幸福？
+
+《持续的幸福》里非常经典的“幸福大厦”：
+
+![](https://p.ipic.vip/n1fmjo.jpg)
+
+幸福像房子，有五柱：积极情绪、投入、人际关系、意义和成就。
+
+有很多小伙伴因职业发展问题找我，多有名校背景，好经济收入，不错职场表现，但对未来充满焦虑，恐惧，迫切想知咋面对当下，咋破局。
+
+其实，我们还需看到工作外更全局人生：
+
+![](https://p.ipic.vip/vs0jl9.png)
+
+在一个生命平衡论里，职业发展只占 1/8，人生不只职业发展，还有亲情、友情，还有休闲娱乐，还有最最重要的个人健康，还有自我实现。
+
+几年前第一次做生命平衡轮，正处职场特焦虑时，发现自己生命平衡轮失衡。如满分10 ，哪怕投入时间最多的职业发展自评就6分，亲情、友情都是不及格，而个人健康、休闲娱乐、自我实现只有4分。
+
+才意识到自己工作困境不是工作本身，而是自己系统失衡。才开始关注健康，花时间陪家人，去见朋友，去破圈认识我好奇的人和事。从那开始，我才真正挖掘自己优势，尝试找自己真正认可、长期有意义的事。
+
+很多工作焦虑解药不在工作，而在人生大盘。跳出工作狭小问题，有亲密家人，有温暖友情，强大社会支持系统，内心才充盈、笃定，有源源不断动力向前。
+
+## 4 总结
+
+职业发展非并人生全部，愿你活出自我，找寻到自己向往的价值。
\ No newline at end of file
diff --git a/docs/md/career/moat-of-rd.md b/docs/md/career/moat-of-rd.md
new file mode 100644
index 000000000..474ed7f57
--- /dev/null
+++ b/docs/md/career/moat-of-rd.md
@@ -0,0 +1,194 @@
+# 研发的护城河到底是什么？
+
+## 0 你的问题，我知道！
+
+和大厂朋友聊天，他感叹原来努力干活，做靠谱研发，积累职场经验，干下来，职业发展一般问题不大。而如今大厂“年轻化”，靠谱再不能为自己续航，企业似乎也不愿意持续为经验买单。
+
+在这不确定时代，职业发展中有无硬通货？
+
+更长远职业发展角度：
+
+- 要抓住机会
+- 要抵御风险，构建自己的职业发展护城河
+
+## 1 机会来自不断积累职场燃料
+
+机会和啥相关？职业发展机会来自不断积累职场燃料。
+
+### 1.1 啥是职场燃料？
+
+《远见》总结三种基本形式的职场燃料：
+
+- 可迁移的技能
+- 有意义的经验
+- 持久的关系
+
+每一种都对获得长远的成功非常关键。
+
+### 1.2 可迁移的技能
+
+工作所掌握核心技能，是换岗、跳槽、改行都能带走的技能。回想研发职场能力全景图，哪些能力可迁移？
+
+#### 硬技能
+
+你会Java编码、解决业务提出的需求，这些不是可迁移技能。但如能把业务问题解决过程总结成“发现问题 - 分析问题 - 解决问题”方法论，在不同行业都能拿结果，那它就是强大可迁移能力。
+
+#### 软技能
+
+基本都可迁移。
+
+他从大厂技术管理做到研发职业发展教练，写代码、查Bug技能肯定都还了，但还有软技能，继续支撑当下职业：
+
+- 沟通表达能力：能与别人高效沟通，清晰表达，还能写出有深度文章。性格内向，少露面，光靠公众号写作也能完成获客和营销
+- 系统思考：能进行一些深度思考总结，找到问题背后规律，助快速找到客户问题背后深层原因
+- 领导团队：虽无团队可带，但做教练陪跑研发职业发展，其实做的就是培养人，企业里历练的培养人的经验都能复用
+- 跨界协作：与不同角色、平台沟通和协作
+
+这些可迁移的技能时间累积，会对职业发展产生大影响。
+
+他大学计算机老师，后北漂，从运维岗做起在日企。日企对文档要求高，要求细化到每个步骤、每个命令及每步操作预案，出问题咋处理，处理完后，还要再把文档更新完善好。
+
+这不耽误时间吗？啥用？但就这看繁琐工作，助他快速积累技术能力，养成记文档好习惯。最近从企业里出来，做技术顾问。这时，当老师表达能力和上份工作写作能力又成助力。他总结之前做技术和现在做技术顾问差别：
+
+- 做技术是把简单问题深刻化
+- 而做咨询要善于把复杂问题简单化
+
+现在看这一路都贯通，每步都是为今天转型铺垫积累。多种素质无形捏合，形成新自我，服务当前工作。
+
+### 1.3 有意义的经验
+
+指生活和工作中独特、多样性经历。可能成功或失败，如从 0 到 1 做 XX 项目，即使最后失败，也有一手经验。
+
+啥叫“有意义”？
+
+#### 让你与同类有区分度
+
+如一个运维既做过 C 端业务运维，又做过 B 端的业务运维，既有业务运维经验，又有网络机房运维经验。那比只做过业务运维更有区分度。
+
+面试官很在乎你在啥公司，做过啥。如平台不错，项目又有挑战，就有意义的经验，会成简历“亮点”，加分。
+
+#### 对你认知有大影响
+
+几年前 O2O 甚嚣尘上时，我去一家公司面试。最后 CEO 面时，对方对于我做的系统、带的团队并没有多问，反而听我聊起如何跟着 BD 去线下拜访商户，对咋实地解决商户问题感兴趣。
+
+结束他说，背景好，技术不错人多，但你为数不多从线上系统主动走到线下，还有总结思考，正是需要的人才。
+
+因此，研发不只停留代码层，而应深入业务现场，真正解决真实问题，技术赋能业务。
+
+建议日常工作和生活中给自己创造一些不一样的体验。如：
+
+- 做一个前景还不明朗但你想尝试的项目
+- 如工作多年人，主动创造轮岗机会
+- 如整天在办公室写代码，选择跟销售去线下跑几趟
+- 如去认识一些圈子完全不同人
+- ……
+
+很多事做前不知意义，而是你去做，体验，才让它有不一样意义。当下它只是在你身体里留下烙印，埋下一颗种子，某一天其它事件唤醒时，你才意识到它的意义。
+
+### 1.4 持久的关系
+
+包括职业生涯中相关人或团体，共同组成职业生态系统。他们可能是并肩作战伙伴，可能关键时提携贵人，也可能你痛苦时给你提供情绪价值朋友。按重要性由低到高排序：
+
+![](https://p.ipic.vip/so2p02.png)
+
+- 一般联系人
+- 拥有特殊知识和权力的专家团。如做技术的行业内专家，崇拜的技术佬
+- 对发展有决定和影响的关键同事。第一显然你上级，影响你职业成功和幸福的头号人物。+2也重要，还有关键同事，如紧密配合产品、测试、关键下属等
+- 支持者，职业生涯中给你提建议、拥护你、激励你的贵人或导师
+- 自己，才是最强大稳固支持者。职业发展主动权在我们手
+
+持久关系在职业发展也重要：
+
+十几年前，他在小公司做技术，月薪 3000，闲，一眼望到头，工作之余学前端，但没好机会。学前端时加个社群，看有人自学进北京大厂。听后蠢蠢欲动北漂。疯狂面试，慢慢积累自信心。有次独角兽面，三面跟面试官投缘，坦诚自己梦想，就想进大厂。面试官也触动，告诉他自己原百度出来，给他内推百度机会，后来他真面试过，大厂认识很多优秀人快速成长。他说帮他内推大哥是贵人。他扩大自己联系人圈，看到更多可能性。同时又遇到自己支持者，后来还定期跟这“贵人”交流，分享工作现状，成朋友。
+
+咋经营持久关系？
+
+重要的不是你有多少关系，不是微信几人，而是你是否在维护这关系，是否用心投入一些重要关系经营，他们是否是你持久的关系。所以对职业发展重要关系，用心对待。
+
+不是肤浅“搞关系”，而是对助过我的人感恩，对合作中的伙伴保持尊重。如当前工作，梳理10 个当下与你工作息息相关的人，看他们咋评价你。再用10节里提到的理解职场中不同人的利益和恐惧，看能否帮你更好处理这些人际关系。
+
+职业发展不同阶段，找不同“支持者”，可给我们当导师指点迷津，助走向下个阶段的人。我出来做职业发展教练，路陌生，原人脉圈都无法提供支持，我就去找教练圈、职业发展圈非常资深前辈作导师。一般优秀老师得付费，但ROI高，给自己找个超强外挂。
+
+## 2 构建护城河
+
+### 2.0 啥是职业发展护城河？
+
+绝无仅有：别人难模仿超越或至少不能短时超越
+
+可不断使用和复制，并加深加固。如你解决代码 Bug 的能力不是护城河，但如你能把技术人日常 Bug、故障排查沉淀成一系列文章，甚至课程，就形成一定护城河。
+
+技术人职业发展护城河的构建，从“点 - 线 - 面 - 体”构建：
+
+![](https://p.ipic.vip/iuqgtu.png)
+
+### 2.1 点
+
+大多职场起点，是工作前几年状态：
+
+- 技术，要在一技能栈精进
+- 合作，做事靠谱、值得信任。如你是前端，对常见前端语言，浏览器原理熟练，能很好解决日常问题
+
+### 2.2 线
+
+到职业发展的一阶段，光有技能栈不够，要：
+
+- 一专多能：深耕某领域，成为一领域专家，利 用专家能力解决一般人解决不了问题
+- 也可走管理，可把你的价值放大
+
+除前端开发，也去了解客户端开发，甚至基础的后端数据存储，接口设计，运维部署等，可帮助顺畅与不同角色合作，扩充技术视野，甚至有需要成为全栈。
+
+### 2.3 面
+
+当你能把很多点连城线，持续建立个人影响力和口碑，有自己代表作，慢慢就可成为行业内有影响力专家。别人提到某领域，就想你，影响力就是你护城河。
+
+除专家，可试往稀缺性人才发展：
+
+- 把成熟经验带到新行业：某佬从大厂离开，一直在做传统行业的数字化，让互联网成熟的数字化技术在传统行业落地，他已经沉淀很多了，这就比很多只有单一大厂背景的人有更多优势
+- 复合型人才：有跨多个领域，可能每个领域只是 1/100 的优秀人才，那交叉领域可能就是 1/100*1/100，变成万里挑一的稀缺性人才。如互联网十几年技术，对心理学感兴趣，一直也研究。大厂出后，潜心投入心理学学习研究。希望把互联网技术，如AI运用到心理辅导中，让心理学更可解释，让心理咨询这个行业的商业模式发生一些改变。虽然她还在路上，但显然她是计算机与心理学交叉领域的稀缺性人才
+
+### 2.4 体
+
+前面“点 - 线 - 面”，还是把个人能力精进、拓宽、多维度组合，但这还只是优秀“打工人”，还依赖合适平台生存。而职业发展最大护城河是**“把自己活成一支队伍”**，能脱离平台，自建体系。
+
+- 超级个体：利用专业技术同时服务多个企业或一群人
+- 创业：构建闭环系统。虽创业风险，但个人职业发展角度，能力越综合，也逐渐脱离平台，独立承担风险，职业发展巨大飞跃
+
+### 2.5 实战理解
+
+他刚毕业DBA运维，经四五年积累，对MySQL原理、分布式数据库集群运维透彻，也能跟研发很好合作解决问题。这时护城河是“点”。
+
+虽还行，但还担心 DBA 运维领域窄，正好业务发展快，开始了解高可用系统设计，用学到知识助业务解决发展中各种性能瓶颈，同时也加深对网络机房运维了解。
+
+这时，他不再是DBA运维，是具备业务架构设计和具备网络机房、业务多种场景运维能力的综合性人才了，他的护城河就进入到了“面”。
+
+持续积累，开始在技术大会分享，逐渐很多公司希望他帮忙去解决系统架构问题，行业积累不错口碑，职业发展护城河已具备“面”特征。
+
+- 如有天不想在企业干，还可独立出来做技术顾问，同时服务多家企业，做超级个体
+- 如有资源，也可创业，提供好运维产品，给中小企业服务。
+
+职业发展护城河就到“体”。
+
+不是都要走完四阶段，也非护城河发展都连续。有些人直接从“线”到“体”，如我就是从企业技术管理者，变成自成系统自由职业者。也有最后停在“面”，寻找适合平台，毕竟每人特质不一，很多人不适合单干，而适合在框架内做事。要了解自己特质，探索适合的职业发展护城河。
+
+## 3 总结
+
+本文分享长远发展相关职场燃料：
+
+- 可迁移的技能
+- 有意义的经验
+- 持久的关系
+
+职场升级过程，再好位置，再光鲜title都是平台，离开一家公司平台，都带不走，唯一可带走就是这些职场燃料。
+
+总结研发人职业发展的护城河，从做靠谱单点，到“一专多能”线，再到行业影响力专家或者稀缺性人才，最后到自成体系“体”。
+
+想抵御职业发展风险，要从单一逐渐往复合型发展，从所有人都会的技能到稀缺性独特技能发展，工作形式也越来越脱离平台，开始独立承担风险。
+
+有朋友之前在大厂多年：
+
+- 一边特别想出来自己干
+- 一边又特别害怕出来干自己会养不活自己
+
+后来跺脚出来，摸索一年后，他自己设计产品得到市场认可，很多人买单。那一刻，他说，当我不依赖任何平台，能独立与社会进行价值兑换时，感觉自己真正成人。
+
+打工为不打工，打工修炼为能力成长，能“工作自由”能力，再不为裁员焦虑，不因绩效恐慌，而按心意工作。希望你早日修筑职业发展护城河，“工作自由”。
\ No newline at end of file
diff --git a/docs/md/career/must-have-soft-skills-for-rd.md b/docs/md/career/must-have-soft-skills-for-rd.md
new file mode 100644
index 000000000..27e2dc0d3
--- /dev/null
+++ b/docs/md/career/must-have-soft-skills-for-rd.md
@@ -0,0 +1,176 @@
+# 突破自我，研发必须掌握的软技能！
+
+## 0 你的问题，我知道！
+
+光有硬技能远不够，很多研发硬技能不错，但发展有明显天花板。
+
+影响研发职业发展走多远的核心能力有啥？技术只是打底和起步，长期职业发展看综合能力，各种软技能组合。研发常忽视或理解片面的能力：
+
+## 1 沟通表达
+
+### 1.1 啥是沟通表达？
+
+不是口头“能说”，而是能把事简洁、结构化、逻辑清晰表达：
+
+- 不只包括面对面口头沟通或会议沟通
+- 还包括书面沟通，把自己思考形成清晰文档。毕竟大多场景需文字达到合作、说服、通知或解释
+
+沟通表达能力是最基础，却最重要职场通用能力，也最被研发低估，也阻碍职业发展。研发专业属性强，技术语言很抽象。同样做技术，前端可能很难理解你的后端接口为啥这么设计，更别提技术和产品、运营这些角色沟通。现在职场分工细致，都要靠各种角色协作结果。
+
+研发沟通表达能力弱的
+
+### 1.2 缺点
+
+不但日常项目与不同角色沟通效率低，影响项目进度质量，还让你就算干活，也不会结果呈现，更别提晋升述职，年度汇报。更长远发展，你也因沟通表达不好，没有很好梳理和沉淀经验，导致难建立长久个人影响力。因此，沟通表达是所有综合能力基础。
+
+上过些沟通课，听过一大堆沟通工具如 3F 倾听，金字塔结构化表达，不赘述学习理论。这只分享几个简单有效的
+
+### 1.3 经验
+
+#### 1.3.1 换位思考
+
+##### 案例
+
+老板带十几个技术管理给大老板汇报。研发都是各种秀系统架构图，技术治理方案，口若悬河，但发现老板迷茫，刚开始还象征性听会，后面就埋头工作。大厂这种无聊大会，“客厅里的大象”比比皆是。
+
+于是，我琢磨这会议目的到底啥？和大老板啥关系？显然大老板关心收益、成本、效率，研发关注和行业对比的创新点。于是我述职时，先从负责模块给企业带来的收入、降本的出发点，再说说我们咋思考、咋去做、攻克啥难点。大老板听懂，才会给更多输入，会议目的才真达到。
+
+做到不难，就是理解别人诉求，别人关注重点，再把要讲的以别人能接受方式讲出。别忘沟通目的是有效传达信息，让对方理解接受。所以必须理解你的沟通对象。
+
+#### 1.3.2 结构：先框架，后细节
+
+晋升述职也是。先讲清背景，讲清你做的在整体体系内的位置，你做的啥，今天沟通目的啥……让大家先回到同一范围对话。
+
+很简单，但研发易沉浸代码细节，所以下意识跳过这环，导致很多时候聊半天也没聊到点。听众一会就睡了。
+
+#### 1.3.3 细节：大白话
+
+很多角色和技术沟通最大痛苦在技术黑话多，多到听不懂。好的沟通尽可能大白话讲，让非专业的人都听七七八八，甚至听懂。
+
+少用“撑场面”专业术语，必须要用，那给外行人讲时，最好先类比，更好理解。可刻意练习，最好试着给家人讲清你的工作。我有段时间给 6 岁的孩子讲自己做的外卖系统，非常有挑战，但讲完之后，发现自己对于外卖系统的理解和抽象能力又提升一大截。
+
+沟通表达是心系沟通对象，找到信息和别人关心的东西之间的关联，按一定结构和框架输出，细节注意少讲技术黑话。这些基本功达到，你的沟通表达能力不会差。
+
+沟通表达是基本功，提升无捷径，就刻意练习，像写代码，多练才提升。
+
+## 2 自我管理
+
+### 2.1 目标管理
+
+清楚啥对己重要。你每天可能在工作花10h甚至更长，但对最终结果起关键作用、年底绩效关键影响的事不多。如不找到这些重要事，就会忙碌整年，结果却不好。
+
+你可能爱学，一年参加活动，囤课程，看书，但真正对个人成长影响比较大事没啥。若无阶段性成长目标，付费学习可能纯属消遣，并无真正成长。
+
+所以，你得花够多时间梳理目标。职业发展角度，如下目标很关键：
+
+- 手头工作：职场工作全景图去梳理当前工作的优先级，找到那些重要的事情
+- 长期的能力发展：职业发展不同阶段的策略【05】来理清当下自己想重点突破的能力。
+
+#### 案例
+
+他工作 6 年，所在公司发展很快，一起入职同事不少升得很快。有的都带团队，而他还大头兵。虽活干还行，但绩效总一般。推荐他梳理所在业务当下重要问题，多和TL沟通，确定啥是重要事。很快，他攻克团队几个重要难题，TL也对他赞不绝口。
+
+他也意识到自己当下能力不足。如对业务全局思考不够，性急，带项目易与人冲突……挨个梳理其发展目标，明确清晰TODO。几月后，他说，“我现在好像没之前忙了，不到 8 点，重要事就干差不多，还可回家看书。”
+
+当一个人目标清晰，人都清爽了。
+
+### 2.2 时间管理
+
+重要事投入足够资源，对我们，最重要资源是时间，需做好**时间管理**。确定目标后，就为重要事配备足够资源。时间是最宝贵资源。
+
+《你要如何衡量你的人生》说企业级战略落地过程，资源配置是最重要环节。
+
+自我管理也是，很多嚷着重要事，其实根本没配备足够时间。如认为身体健康最重要，但依然每天外卖、熬夜，不运动，就被体检结果打击后才突击跑几步。
+
+都听过很多时间管理工具和方法，如番茄时钟法、重要 / 紧急四象限、GTD时间管理法，但真把工具执行到位极少。觉得上班够忙，能掌控时间太少，有啥可管理？
+
+#### 案例
+
+他在大厂上班的妈妈，孩子才3岁，自己工作很忙。入职时就跟 HR 和主管都聊过，因孩小，希望8点半前下班。当然，工作不耽误，也会早到公司，比别人早一小时。
+
+这样早送孩子上幼儿园就来班。每早，给自己梳理重要三事，早上办公区安静，工作效率高。
+
+你看，如此忙大厂，仍把时间管理主动权掌握在手。很多事商量来，当你把选择权拿在手，就不易被环境裹挟。
+
+还有一种case，很多同学一味给自己加任务，但无阶段性复盘资源使用情况，也是为啥年度 Flag 立了就倒。因为你年初设定目标，可能并未评估清楚每项到底需多久，要不中间遇到新变化。
+
+现每段时间复盘目标，再找到自己的限制性资源。绝大部分的限制性资源就是时间，这时候除了要学会借力找外挂，更重要学做减法：
+
+- 砍掉一些事。若哪些东西当下精力Cover不了，先放下，后再拿起
+- 降低成本去做。若有些事例行，尽可能想咋低成本做。如有段时间坚持冥想，有时间就饭后冥想，没时间就开会前几min冥想，其实无需专门早起设置特殊时间安排，效果也不错
+
+### 2.3 情绪管理
+
+有清晰自我认知，能理解自己情绪，拥有与情绪共处能力，并做到自我赋能。自我管理的核心是情绪管理，因为状态是做一切事情的基础。
+
+大多人情绪管理理解就是我要够理性，灭情绪，这是误解。情绪不但是无法逃避的客观存在，更是身体对我们的提醒，背后蕴含巨大礼物。
+
+#### 客观存在
+
+职场不可避免遇糟心事。可能产品 Diss 项目工期太长，可能“猪队友”接口总报错。或管理者，上级在会议给你加活，还话里话外提醒你团队效能不高，你刚愁容走出会议室，结果一个核心同学发消息：老大，我想离职！
+
+情绪客观存在。当情绪上来，别抗拒或责备自己“咋又生气”。与其和己较劲，不如离开原场合，深呼吸，先冷静。如有条件，冥想也是让自己安静方法。
+
+#### 一种提醒
+
+- 有时你原认为对的事
+- 特别期待的事在现实碰壁
+- 坚持的价值观被扭曲
+- ...
+
+所以情绪上头。
+
+一个优秀每年高绩效朋友最近焦虑，因为老板通知他2月合同到期后不续签。他惊慌之余愤怒，“为啥是我？”通过对话，他慢慢意识到自己有朴实信念：只要努力工作，就有好结果，而当下环境给他一棒。
+
+“旧信念被冲毁，新还没构建”，新旧交替空档期，焦虑正常。他也有优势，只是需在新战场重新组装自己能力，这时会经历痛苦期，但是成长必经。
+
+很多人处焦虑惶恐态，推荐你忙碌同时，好好构建自己的社会支持系统。有情绪时，有家人、朋友倾诉，也得对方能真倾听。
+
+有些男性的社会支持系统薄弱，自己是家里经济柱，而职业发展困惑没法和家人聊，平时朋友又少，只能自己扛，确实累。可寻求专业指导支持：
+
+- 因为之前太缺乏社会支持
+- 大多男性面对情绪之后，更能理性地执行
+
+人知道自己的阶段目标，配备相应资源去落地，过程还能管理情绪，给自己赋能，就具备很好自我管理能力。
+
+## 3 跨界协作
+
+一人想走更远，不能仅靠个人力量，需和多人跨界协同。
+
+技术人的跨界协作分为三部分，企业内跨角色、跨部门的协作，行业内协作以及不限行业的协作。
+
+![](https://p.ipic.vip/dm2s4a.png)
+
+### 企业内协作
+
+司内不同角色、不同部门不同业务线协作。一些大项目提供与不同角色合作机会，但还需主动走出。如一个大厂有不同业务线，而你正做某项目，要用新技术，自己也没把握，完全可找有类似经验、不同业务线同学学习，让自己少走弯路。大厂很多中台，除了用他们的 API，你也可技术上和对应同学交流讨论。你还可以主动去跟产品、业务同学多沟通，从他们的视角重新理解你做的系统。
+
+### 往外走：行业内协作
+
+结识一些行业专家。他们会极大地拓展视野，让你了解这行业最聪明大脑咋思考你日常面对的问题。
+
+定期参加技术大会，主动结识一些专家。不是加微信就建立联系，而是打过一些交道，合作些事。
+
+如参加完技术大会，留下来当面与欣赏的大牛交流，一边表示感谢，说哪些地方对你启发大，一边提出具体困惑与大牛探索。甚至把你今天听完分享的一些感受和实际的行动整理成文字，分享给行业大佬，让他给你指点指点。一般有经验前辈都愿意帮助一个用心晚辈。
+
+### 跨行协作
+
+很多焦虑 35+ 危机，一聊又发现周围都是焦虑迷茫者。建议这类同学多去找那些与自己经历差大的人聊。
+
+大厂兜转 10 年的人，建议她跟从大厂出来创业好几年的人聊，她一定听到很多大厂局限，甚至发现大厂积累更多自己看不见的能力和资源，只是在当前工作范围内，她不了解。
+
+《职得》说过：真正对你有帮助的人，是那些跟你有很多不同之处的不同之人，正是这些不同之人的不同之处给你带来了新的观点，带你走向全新的领域和更高的格局。拓展职场社交的真谛，在能否和你不同的人身上找到交集，并促进双方利益共同发展。
+
+破圈、跨界协作是研发急需突破能力。因更长远角度，科技第一生产力，从社会角度，研发人才未过剩，只是在互联网行业显得过剩。更多机会在自己能否打破惯性，破除原圈，去跨界协作，发现可能性。
+
+## 4 总结
+
+职业发展非常重要的软技能，沟通表达、自我管理、跨界协作。
+
+沟通表达，就换位思考，先整体后框架，大白话把工作讲明。掌握好，定让工作效率大升，还能放大工作成果，助建立个人影响力。
+
+自我管理核心三要素，在于知啥对你重要，并知咋在重要事上投入足够资源，做好自我觉察，学会情绪共处，给己赋能。
+
+而跨界协作，助我们走向更远，跨角色，跨企业，甚至不限行业的交流与协作，一定能一点点扩大世界。
+
+社会对人才能力要求越来越综合，往复合型人才发展，对研发，复合型人才就是既能写好代码，做好架构，解决业务难题，又能写好技术文章，站在技术大会分享，还能不被研发标签束缚，保持好奇心和敬畏心，与不同岗位、不同企业、不同行业的人交流碰撞，在更大的舞台上绽放光彩。
\ No newline at end of file
diff --git a/docs/md/career/no-tech-no-future-for-rd.md b/docs/md/career/no-tech-no-future-for-rd.md
new file mode 100644
index 000000000..d547f64b4
--- /dev/null
+++ b/docs/md/career/no-tech-no-future-for-rd.md
@@ -0,0 +1,165 @@
+# 没有技术，研发就真没前途吗？
+
+## 0 你的问题，我知道！
+
+很多技术人都有自己崇拜的技术大咖，特别渴望成为他的样子。比如阿里很多小伙伴都特别崇拜鲁肃（花名，前支付宝 CTO），膜拜王坚博士（阿里云创始人），心里幻想着自己有一天能像大牛一样挥斥方遒，搞定一个个技术难题，建设起一个庞大的系统。
+
+在很多人看来，一个典型的技术人，就是遇到技术难题，就会两眼放光，像乞丐看到面包一样扑上去，认真研究。聊起新技术，就口若悬河，眉飞色舞……如果自己不是这样的，就会担心自己成为不了技术大牛，继而出现一个新的困惑：成为不了技术大牛，是不是职业发展的天花板就会很低？
+
+事实上，这是很多人对于职业发展的刻板印象。成功的路不止一条，技术人的职业发展之路千差万别，跟每个人的特质关系很大。
+
+## 每个人都是独一无二的存在
+
+每个人都有自己更倾向的思维模式、感受或行为，我们把它叫做才干。比如有的人喜欢研究逻辑推理，爱看侦探小说，而有的人更喜欢人文，对人的情绪、人的发展更敏感。比如有的人天生就自来熟，见到陌生人能毫无压力地搭讪、建立关系，而有的人在人多的酒桌上会浑身别扭……每个人的才干都和自己的出厂设置有很大关系。
+
+有很多工具可以帮助我们识别自己身上的独特性，比如全球有 3000 万人使用过的盖洛普优势测评就是一个很好的工具。经过数十年的研究和沉淀，盖洛普认为与潜能最直接相关的才干可以分为 34 个主题。这 34 个才干主题可以划分为 4 个领域，执行力、影响力、关系建立和战略思维。
+
+![image-20250130210149975](/Users/javaedge/Downloads/IDEAProjects/java-edge-master/assets/image-20250130210149975.png)
+
+我简单说下 4 个领域的含义。
+
+**执行力**：也就是懂得如何完成任务。一般这个领域才干比较突出的人，对于别人交给自己的任务，尤其是比较确定的事情，都能很好地交付。
+
+**影响力**：知道如何掌控局势，有一种外显的力量感，可能给人一种很有 Power 的权威感。在职场中，这类人有时候会显得很有气场。
+
+**关系建立**：擅长建立牢固的关系，从而将团队凝聚起来，发挥更大的力量。很多人会觉得影响力领域突出的人更有领导力，事实上，那只是一种外显的力量，真正的领导力来自深度信任的建立，凝聚人心，使众人行。所以，在领导力这件事上，反而是关系建立领域靠前的人更有优势。
+
+**战略思维**：这个跟企业里说的战略思维不一样，它指的是我们的大脑获取信息、加工信息、做出决策的过程。战略思维领域尤其突出的人特别享受思考。
+
+盖洛普优势测评会根据测评结果给 34 个才干主题进行排序，在全球 3000 多万份的测评中，几乎找不到两张完全一致的报告，这足以验证每个人都是独一无二的存在。
+
+很多技术人的盖洛普优势测评显示，技术群体的战略思维和执行力领域更突出，关系建立偏弱，影响力领域更弱。在战略思维和执行力领域里，分析、排难、思维这些才干主题又会更靠前。也就是喜欢像做数学和物理题一样做逻辑推导，在看起来混乱的东西中总结规律，找到那个 Root Cause（根本原因），从根源上解决问题。这确实跟大家以为的“典型技术人”很像。
+
+但事实上，也有非常多的技术人不具备这样的特质。如果你深入了解周围的小伙伴，可能会发现与典型技术人形象非常匹配的同学可能连 20% 都不到。
+
+比如有些小伙伴的关系建立领域更靠前，他会很在乎同事之间的关系，关注团队的氛围，会在乎身边人的感受，有时候会为了别人的感受把一些话咽回去，面对冲突的时候也会非常不舒服。如果他不了解职场的游戏规则，可能还会给自己贴上“玻璃心”的标签。其实，它只是个人的特质。
+
+这个领域的才干刚开始在职场中可能不那么好用，甚至会带来一些内耗。你可能会羡慕那些目标明确、想清楚了就像机器人一样咔咔执行的人。但事实上，你更能理解他人，更能理解第 10 节提到的职场上不同角色的利益和恐惧，有了时间的加持，你往往能赢得更深厚的关系。如果带团队，可能还会慢慢沉淀很多愿意跟随的人。
+
+比如有的小伙伴影响力领域的很多才干靠前，可能会特别迫切地想干一番大事业，天生希望赢，比别人更渴望鲜花和掌声。这样的小伙伴可能在陌生人面前一点都不社恐，甚至喜欢张罗事儿，喜欢站在聚光灯之下。
+
+即使一个看起来是典型的技术人，每个人之间也是有很多差异的。两个同样都喜欢研究问题的技术人，有的人喜欢跟别人讨论、碰撞，去把事情聊清楚，有的人就喜欢自己琢磨明白。有的人喜欢想明白再干，而有的人习惯边干边调整。
+
+世界上没有完全相同的两片叶子，也没有完全相同的两个人，每个人都是独一无二的存在。
+
+## 职业发展，离不开你的优势
+
+我们在第 5 节分析了技术人职业发展不同阶段的发展策略，在第 13 节也聊到了技术人职场的能力模型。这些都会给你一些职业发展的宏观视。
+
+但回到个体的我们，职业发展路径具体应该怎么走，还必须多一个视角，就是回到我们自身的特质。因为我们每个人抓到的牌不一样。
+
+那在职业发展这件事上，我们如何打好自己手里的牌呢？首先，就是要找到自己的天赋优势，其次，发挥优势，扬长避短。
+
+### 如何找准自己的优势？
+
+什么是优势呢？有个简单的公式。
+
+![image-20250130210202518](/Users/javaedge/Downloads/IDEAProjects/java-edge-master/assets/image-20250130210202518.png)
+
+翻译一下，就是在你具备天赋的领域里，不断投入训练，就会形成属于你的竞争优势。要想找到自己的优势，我们先要找到自己可能有天赋或者有潜能的地方。那具体怎么找呢？
+
+前面提到的盖洛普优势测评就是一种非常快速的方法，我建议你测评之后找专业的优势教练结合自己的实际问题去解读。一方面，是因为自己的解读难免有理解不到位的地方，盖洛普优势报告的 34 个才干有很多含义跟字面意思差异挺大的。另一方面，专业教练也会根据你的岗位要求和个人情况给出针对性的分析建议。
+
+当然，除了测评工具，你还可以通过自己的观察以及周围人的评价来找到自己的天赋。
+
+先来说说自己的观察，你可以尝试问自己这么三个问题。
+
+**哪些事会让你觉得特别有成就感？或者说，哪些事你比别人做得又快又好？**
+
+拿我来举例子。工作时，周围的技术人和产品聊东西经常很费劲，我路过时，插上几句话，产品和技术常常会转头说，“对，就是雪梅说的这个意思”。我发现自己好像特别擅长做技术人与不同角色之间沟通的桥梁，而且很快就能说到事情的本质。这个优势后来在我带团队，甚至出去演讲的时候，一直在发挥作用。
+
+**哪些事****即使****没有别人要求，你****也****会持续去做？**
+
+刘建国老师说自己在做技术的时候，发现自己挺喜欢给团队分享，而且每次分享大家都会觉得很有收获，第一次去公司当内训师，就获得了金牌讲师。这些当初自己并没有意识到的潜能后来成就了他，让他成为了技术圈非常有影响力的讲师。
+
+**如果时间充裕，你也愿意努力的话，你还会擅长****哪些****事情？**
+
+挖掘自己的天赋不能光靠想，还需要去实践验证。我曾经觉得自己社恐，社交能力很弱，后来发现自己带团队时，居然有不少人会很信任我，我发现自己一对一建立关系的能力非常强，而且往往关系还比较牢固，这都是在实践中发现的。
+
+你可以用这些问题去做自我觉察，看看自己的优势在哪里。当然，个人视角会有很多局限性，你可以再增加一些他人视角，比如找几个你信得过的朋友或者几个前辈，问问在他们眼里，你有哪些方面他们特别欣赏和认可。
+
+举几个细化问题的例子。
+
+你觉得我在哪些事情上做得比较好？
+
+如果我在你团队工作，你会倾向把什么样的事情交给我？
+
+你觉得我跟同龄人来比，在哪些方面比较突出？
+
+在这些问题之上，你再多追问几个为什么，就可以收集到更多的信息，是自我觉察之上很好的补充。
+
+不过，目前找到的这些都只是天赋，要把它们转变成你真正的职场优势，还需要投入足够多的时间刻意训练。
+
+拿我来说，盖洛普优势测评中，我的突出才干有思维（喜欢深度思考，追根溯源）、回顾（擅长从过去中总结规律学习），我还发现自己平常挺喜欢写点东西，常常能写出心流。那我的思维、回顾才干和我爱好的写作如何变成我的职场优势呢？
+
+我不是天生的技术极客，对于技术研究本身没有那么大的热情，有时候遇到技术难题，死磕半天也搞不定，就会厚着脸皮问别人。但问完之后，我就会发挥自己的思维 + 回顾才干，去复盘总结规律，想想这类问题应该怎么解？哪些知识点我是缺乏的？哪些技能我还不够熟悉？下次做这样的事情我再做会有哪些不一样……
+
+往往这样问完之后，我还会自己用文字记录下来。慢慢发现自己不是技术大牛，但大部分的问题也能慢慢搞明白，而且有些问题我还会有一些方法论层面的、更深层的思考。
+
+此外，因为有了体系化的思考，我也开始慢慢写一些文章，去琢磨怎么把一件事讲得让更多人听明白。有几年还会刻意去历练自己的 PPT 演讲能力，每个月给团队做几次分享，一次次打磨，这都让我的沟通表达，述职呈现能力得到了极大的提升。所以系统思考、沟通表达、述职呈现都成了我的职场优势，在职业发展上给了我很多助力。
+
+你也可以梳理一下自己的天赋，思考下在工作场景下如何刻意练习，让它们真正变成你的职场优势。
+
+### 如何扬长避短？
+
+了解了自己的职场优势之后，我们就可以具体到“场景 - 角色 - 目标”下去谈成长和职业发展的事了。
+
+什么是“场景 - 角色 - 目标”呢？比如小 A 是个带 5-6 人团队的新经理，他发现自己在与上级沟通的时候有卡点，影响自己团队的工作产出，很苦恼。这个场景就是向上沟通，角色是新的技术经理，目标是提升向上沟通能力。
+
+通过优势挖掘，发现小 A 确实不属于灵机应变，脑子很快的人，有时候在大会上被上级突然问一个问题，可能一下子脑子就空白了。但他自己的逻辑分析能力不错，一对一沟通能力也还可以。于是我建议他每次与上级沟通之前做充分的功课，梳理好提纲，理清楚目的与逻辑，尽量约老板先做单独沟通，慢慢地，他打通了向上沟通的卡点。
+
+职业发展这条路也是如此，我们不需要死磕自己的短板，更多的是要发挥优势，扬长避短。这里再给你分享一个发挥优势的故事。
+
+小 B 是一个测试小伙伴。刚进职场时，她总觉得自己是个小透明，技术没有优秀到出类拔萃，性格也比较低调。但渐渐地，她发现自己在带项目上似乎很有心得，她负责的项目很少延期，她总能有条不紊地把各种事情推行到位。有一次，她作为一个 100+ 人的大型项目的负责人，最后这个项目完美交付，而且大家都还干得挺开心的。
+
+这时候她才意识到，相比去做技术难题的攻关，她明显更擅长做项目的推进协调，能更好地理解业务，后来她也顺理成章地成了测试经理。
+
+事实上，职业发展每个人的路径可以不一样，完成一件事情的方式也有很多，所谓“条条大路通罗马”，就是这个道理。
+
+不过，我们在扬长避短的同时，还要关注两个事实。
+
+首先，**避免限制性短板**。木桶理论你肯定知道，所以，不要让短板阻碍自己的发展。按照盖洛普优势理论，虽然我们有不同的天赋，但大多数能力都是可以培养的。比如我在第 15 节里提到的沟通表达，很多技术人是因为性格内向，这方面历练太少，其实做到 90 分可能很难，但做到 60 分的成本没那么高，花点时间都可以做到。
+
+其次，**避免优势过度发挥**。硬币都有两面，过度发挥优势，优势就会变成自己的盲区。比如咱们技术人都擅长思考，但想得太多，也许就会导致下场验证得太少，在这个不确定性极高的时代，就成了咱们的困局了。
+
+## 不是技术大牛，怎么规划职业发展？
+
+现在，咱们回到这节课最开始的问题，如果不是技术大牛，是不是职业发展的天花板很低？
+
+首先，你要**澄清自己对于技术大牛的理解**，想想自己是不是被技术大牛的刻板印象给束缚了？是不是只关注了技术能力的成长？如果是，请回到第 13 节好好复习一下。
+
+我反复说过，技术是打底，如果你不指望成为技术专家，那完全可以在技术上做到 80 分的水位，大面的技术问题都知道，可能具体细分场景不是最专业的，但一定要知道如何调用资源去解决问题，花更多精力历练综合能力，往复合型人才发展。
+
+其次，你可以**发挥优势，走差异化路线。**还是给你讲个故事。小 C 大学学校一般，毕业后做底层算法研发，他发现自己的算法建模能力确实不如周围一群名校毕业的同学，最主要的是“真的没那么感兴趣，研究不下去”，他很苦恼长远的职业发展路线。
+
+我们通过盖洛普优势测评和沟通，发现他虽然在技术深度上不占优势，但综合能力非常不错。他总能很好地理解产品和业务的问题，所在的业务有时候也会要求他直接面对客户，但自己与周围其他人来相比，更很好地与客户对话，解决他们的问题。
+
+梳理这些细节之后，他给自己确定的发展目标是走差异化路线，往综合型人才发展。所以他从原来的底层算法团队转岗出来，正好公司有一条创新业务线要做，他就转岗过去做产品和研发的复合型岗位工作了。显然，这个工作他干得得心应手。
+
+从更长远的发展来看，小 C 希望自己能独立创业，为了实现自己的目标，也在发挥自己“影响力”的优势，工作之余修了 MEM（工程学硕士），不但能提升能力，更能帮助自己破圈，认识更多优秀的人。不到 30 岁的小 C，虽然未来的职业发展之路还很长，但在当下，他知道自己在稳步地积累着自己的能力。
+
+如果你真的觉得技术的工作非常不适合自己，特别消耗，那你也完全可以转岗。我的一个朋友刚工作时，被 Leader 批评写代码太慢了。刚好公司有项目交付，她就尝试去做项目经理，发现相比写代码，自己更擅长做项目管理，就继续在这条路上深耕。从技术团队的项目管理，到公司业务流程的梳理，后来也做到了独角兽公司的高管，完美走出了很多人羡慕的职业发展路径。
+
+一定要记住，技术大牛不是唯一的发展之路，每个人可以有不同的选择，结合自己的优势，在具体的“场景 - 角色 - 目标”中去找到自己的最优解就是王道。
+
+## 小结时刻
+
+这一节我用盖洛普优势工具带你认识了每个人的独特性，给你分享了职业发展中找准自己优势，扬长避短的方法。
+
+职业发展从来没有刻板的标准路径，无论是心中的榜样人物，还是身边的真实案例，都只是你的参考答案。具体到每个人的职业发展上，我们还是要回到自身优势，走出属于自己的路。技术人的职业发展也不只有技术大牛一条路，还有很多种选择。
+
+说到这里，如果你还是因为自己不能成为技术大牛而耿耿于怀，我可以分享自己走过的路，可能能给你一些启发。
+
+2008 年硕士毕业的我，满脑子都是“技术改变世界”的梦想，想进 Google，算法不行没进去，就进了中国的 Google——百度。那个时候的百度技术怪咖特别多，拿我们组来说，有聚餐时带着打印的最新技术 Paper 的师兄，有据说大学、研究生期间把北大图书馆计算机相关书都看完的大牛，吹没吹牛不知道，但日常工作中，无论是前端 JS、后端开发、MySQL 优化还是 Linux 内核，从来没被问倒过。被这样一群技术大牛环绕，我有了深深的技术大牛情结。
+
+工作的前五年，我都特别希望自己成为技术大牛，可做的总是业务研发。好几次想转岗去做搜索底层，去做基础架构，总是未能如愿。死磕很多年之后，我发现自己根本不是“技术大牛”的料，比如缺乏极客精神，这个不是靠练出来的，得骨子里本来就对技术非常有热情。于是，我重新去认识自己的优势，也开始从刻板的技术大牛印象中走出来。
+
+现在回看自己的职业发展之路，一个女生在性别比例 6:1，甚至 10:1 的行业里，不是什么技术大牛，性格还有些劣势——又倔又敏感，能做到大厂总监，最多带过 150+ 人的团队，除了时代红利，**我做对了一件事，那就是发挥优势。**
+
+在一线的时候，我不是技术最牛的，但是合作能力很不错，就是用到前面提到的学习 + 复盘能力，打好技术的基本功。
+
+带团队时，我性格内向，学不了别人打鸡血，与团队打成一片。但是踏实做好项目，认真培养小伙伴，也带出了一支能打硬战，信任度很高的团队。
+
+我嘴笨，一直害怕公开演讲。但我知道自己一对一的沟通表达能力不错，能把复杂问题讲明白，于是发挥了这个优势去技术大会演讲，不讲高大上的道理，只讲自己的实践思考，居然第一次就获得了非常多的点赞。
+
+当职业发展出现巨大瓶颈时，我再次回到了自己的优势，深知自己的优势是热情和助人，于是自己打破天花板，出来自己干。别人担心 35 岁危机，而我坚信只要身体允许，我的工作可以干到 80 岁。未来我会继续在发挥优势的路上，一路狂奔。
\ No newline at end of file
diff --git a/docs/md/career/performance-review-guideline.md b/docs/md/career/performance-review-guideline.md
new file mode 100644
index 000000000..0768de512
--- /dev/null
+++ b/docs/md/career/performance-review-guideline.md
@@ -0,0 +1,193 @@
+# 晋升必备！打造完美述职报告，助你脱颖而出！
+
+## 0 你的问题，我知道！
+
+谁都想晋升，但晋升述职又属研发最薄弱。
+
+很多研发聊咋写优雅代码，设计高并发系统，信手拈来，但听到写晋升材料，就抓耳挠腮。有的小伙伴甚至说，太痛苦了，写PPT比通宵加班一周还累。
+
+可职场述职汇报是基础且重要能力。光说不干假把式，光干不说傻把式。不掌握它，只埋头苦干，不会述职汇报，就傻把式！
+
+一年累死拿到好绩效，能力也打磨好，老板给晋升提名机会，结果临门一脚，栽在晋升述职？
+
+## 1 常见问题
+
+### 1.1 流水账
+
+最常见，即平铺直述，罗列做的项目。如“我过去做了 10 个项目，第一个 A 项目，第二个 B 项目……”，以为丰满，但在评委眼里一地散沙。
+
+### 1.2 显微镜
+
+为显示自己做的模块复杂，整出超复杂流程图，唾液横飞讲，评委早云里雾里。大多数这种图，都是代码“翻译”过来。
+
+### 1.3 充门面
+
+为让述职材料有技术含量，各种热门词汇、术语满天飞。听半天不知到底解决啥高大上问题。
+
+你说 PPT 太虚，就是形式主义，但很多人讲不清，是你根本没想清晋升述职目的。很多人答辩被评委问得答不上，要不：
+
+- PPT逻辑有漏洞
+- 日常根本没有思考过这些问题
+- 思考层次很浅，临时凑数
+
+如你在准备述职材料时想清楚，就能说明白。
+
+## 2 一个模型—证明题
+
+《高效人士的七个习惯》关键一条：
+
+![](https://p.ipic.vip/2tyryo.png)
+
+以终为始，先思考
+
+### 2.1 晋升述职目的
+
+我也不想写，这不是领导要求？换位思考，在资本家角度看晋升。晋升本质是企业为了未来选拔人才，就是选拔谁牛。
+
+述职就是做证明题，证明你牛，是公司需要的人才。不但战功累累，还积累超绝能力，未来还能打大仗。
+
+### 2.2 证给谁？
+
+晋升的评委们！
+
+Q：评委是啥人？
+
+A：比你职级高，一般+2。且为保证公平，大多是其它部门人。
+
+Q：这些评委啥特征？
+
+A：能力比你强。他们对你的部门不熟悉，你要向一群半熟悉的、能力比你强的人，做证明你优秀的证明题。
+
+证明题咋做？
+
+### 2.3 证明题的背景
+
+做好“导游”。评委都是半熟之人，所以述职前要交代些背景，即先做“导游”，讲清我是谁、我在做啥。
+
+“我是谁”简单，说清工作履历。
+
+“我在做啥”大多研发易出问题。很多人说我做 XX 系统，然后立即进入项目细节。这是让听众犯晕最快手段。你天天跟这些系统、代码交互，但评委不了解细节。
+
+所以，要把“我在做啥”说清，讲清你做的事在公司、部门、大系统的位置，先让听众找到你“坐标”。如你做交易中心，画个全景图，用户下单流程中，哪些会走交易中心，多少服务强依赖你，每天并发量多少等……
+
+证明你做的系统地位重要，你一抖，整个系统都得跟你抖。
+
+厉害“导游”不只讲景点古今，还强调景点多**独特**：
+
+- 系统价值，也考验你对业务理解。如服务接入层，它与其他内部系统相比，不一样的挑战来自它是服务的外层，需要具备防攻击的能力、负载均衡的能力。比如做金融系统，与一般的新闻网站系统，具备金融属性，需超强一致性
+- 你自己在这系统角色，从 0 到 1 负责的？还是主程？或“救火队”？表达清楚，因不同角色体现价值也不一
+
+### 2.4 证明题的主体
+
+通过你做的这些事证明你优秀，能力是达到下个职级标准。
+
+推荐时间轴组织：做前、做的过程、做后的结果。
+
+#### ① 做前：多烂
+
+证明牛，要有对比，即做前和做后，所以先把做前，即起点讲清。要客观，不甩锅，但也不过度谦虚。
+
+一般可能说起点多低，最开始系统有多少问题。可能技术层如：
+
+- 接口性能差，单接口耗时有时几s
+- 系统服务容灾多低级，一个误操作就可能宕机
+- 代码结构不理想，新人不敢改代码，一改就线上事故
+
+也可能业务层，因系统不好:
+
+- 每天造成多少客诉
+- 带来 GMV 损失
+- ...
+
+有系统并非烂，只随业务发展面临新挑战。如有性能瓶颈，那高峰期接口耗时、失败率多少？也可能是原来的系统设计过于简单，无法满足当下业务的发展需求，需要做很多新的兼容性设计，可能要抽象底层模型，甚至要做重构。这个时候就要讲清楚你要优化重构的部分是什么，与其它模块错综复杂的关系是什么？如果涉及部分重做数据，那数据量有多大，重做数据面临哪些风险等等，都要说清楚。
+
+你可能会问如果是从 0 到 1，那起点是个 0，怎么对比呀？其实从 0 到 1 本身就是很难的，所以讲清楚业务场景是什么，业界是如何解决的，我们当下面临的不同挑战有哪些，就可以了。
+
+“做前”就是给听众一个宏观印象，觉得这事真难，为下步你的方案铺垫。
+
+#### ② 做的过程：很难，我如何一步步解决
+
+铺垫困难后，咋解决这些困难，咋优化。就是研发最擅长环节，最能彰显技术实力。
+
+拿出系统设计图（而非详细流程图），讲清为啥这么设计，有啥权衡？为啥做这些考虑？针对一些痛点，你的思考是啥？咋从根本解决？再讲具体实现思路。
+
+注意讲清解决过程，而非直接给标准答案。发现问题、分析问题、解决问题的过程，才真正体现能力。评委也能从中判断你是否真正理解这类问题，还是道听途说个方案，从而判断你对问题自己的思考深广度，是否具备举一反三能力，未来是否能有更好发展前景。
+
+若解决问题有很多难点，无需一一展开，找一两个最体现技术能力点，讲清、讲透。晋升述职是为“秀肌肉”，展现能力，勿贪多和重复证明。
+
+#### ③ 做后：对比多明显
+
+成果展示：
+
+- 业务结果，收入增加几？成本降低几？核心转化率指标提升几？
+- 技术结果，扩展更强架构？性能更好模块？想办法找到前后对比数据支撑，如你做个长连接解决消息到达问题，那之前消息丢失率几？做后几？
+
+### 2.5 证明题的“升华”
+
+完全可按证明题思路去挨个介绍你的重要项目，讲述你的丰功伟绩，还有做这些事情的过程中你积攒的能力。
+
+再升华，证明通过这些事，自己能力得到了提升，还可做更多事。如：
+
+- 对当前事情长远规划
+- 或这些经验可以推广到哪些问题解决
+
+潜台词告诉老板，你看，我不只把活干完，对未来、团队还有思考。
+
+证明题晋升述职模型：
+
+![](https://p.ipic.vip/0ge0gv.png)
+
+结构清晰、数据充分、还有未来长远思考！
+
+## 3 晋升在日常
+
+### 3.1 全局意识
+
+知道自己的模块在整个系统中的位置，模块独特的价值，你可以为目标做些什么。如果你日常完全没有思考过这些，单靠晋升述职的冲击是很难有效果的，因为你日常并没有用全局思考的角度指导你的工作方向。
+
+### 3.2 数据运营意识
+
+你需要时刻清楚自己系统的关键数据，包括业务数据和技术指标的数据，清晰知道如何通过技术手段去优化。如果你光是埋头苦干，完全没有数据思维，没有用数据去驱动你工作的改进，也很难有清晰的数据对比，更难得出未来的优化方向。
+
+### 3.3 工作汇报
+
+我活干得还可，但不会说，晋升总吃亏。日常练习过和不熟悉的人介绍工作内容吗？
+
+你学习写代码，4年大学，3年研究生，再工作，咋也得10年才勉强出师。写代码这事你学习 + 实践花近10年。而最基础述职呈现你花多久？凭啥不练，到关键时觉得你应该会？
+
+述职汇报是职场基本功，跟写代码一样，都是基础能力。如果你觉得自己这方面很差，就多练习，如多给团队做分享，把听众当评委，用述职汇报思路做，看自己这方面能力是否明显提升？
+
+## 4 总结
+
+晋升述职是给评委们做一道“我的能力已经达到下个层级”的证明题。
+
+先澄清自己做的系统在整个系统位置、重要性和独特性，还有你的角色。
+
+再做前 - 做的过程 - 做后组织你的述职材料，陈述清楚你的工作最开始多么艰难，遇到多少挑战，咋一个个打怪升级。
+
+最后有清晰结果呈现，证明你拿到的结果显著。而且在这些结果之上，你的能力还得到了大幅的提升，还可以做更多的事情。
+
+这个“证明题”工具不但可以用来准备晋升述职，还可以用来指导你的日常工作，时常提醒自己抬头看路，要有全局视角，用数据驱动工作。更重要的是，你要把述职汇报真正当做一个职场的基本能力，就像你练习写代码一样，花时间去练习你的肌肉，才能真正提升。
+
+技术人需要的能力远远不只有技术能力，还有非常多综合能力，别偏科。职业发展既扬长避短，也规避木桶效应。优秀研发，技术难题都能搞定，简单述职何难？日常功夫深，才能真正“干好，也说好”。
+
+## 5 FAQ
+
+Q：用“证明题”思考下你当下的工作，你的工作在系统中的价值是什么？如果有述职机会，你会如何来体现？
+
+A：项目一：一个新项目从 0 到 1，业务做的是银行核心系统：
+
+- 难点 1：团队内没有真正懂银行业务的人
+- 难点 2：跟传统银行业务又不同的业务模型（用户、客户、账户）
+- 难点 3：在倒排期的展业 ddl 下保证代码质量和需求快速迭代
+- 难点 4：依赖系统的文档和流程不明确，需要自己不断试错确定
+
+可以试着分下类，比如合作上的挑战，项目排期的挑战，另外建议增加一些技术上的难点，银行核心系统对比一般的业务系统会有哪些不一样的挑战？你是如何解决的？比如银行系统一般对数据准确性要求极高，这方面你是如何考虑的。
+
+给CEO汇报思路差不多。 讲清工作在全局位置，你的独特价值，即“当导游”部分。年底汇报如面向更高级老板，需落到老板关注的，一般无非收益、成本、效率等。 
+
+再分版块去介绍咋做的，解决啥挑战。规划部分结合公司的OKR，看你在这框架内贡献及前面做的工作一定会有待提升的点。
+
+也适用于面试哦！
+
+技术分享！
\ No newline at end of file
diff --git "a/docs/md/career/02-\344\270\272\344\273\200\344\271\210\344\270\255\345\233\275\347\232\204\347\250\213\345\272\217\345\221\230\346\234\21135\345\262\201\345\215\261\346\234\272.md" "b/docs/md/career/\344\270\272\344\273\200\344\271\210\344\270\255\345\233\275\347\232\204\347\250\213\345\272\217\345\221\230\346\234\21135\345\262\201\345\215\261\346\234\272.md"
similarity index 100%
rename from "docs/md/career/02-\344\270\272\344\273\200\344\271\210\344\270\255\345\233\275\347\232\204\347\250\213\345\272\217\345\221\230\346\234\21135\345\262\201\345\215\261\346\234\272.md"
rename to "docs/md/career/\344\270\272\344\273\200\344\271\210\344\270\255\345\233\275\347\232\204\347\250\213\345\272\217\345\221\230\346\234\21135\345\262\201\345\215\261\346\234\272.md"
diff --git "a/docs/md/career/\347\240\224\345\217\221\347\232\204\347\253\213\350\266\263\344\271\213\346\234\254\345\210\260\345\272\225\346\230\257\345\225\245\357\274\237.md" "b/docs/md/career/\347\240\224\345\217\221\347\232\204\347\253\213\350\266\263\344\271\213\346\234\254\345\210\260\345\272\225\346\230\257\345\225\245\357\274\237.md"
new file mode 100644
index 000000000..83c23a700
--- /dev/null
+++ "b/docs/md/career/\347\240\224\345\217\221\347\232\204\347\253\213\350\266\263\344\271\213\346\234\254\345\210\260\345\272\225\346\230\257\345\225\245\357\274\237.md"
@@ -0,0 +1,156 @@
+# 研发的立足之本到底是啥？
+
+## 0 你的问题，我知道！
+
+本文深入T型图“竖线”的立足之本：专业技术 + 技术赋能业务能力。研发在学习投入精力最多，也误区最多。
+
+某粉丝感发展遇到瓶颈，项目都会做，但觉无提升，想跳槽。于是，梳理过往经历。
+
+他觉得业务小，阻其技术发展。但细问，这系统用户量百万级，一点不小，只是淡季、旺季明显。旺季时常卡死、提交延迟。
+
+你这核心系统主程，咋看待这问题，啥优化思路？他皱眉说不出。我看他还做过重构
+
+Q：系统为啥重构？
+
+A：原框架太老，现在大家都用新框架。而重构的收益，说不透……
+
+这是典型只看到技术能力最表层技能，觉得会编程，做需求开发上线就够。但研发硬技能不止于此。
+
+## 1 专业技术能力
+
+如用冰山模型形容，更多藏在冰山下“看不见能力”。如Javaer日常Java编程，会用编程工具如IDEA，还会Linux命令，知道后端必备MySQL、Redis、MQ的API咋调，还能遵循编码规范和稳定性要求……看得见能力。
+
+但更多看不见能力藏在山下。很多 JVM 原理，数据库原理等很多知识和能力需具备。
+
+![](https://p.ipic.vip/wuriyg.png)
+
+若研发仅注意力放在冰山上，大概率会：
+
+- 很快沉溺瓶颈。觉得每天就CURD，没成长。若研发完全不懂设计原理，不懂咋写好代码，其环境也无好设计和CR机制，长久以往，系统成“垃圾山”，技术债越垒越高，完全无法维护。《代码整洁之道》说“不管你多敬业加班，面对烂系统，仍寸步难行，因你大多精力不在开发需求，而是应对混乱”。
+- 变成定制螺丝钉。若你在大厂，会发现大部分底层服务如Redis、MQ有专人维护，他们还在上面定制开发。如把它们全当黑盒，出问题就找接口人，也非不可。但硬伤是协作成本高，而且你真变“螺丝钉”，“定制的螺丝钉”，只能在特定体系下生存，换个系统可能就“拧不上”
+
+个人职业发展角度，若研发专业技术能力仅专注“山上”，就真是个“搬砖”。越在冰山之上的能力越简单、门槛低，越底层能力，鲁棒性越强：
+
+- 曾经团队技术栈更换，从PHP全部重构为Java。之前PHP技术栈不错的，几月语言熟悉，在 Java技术栈仍不错。作为后端开发，难在网络通讯、存储、MQ、系统设计、故障排查等更底层经验积累。语言学不难，智商正常2周入门，后续只是需熟悉
+- 前端常抱怨前端技术更新迭代太快，学不过来。而从业15年前端大佬指出前端工作本质：前端交付用户使用体验，而使用体验核心在交互。前端要多花时间了解交互及背后渲染，理解底层CPU、GPU渲染原理，弄清标准化端容器（如浏览器）工作原理。
+
+因此，为让技术成长之道更长，让“兼容性”更高，能解决更复杂问题，适配更多样环境，要更关注冰山下技术，“往下沉”。
+
+### 下沉方向
+
+Javaer往3方向，可大提升技术深度。
+
+#### 语言深钻
+
+底层及高级玩法。
+
+能日常基础需求开发后，再深入掌握更高级使用。如了解JVM原理，知道Java系统调优方法，让服务更轻盈。
+
+> 99%程序员一辈子没机会写JVM代码，但研发仍需了解技术底层实现原理，因为这是你解决难题、为企业创造价值前提。也是延长职业赛道的唯一有效途径；更是面试必问！
+
+#### 周边服务
+
+与你日常工作息息相关的底层服务原理。
+
+如：
+
+- MySQL了解透彻数据库引擎、事务、索引等底层原理
+- MQ清楚底层实现，了解常用MQ，技术选型时知啥场景选啥
+
+熟悉这些最基础内容，是为日常工作出现问题、故障时可高效应对，更重要的是你的工作域变大，不再一群黑盒。
+
+#### 系统设计
+
+常见设计原理、应用、经典场景的设计。
+
+研发专业能力的成长：刚开始仅开发小功能，到维护模块，再到子系统，甚至一个业务域系统。系统设计能力就关键了。需将相应设计原理，具体应用方法，还有经典场景设计思路都搞透。
+
+如了解高可用系统架构设计原理和实践，你就对公司这样那样“稳定性红线要求”更深理解，甚至主动思考自己做的模块强依赖、弱依赖啥服务？如需降级，咋设计？
+
+当你了解语言底层、底层服务原理及系统设计，你就把自己“技术世界”撑大，也给自己发展打下更坚实基础。若很有技术热情，愿研究新技术，地盘稳定后，学习速度也会加快。
+
+## 2 技术赋能业务能力
+
+专业技术往下渗透，了解底层原理相当于研发工作的“微观环境”撑大，进一步，就要去理解技术周围系统。技术作为工具要回到真实场景衡量价值。
+
+### 2.1 技术和业务啥关系？
+
+技术技能好比一个锤或锯，业务好比要做一张桌。做张桌很多工序，需设计，需锯木，需锤钉，需打磨，需抛光，可能还需营销推广……
+
+若看不到桌全貌，就难知啥时需用锤，要锤几次，咋锤才更精准。即业务研发价值绝不仅代码写多好、无Bug、接口TPS多厉害，还看到底用技术解决多少业务问题，带来多少业务增量，给客户创造啥价值。完全不了解业务时，空谈技术就耍流氓，空中楼阁不长久。
+
+很多研发把自己发展只定义在专业技术能力，这是惯性。职场初期，工作要求被定义很清晰，这是公司高层和各级管理者定义。如电商商家端团队要找个Javaer，那电商系统划分，如用户、交易、商家端等框架划分，还有整系统具体要承接功能、解决问题，甚至解决问题方式及对这岗位考核，都是提前定义好，只是需人“填坑”。
+
+我们要做的，就是从“坑”走出。到一定年龄，给企业的价值更多是在一些不确定、不清晰事，去定义啥是有价值，从而定义自己的工作。就像刚开始有锯、有锤，那做桌时咋用这些工具？
+
+就是“咋用”，去定义这些事，是更大价值所在。研发想发挥更大价值，追求自身长远发展，除技术本身技能，须懂技术赋能业务。
+
+### 2.2 咋技术赋能业务？
+
+#### ① 了解业务
+
+要理解商业价值，如清楚当前业务重要指标，要达成需解决啥问题，啥可技术手段解决？如企业用OKR做技术管理，那就是业务重要的O。
+
+#### ② 定义问题
+
+当你找到要解决的问题，就要把这业务问题转为技术问题。
+
+#### ③ 解决问题
+
+研发最擅长，技术手段解决问题。
+
+#### ④ 数据回证
+
+提前做好数据埋点，通过数据统计论证最开始设想，检验是否真正解决问题？啥收益？
+
+### 2.3 实战
+
+他客户端研发，所在部门负责外卖物流配送系统，即管理和调度外卖配送员。随外卖发达，公司越重视骑手安全，今年业务有考核指标关于骑手配送过程事故率。如配送1万个订单，出现交通事故率控制多少。你会咋做？
+
+#### ① 了解业务
+
+想想骑手配送事故，和啥相关？
+
+可能跟对骑手考核相关，如：
+
+- 要求30min送达，不过这是业务运营规则，跟市场环境相关，技术干预少
+- 可能和调度系统相关，如给骑手派太多单或不顺路，导致骑手赶时间，不得不超速，甚至闯红灯，造成交通事故。这是调度算法团队解决议题，客户端研发参与感少
+
+没法了？但他线下调研骑手配送。发现很多骑手送餐过程，一只扶把手，一只刷手机，因为可能来新订单，而骑手要抢单。这过程增加事故发生率。可用技术解决？可！用语音交互，这就是技术助业务提升点。
+
+#### ② 定义问题
+
+将业务问题转化为技术问题。刚才就是语音交互系统问题。但回到业务场景，不够精准：
+
+- 骑手配送在户外，快速移动、无稳定电源，耗电量是问题
+- 配送过程环境声音嘈杂，有的地方可能网络环境还差
+
+所以，问题进步精准定义为需低功耗，弱网、噪音环境可用语音交互系统。
+
+精准定义问题后，技术手段解决问题的第三步就不难。
+
+最后，第四步数据回证。可能AB测试，对比上线前后期骑手事故率的变化，用数据证明收益。
+
+这就是技术赋能业务的完整闭环。
+
+## 3 总结
+
+本文讨论研发硬技能。专业技术能力，不仅得编程，排查问题，更需深钻，知其然，知其所以然，不断打磨技术。还不够，还得把技术放现实去用，历练不同场合“炫技”能力，即用技术赋能业务。
+
+职业发展角度，专业技术能力、技术赋能业务能力是研发岗的根本，是更好发展的基础。抛开这些，技术能力还帮历练好的抽象能力和务实精神。
+
+互联网是把现实搬到线上，那这“搬”就是靠研发把现实抽象成线上的数据结构、对象、模块和系统来实现。系统设计、编码过程，就是历练从现实的“现象”抽丝剥茧，提炼本质的能力。
+
+代码界不容虚头巴脑，手抖写错字符，就能让庞大系统轰然倒塌。要求极度精准工作磨炼下，大多研发就很务实，能静下和深扎，能啃硬骨头。这种抽象复杂事物本质的能力以及极其务实的精神，都是职业发展能航行更远的燃料。
+
+## 4 FAQ
+
+Q：研发咋在专和通之间保持合理平衡？
+
+A：无比例，个人经验根据自己工作阶段、当下工作需要和兴趣综合判断。
+
+如工作前几年，定以专为主，至少一个技术栈做到熟悉，解决工作中大部分问题，当你在一个领域深钻后，深度会帮助更好做广度。
+
+而当你工作五六年，很多基本面技术已掌握，可适当拓展广度。同时结合当前工作需要，这里面最基础逻辑是技术所有的东西光学很难掌握，要有好的历练场所。如根据工作的需要，针对性拓展广度和精钻深度，又能回到工作中运用是最好的闭环。 
+
+最后是兴趣，如对某方向感兴趣，也会帮助你在广度或深度拓展。 所以无绝对比例，或者这个平衡，是根据你工作的阶段、工作场景的需要和你自己的兴趣来动态调整的。
\ No newline at end of file

From e13a372fe1c888e2e66015d76b02861496492b41 Mon Sep 17 00:00:00 2001
From: JavaEdge <sss2855845850@gmail.com>
Date: Tue, 4 Feb 2025 23:09:53 +0800
Subject: [PATCH 04/20] =?UTF-8?q?docs:=E6=9B=B4=E6=96=B0=20dify=20?=
 =?UTF-8?q?=E4=B8=93=E6=A0=8F=E5=86=85=E5=AE=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/.vuepress/config.js              |   2 +
 docs/md/AI/llm/Build-App-with-Dify.md | 225 ++++++++++++++++++++++++++
 docs/md/rpc/RPC-Traffic-Replay.md     | 139 ++++++++++++++++
 3 files changed, 366 insertions(+)
 create mode 100644 docs/md/AI/llm/Build-App-with-Dify.md
 create mode 100644 docs/md/rpc/RPC-Traffic-Replay.md

diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index 3f3a0fe9d..0ba7afdb6 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -1134,6 +1134,7 @@ module.exports = {
                             "04-RPC框架在网络通信的网络IO模型选型",
                             "熔断限流",
                             "11-RPC的负载均衡",
+                            "RPC-Traffic-Replay",
                         ]
                     }],
 
@@ -2162,6 +2163,7 @@ module.exports = {
                             sidebarDepth: 0,
                             children: [
                                 "what-is-llmops",
+                                "Build-App-with-Dify",
                                 "integrate-dify-and-aws-services-to-enable-more-flexible-translation-workflows",
                             ]
                         },
diff --git a/docs/md/AI/llm/Build-App-with-Dify.md b/docs/md/AI/llm/Build-App-with-Dify.md
new file mode 100644
index 000000000..6e6d26830
--- /dev/null
+++ b/docs/md/AI/llm/Build-App-with-Dify.md
@@ -0,0 +1,225 @@
+# 基于DIFY快速构建应用
+
+## 0 前言
+
+Dify的一个“应用”指基于LLM构建的实际场景应用。通过创建应用，可将智能 AI 技术应用于特定的需求。它既包含了开发 AI 应用的工程范式，也包含了具体的交付物。
+
+一个应用为开发者交付：
+
+* 封装友好的 API，可由后端或前端应用直接调用，通过 Token 鉴权
+* 开箱即用、美观且托管的 WebApp，你可以 WebApp 的模版进行二次开发
+* 一套包含提示词工程、上下文管理、日志分析和标注的易用界面
+
+可任选**其中之一**或**全部**，来支撑你的 AI 应用开发。
+
+## 1 应用类型
+
+Dify提供如下应用类型：
+
+* **聊天助手**：基于 LLM 构建对话式交互的助手
+* **文本生成**：构建面向文本生成类任务的助手，例如撰写故事、文本分类、翻译等
+* **Agent**：能够分解任务、推理思考、调用工具的对话式智能助手
+* **工作流**：基于流程编排的方式定义更加灵活的 LLM 工作流
+* chatflow：支持记忆的复杂多轮对话工作流
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/ae7b2cfd247d3612986fbf637a02858a.png)
+
+### 文本生成 V.S 聊天助手
+
+| 特性         | 文本生成              | 聊天助手        |
+| ------------ | --------------------- | --------------- |
+| WebApp 界面  | 表单+结果式           | 聊天式          |
+| WebAPI 端点  | `completion-messages` | `chat-messages` |
+| 交互方式     | 一问一答              | 多轮对话        |
+| 流式结果返回 | 支持                  | 支持            |
+| 上下文保存   | 当次                  | 持续            |
+| 用户输入表单 | 支持                  | 支持            |
+| 知识库与插件 | 支持                  | 支持            |
+| AI 开场白    | 不支持                | 支持            |
+| 情景举例     | 翻译、判断、索引      | 聊天            |
+
+## 2 创建应用
+
+3种方式在 Dify 的工作室内创建应用：
+
+* 基于应用模板创建（新手推荐）
+* 创建空白应用
+* 通过 DSL 文件（本地/在线）创建应用
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/d40a5470860eca6aa1cfb7419270249a.png)
+
+### 2.1 从模板创建应用
+
+为帮助新手用户快速了解在 Dify 能构建啥应用，Dify 团队提示词工程师已创建多场景、高质量的应用模板。
+
+任意选择某个模板，并将其添加至工作区即可。
+
+### 2.2 创建一个新应用
+
+如需在 Dify 创建一个空白应用，Dify可创建不同应用类型：
+
+给应用起一个名字、选择合适的图标，或者上传喜爱的图片用作图标、使用一段清晰的文字描述此应用的用途，以便后续应用在团队内使用。
+
+![](https://assets-docs.dify.ai/2024/12/1429eb56e0082c281f7aaeb48e72cb0f.png)
+
+### 2.3 通过 DSL 文件创建应用
+
+Dify DSL 是由 Dify.AI 所定义的 AI 应用工程文件标准，文件格式为 YML。该标准涵盖应用在 Dify 内的基本描述、模型参数、编排配置等信息。
+
+#### 本地导入
+
+如从社区或其它人获得一个应用模版（DSL 文件），可从工作室选择 「 导入DSL 文件 」。DSL 文件导入后将直接加载原应用的所有配置信息。
+
+#### URL 导入
+
+你也可以通过 URL 导入 DSL 文件，参考的链接格式：
+
+```url
+https://example.com/your_dsl.yml
+```
+
+> 导入 DSL 文件时将校对文件版本号。如果 DSL 版本号差异较大，有可能会出现兼容性问题。
+
+## 3 聊天助手
+
+对话型应用采用一问一答模式与用户持续对话。
+
+### 3.1 适用场景
+
+客户服务、在线教育、医疗保健、金融服务等领域。这些应用可以帮助组织提高工作效率、减少人工成本和提供更好用户体验。
+
+### 3.2 咋编排？
+
+对话型应用的编排支持：对话前提示词，变量，上下文，开场白和下一步问题建议。
+
+以 **面试官** 应用为例。
+
+#### 3.2.1 创建应用
+
+填写应用名称，应用类型选**聊天助手**：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/3c087c52d42ab4c5bf8332a0c69d66b5.png)
+
+#### 3.2.2 编排应用
+
+创建应用后会自动跳转到应用概览页。点击左侧菜单 **编排** 来编排应用。
+
+##### ① 填写提示词
+
+提示词用于约束 AI 给出专业回复，让回应更精确。示例：
+
+1. 输入提示指令，要求给出一段面试场景的提示词
+2. 右侧内容框将自动生成提示词
+3. 你可以在提示词内插入自定义变量
+
+可借助内置提示生成器，如下点击生成：
+
+![](/Users/javaedge/Downloads/IDEAProjects/java-edge-master/assets/image-20250204213510811.png)
+
+红框内输入你的提示词，再点击生成即可，右边即是优化后的提示词：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/076d30028c80ba2c4d2c18cd639f8d01.png)
+
+提示词内支持插入表单变量，如 `{{input}}`。提示词中的变量的值会替换成用户填写的值。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/623d4d1158b31cd532453299d2b12ffc.png)
+
+为更好用户体验，可以加上对话开场白，点击右下角【管理】：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/015f2828146f7522e26cf2e79efb72f9.png)
+
+可选增强功能如下：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/bd66ecd8db59f8f15aaaf677d6668e56.png)
+
+编辑开场白即可：`你好，{{name}}。我是你的面试官，Bob。你准备好了吗？`。
+
+> 可添加数个开场问题。
+
+##### ② 添加上下文
+
+如果想要让 AI 的对话范围局限在【知识库】内，例如企业内的客服话术规范，可以在“上下文”内引用知识库。
+
+##### ③ 添加文件上传
+
+部分多模态 LLM 已原生支持处理文件，如 [Claude 3.5 Sonnet](https://docs.anthropic.com/en/docs/build-with-claude/pdf-support) 或 [Gemini 1.5 Pro](https://ai.google.dev/api/files)。你可以在 LLM 的官方网站了解文件上传能力的支持情况。
+
+选择具备读取文件的 LLM，开启 “文档” 功能。无需复杂配置即可让当前 Chatbot 具备文件识别能力。
+
+![](https://assets-docs.dify.ai/2024/11/823399d85e8ced5068dc9da4f693170e.png)
+
+#### 3.2.3 调试
+
+在右侧填写用户输入项，输入内容进行调试。先输入变量 jobName 值为后端开发，开始激聊：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/89df43f43bd3880db673e425d4c893fa.png)
+
+如果回答结果不理想，可以调整提示词和底层模型。你也可以使用多个模型同步进行调试，搭配出合适的配置：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/c659c34c52b218d8c0a3fa3239daa80b.png)
+
+**多个模型进行调试：**
+
+如果使用单一模型调试时感到效率低下，你也可以使用 **“多个模型进行调试”** 功能，批量检视模型的回答效果。最多支持同时添加 4 个大模型：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/d4304880c23db83baae3e8c7def92008.png)
+
+> ⚠️ 使用多模型调试功能时，如果仅看到部分大模型，这是因为暂未添加其它大模型的 Key。
+
+#### 3.2.4 发布应用
+
+调试好应用后，点击右上角的 **“发布”** 按钮生成独立的 AI 应用。
+
+##### ① 发布为公开 Web 站点
+
+发布一个可供用户在互联网上公开访问的 Web 应用，该应用将根据你的 Prompt 和编排设置进行工作。
+
+* 自部署的开源版，该应用将运行在你的服务器上
+* 云服务，该应用将托管至网址 [https://udify.app/](https://udify.app/)
+
+***
+
+###### 发布 AI 站点
+
+在应用监测页中，你可以找到 WebApp 的管理卡片。打开访问开关后，你可以得到一个能够在互联网上公开分享的网址：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/1fd67011c778b803cd4de520c1ccbb96.png)
+
+可见，均预置了漂亮的 WebApp 界面。
+
+##### ② 嵌入你的 AI 站点
+
+Dify 支持将你的 AI 应用嵌入到业务网站中，可用该能力在几分钟内制作具有业务数据的官网 AI 客服、业务知识问答等应用。点击 WebApp 卡片上的嵌入按钮，复制嵌入代码，粘贴到你网站的目标位置：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/13e031c88e43bd6396d39a4b877e3cf3.png)
+
+##### ③ 基于 APIs 开发
+
+Dify 基于“**后端即服务**”理念为所有应用提供了 API，为 AI 应用开发者带来了诸多便利。通过这一理念，开发者可以直接在前端应用中获取大型语言模型的强大能力，而无需关注复杂的后端架构和部署过程。
+
+###### 用 Dify API 的好处
+
+* 让前端应用直接安全地调用 LLM 能力，省去后端服务的开发过程
+* 在可视化的界面中设计应用，并在所有客户端中实时生效
+* 对 LLM 供应商的基础能力进行了良好封装
+* 随时切换 LLM 供应商，并对 LLM 的密钥进行集中管理
+* 在可视化的界面中运营你的应用，例如分析日志、标注及观察用户活跃
+* 持续为应用提供更多工具能力、插件能力和知识库
+
+###### 如何使用？
+
+选择一个应用，在应用（Apps）左侧导航中可以找到**访问 API（API Access）**。在该页面中你可以查看 Dify 提供的 API 文档，并管理可访问 API 的凭据。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/a858e4f584fdd457b34947d2eb7da90c.png)
+
+例如你是一个咨询公司的开发部分，你可以基于公司的私有数据库提供 AI 能力给终端用户或开发者，但开发者无法掌握你的数据和 AI 逻辑设计，从而使得服务可以安全、可持续的交付并满足商业目的。
+
+最佳实践中，API 密钥应通过后端调用，而不是直接以明文暴露在前端代码或请求中，这样可以防止你的应用被滥用或攻击。
+
+你可以为一个应用**创建多个访问凭据**，以实现交付给不同的用户或开发者。这意味着 API 的使用者虽然使用了应用开发者提供的 AI 能力，但背后的 Promp 工程、知识库和工具能力是经封装的。
+
+## FAQ
+
+Q：咋在聊天助手内添加第三方工具？
+
+A：聊天助手类型应用不支持添加第三方工具，可在 [Agent 类型](https://docs.dify.ai/v/zh-hans/guides/application-orchestrate/agent)应用内添加第三方工具。
\ No newline at end of file
diff --git a/docs/md/rpc/RPC-Traffic-Replay.md b/docs/md/rpc/RPC-Traffic-Replay.md
new file mode 100644
index 000000000..a76f8d8ac
--- /dev/null
+++ b/docs/md/rpc/RPC-Traffic-Replay.md
@@ -0,0 +1,139 @@
+# 21-重构大杀器！流量回放让线上BUG无处遁形，QA团队集体沉默…
+
+流量：某个时间段内的所有请求，通过手段把发送到A应用的所有请求录制，然后把这些请求统一转发到B应用，让B应用接收到的请求参数跟A应用一致，实现A接收到的请求在B应用里面重新请求了一遍。整个过程即“流量回放”。
+
+## 1 流量回放的意义
+
+经常多需求并行开发，还可能夹杂着应用重构和拆分。基本很难做到不改动老逻辑，只要有改动就可能存在考虑不周。
+
+代码小改动的业务需求，这做法一般不出问题。但对大改动应用，如应用中很多基础逻辑都被改动过，还通过已有Case去验证功能正确性，就很难保证应用上线后不出故障，毕竟我们靠自己维护的Case相对线上运行的真实环境少很多。
+
+会向QA求助，希望他们多加Case。但因改动代码逻辑影响范围大，想圈定一个比较确定的测试范围难，相对保险的是把整个项目都回归测试，最大程度避免上线出问题，但也不是万无一失，因为线上不仅环境复杂，而且使用场景不好评估，这种方式耗时也长。
+
+## 2 更可靠、廉价方案？
+
+传统QA测试出问题的根本原因：改造后的应用在上线后出现跟应用上线前不一致的行为。
+
+测试就是为保证改造后的应用跟改造前应用的行为一致，测试Case也都尽力模拟线上运行行为，但仅通过我们自己枚举测试Case不能代表线上所有行为。因此最好用线上流量验证，但直接把新应用上线肯定不行，一旦新改造的应用存在问题就可能导致线上调用方业务受损。
+
+可先把线上一段时间内的请求参数和响应结果保存，然后把这些请求参数在新改造应用里重新请求，比对改造前后的响应结果是否一致，间接达到使用线上流量测试的效果。
+
+有了线上的请求参数和响应结果后，再结合持续集成，可让改动后的代码随时用线上流量验证。
+
+## 3 RPC实现流量回放
+
+如TcpCopy、Nginx。但线上环境要使用这些工具时，还得找运维团队帮把应用安装到应用实例，再按照你的需求给配置好才能使用，整个过程繁琐而且重复做无用功，有无更好办法？尤其是在RPC情况下。
+
+RPC是用来完成应用间通信，即应用间所有请求响应都会经RPC，那在RPC里是否就能很方便地拿到每次请求的出入参数？拿到这些出入参数后，把它们旁录下来，用异步方式发到一个固定地方保存，就完成流量回放里面的录制功能。
+
+### 咋把这些请求参数转发到要回归测试的应用？
+
+在RPC中，把能接收请求的应用叫服务提供方，只需模拟一个应用caller，把刚才收到的请求参数重发一遍到要回归测试的应用，然后比对录制拿到的请求结果和新请求的结果，完成请求回放。
+
+### RPC回放过程
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/b3da0e6031b29e9e23aecbbb447b2618.jpg)
+
+相对其它现成流量回放方案，在RPC里内置流量回放功能，更方便，还可更多定制，如在线启停、方法级别录制。
+
+## 4 总结
+
+保障线上应用的稳定，不管是通过应用架构升级，还是修复现有问题。就是不仅要保障已有业务稳定，还要快速完成各种新需求，应用代码就经常变化，变化后就会引入新的不稳定因素。
+
+为保障应用升级后，业务行为还能保持和升级前一样，大多都是依靠已有TestCase验证，但不是完全可靠。最可靠是引入线上Case去验证改造后应用，把线上真实流量在改造后应用里回放：
+
+- 节省整个上线时间
+- 弥补手动维护Case存在的漏测缺陷
+
+应用引入RPC，所有请求流量都会被RPC接管，很自然在RPC里支持流量回放。虽然这个功能本身不是RPC核心功能，但对使用RPC的人，有了这功能，就可更放心升级应用。
+
+## 5 FAQ
+
+还可用流量回放做啥？
+
+- **监控和告警**：通过持续回放关键接口的流量，实时监控系统的正确性和性能，及时发现异常。
+
+- **版本对比**：在新旧版本同时运行时，将流量同时发送到两个版本，对比响应结果，确保新版本兼容性。
+
+- **自动化测试增强**：结合自动化测试框架，使用真实流量作为测试用例，补充人工编写的测试用例，提高覆盖率。
+
+- **故障演练**：模拟故障场景，观察系统在真实流量下的容错能力，比如服务降级、重试机制等。
+
+- **数据迁移验证**：在数据迁移后，回放历史请求，验证新数据存储的正确性。
+
+- **用户体验分析**：分析用户请求模式，优化接口性能，提升用户体验。
+
+不过，每个用途都有其挑战。例如，版本对比需要同时维护两个版本的环境；故障演练需要精细的控制机制避免影响真实用户；数据迁移验证需要确保数据一致性和隔离性。
+
+### 类似的线上验证系统
+
+核心就是拿到线上接口的出入参和接口信息，转存到另一个系统，在这系统再调用改造、开发、或重构的接口（总之只要有变化或想测试一下同样的如入参，调用同样的方法，只是逻辑稍微不同了，是否结果一样）就可以通过，线上验证系统来验证一下。
+
+#### 使用限制
+
+- 底层数据依赖是否一致，入不一致那结果不一致也太正常了
+- 和当前系统状态或者当前系统时间是否相关，如果相关，结果也可能不一致
+- 方法是否幂等，如果不幂等，结果大概率也不一致的。
+
+虽有局限性，不过也能解决一些问题。结果是否一致可定制化，所以对某些特殊情况也可使用。
+
+#### 实现思路
+
+- 使用动态代理，AOP切面拦截对应的方法，获取出入参
+- 把拦截信息异步转存到线上验证系统
+- 通过线上验证系统调用待验证的方法
+- 收集结果比对信息，有报警功能（当然，在验证系统侧需要先收集和配置响应的待验证系统的信息，比如：定制化结果是否一直的条件）
+- 一般就是用于线上验证或系统重构时使用
+
+阿里开源sandbox-repeter：https://github.com/alibaba/jvm-sandbox-repeater。
+
+Q：既然能在rpc做，是不是可放到网关做，如机房迁移或服务重新部署一套，在网关做流量采集然后回访到另一网关，后面的服务都涉及到了，可行？
+
+A：在入口流量上做也是一种方案。
+
+Q：应该还可恢复数据，如一段时间数据由于某种原因丢，用流量回放功能恢复这段时间数据，当然要求接口幂等，否则会导致错误数据。
+
+A：恢复数据更多是采用log。
+
+Q：游戏角度，可用流量回放进行玩家脚本录制，然后多线程进行大批量脚本执行从而达到压力测试的效果。
+
+一般rpc都会有扩展，只要在扩展里面进行异步处理一下就可以满足。
+
+Q：只是录制请求和响应感觉不够。 响应可能和用户数据有关。 响应=请求参数+用户状态+其他依赖方状态。
+
+A：你想表达数据隔离？好比如count场景确实可能不够。
+
+Q：流量回放还可：
+
+- QA做接口探活，用线上数据调用接口（http接口只探get方法）
+- 算法逻辑的验证：可用历史请求参数重跑一遍新算法逻辑，验证新算法逻辑的效果
+
+Q：参数和返回值也得存下来，安全隐患较大
+
+A：确实，存储请求和响应数据可能包含敏感信息，比如用户个人信息、支付信息等。因此，在实施流量回放时，必须对数据进行脱敏处理，或者确保存储和传输的安全性。例如，可以对敏感字段进行加密或替换，避免数据泄露。
+
+Q：非幂等接口想用的话，TC里最好有完整的创建数据，清理数据调用，难度也比较大。
+
+A：如支付接口，如果回放时重复调用，可能导致多次扣款。这时候，处理起来确实复杂。可能方案：
+
+- 在测试环境中使用mock的支付服务，避免真实交易
+- 在回放前清理测试数据，确保每次回放都在干净的环境中进行
+- 标记测试请求，让下游系统识别并处理测试数据，避免影响真实业务
+
+Q：感觉没啥用处。如付款接口，你不能通过入参、出参相同就判断里面执行结果相同，都是返回付款成功，你咋知道实际付款了一次or两次？你可能会说把付款成功金额返回，但有bug的情况，付款了两次，却返回一次的成功金额。按回放功能来跑，这bug发现不了。
+
+A：如果系统存在bug，导致重复付款但返回成功一次，这种情况流量回放可能无法发现，因为响应结果相同。这时需结合日志分析或其他监控手段检测重复操作。或在回放时不仅比对响应结果，还检查数据库状态或其他副作用，但这增加复杂度。
+
+重现生产问题：不好定位问题的时候，也是可以试试流量回放重现生产问题。
+
+Q：用生产环境的流量来做压测。
+
+A：使用真实流量进行压测，比人工构造的请求更贴近实际场景，能更真实地反映系统性能。但需要注意，压测环境和生产环境的数据隔离，避免影响真实用户。
+
+Q：可是场景模拟，镜像流量只是其中一步，所有外部接口的mock也得和线上当时的场景一致，不然最后也可能脱离预期。
+
+A：外部接口的mock。为了准确模拟线上环境，所有依赖的外部服务在回放时需要保持与录制时一致的状态，或者使用录制的外部响应数据进行mock。否则，回放结果可能因为外部服务状态变化而不准确。
+
+Q：流量回放适用的方法是不是有限制，需要幂等的方法才可以？
+
+A：只要做好隔离了，不用区分。
\ No newline at end of file

From 8f291eef0cd4288ea02a6a6df0a5071d1f267087 Mon Sep 17 00:00:00 2001
From: JavaEdge <sss2855845850@gmail.com>
Date: Tue, 4 Feb 2025 23:30:04 +0800
Subject: [PATCH 05/20] =?UTF-8?q?perf:=E4=BC=98=E5=8C=96=E6=A0=87=E9=A2=98?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/md/AI/llm/Build-App-with-Dify.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/md/AI/llm/Build-App-with-Dify.md b/docs/md/AI/llm/Build-App-with-Dify.md
index 6e6d26830..58e535e44 100644
--- a/docs/md/AI/llm/Build-App-with-Dify.md
+++ b/docs/md/AI/llm/Build-App-with-Dify.md
@@ -1,4 +1,4 @@
-# 基于DIFY快速构建应用
+# 用Dify零代码给你的网站做AI客服！
 
 ## 0 前言
 

From 7e7fe9d5dc007857c42b5a7011efff048b6d518a Mon Sep 17 00:00:00 2001
From: JavaEdge <sss2855845850@gmail.com>
Date: Tue, 25 Feb 2025 18:01:44 +0800
Subject: [PATCH 06/20] =?UTF-8?q?docs:=E6=9B=B4=E6=96=B0=E4=B8=93=E6=A0=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .vscode/.server-controller-port.log           |   4 +-
 docs/.vuepress/config.js                      |  54 +--
 ...345\244\247\346\250\241\345\236\213API.md" |   2 -
 docs/md/AI/llm/claude-3-7-sonnet.md           | 114 +++++
 docs/md/AI/llm/deepseek-r1-detail.md          | 182 +++++++
 docs/md/AI/llm/llm-api-platform.md            |  56 +++
 ...owledge-base-segmentation-data-cleaning.md | 176 +++++++
 .../building-neural-networks-with-pytorch.md  | 230 +++++++++
 ...torch-cifar10-image-classifier-tutorial.md | 419 ++++++++++++++++
 docs/md/AI/ml/what-is-neural-network.md       |  16 +-
 docs/md/AI/ml/what-is-tensor.md               | 116 +++++
 docs/md/DDD/domain-service.md                 | 455 ++++++++++++++++++
 ...14\350\264\243\345\216\237\345\210\231.md" | 150 ++++--
 package.json                                  |   2 +
 14 files changed, 1899 insertions(+), 77 deletions(-)
 delete mode 100644 "docs/md/AI/llm/00-\345\205\215\350\264\271\345\244\247\346\250\241\345\236\213API.md"
 create mode 100644 docs/md/AI/llm/claude-3-7-sonnet.md
 create mode 100644 docs/md/AI/llm/deepseek-r1-detail.md
 create mode 100644 docs/md/AI/llm/llm-api-platform.md
 create mode 100644 docs/md/AI/llm/llm-knowledge-base-segmentation-data-cleaning.md
 create mode 100644 docs/md/AI/ml/building-neural-networks-with-pytorch.md
 create mode 100644 docs/md/AI/ml/pytorch-cifar10-image-classifier-tutorial.md
 create mode 100644 docs/md/AI/ml/what-is-tensor.md
 create mode 100644 docs/md/DDD/domain-service.md

diff --git a/.vscode/.server-controller-port.log b/.vscode/.server-controller-port.log
index 5f690f808..9b77e4e1e 100644
--- a/.vscode/.server-controller-port.log
+++ b/.vscode/.server-controller-port.log
@@ -1,5 +1,5 @@
 {
-  "port": 9146,
-  "time": 1738581319562,
+  "port": 13452,
+  "time": 1740476476079,
   "version": "0.0.3"
 }
\ No newline at end of file
diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index 0ba7afdb6..cb0575f94 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -11,7 +11,8 @@ module.exports = {
         externalLinks: {
             target: '_blank',
             rel: 'noopener noreferrer'
-        }
+        },
+        mermaid: true,
     },
     locales: {
         "/": {
@@ -111,6 +112,7 @@ module.exports = {
             color: '#3eaf7c',
             successText: '@JavaEdge: 代码已经复制到剪贴板'
         }],
+        'vuepress-plugin-mermaidjs',
         // // see: https://github.com/tolking/vuepress-plugin-img-lazy
         // ['img-lazy', {}],
         // ["vuepress-plugin-tags", {
@@ -733,39 +735,15 @@ module.exports = {
                                 link: '/md/python/00-macOS和Linux安装和管理多个Python版本'
                             },
                             {
-                                text: '机器学习',
+                                text: 'AI理论',
                                 link: '/md/AI/ml/01-人工智能概要'
                             },
                             {
-                                text: 'LLM应用开发',
+                                text: 'AIGC应用开发框架',
                                 link: '/md/AI/AI大模型企业应用实战'
                             },
                             {
-                                text: 'LangChain',
-                                link: '/md/AI/00-introduction-to-langchain'
-                            },
-                            {
-                                text: 'RAG',
-                                link: '/md/AI/00-rag-introduction-tool-to-eliminate-llm-hallucinations'
-                            },
-                            {
-                                text: 'Agent',
-                                link: '/md/AI/01-what-are-agents'
-                            },
-                            {
-                                text: 'LangGraph',
-                                link: '/md/AI/00-introduce-to-LangGraph'
-                            },
-                            {
-                                text: 'LangChain4j',
-                                link: '/md/AI/langchain4j/01-intro'
-                            },
-                            {
-                                text: 'Spring AI Alibaba',
-                                link: '/md/AI/spring-ai-alibaba/why-choose-spring-ai-alibaba-for-smart-customer-service'
-                            },
-                            {
-                                text: '大模型发展',
+                                text: '大模型平台',
                                 link: '/md/AI/llm/GPTs推荐'
                             },
                             {
@@ -1458,6 +1436,7 @@ module.exports = {
                                 "基于电商履约场景的DDD实战",
                                 "11-上下文映射",
                                 "13-DDD分层架构及代码目录结构",
+                                "domain-service",
                                 "23-理解领域事件（Domain Event）",
                             ]
                         },
@@ -2115,7 +2094,7 @@ module.exports = {
                             collapsable: false,
                             sidebarDepth: 0,
                             children: [
-                                "00-免费大模型API",
+                                "llm-api-platform",
                                 "GPTs推荐",
                                 "ChatGPT为啥不用Websocket而是EventSource",
                                 "携手阿里云：JetBrains AI Assistant 正式发布！",
@@ -2130,11 +2109,11 @@ module.exports = {
                             ]
                         },
                         {
-                            title: "Gemini",
+                            title: "DeepSeek",
                             collapsable: false,
                             sidebarDepth: 0,
                             children: [
-                                "00-免费大模型API",
+                                "deepseek-r1-detail",
                             ]
                         },
 
@@ -2145,6 +2124,7 @@ module.exports = {
                             children: [
                                 "Claude3到底多强",
                                 "计算机使用功能",
+                                "claude-3-7-sonnet",
                             ]
                         },
                         {
@@ -2165,6 +2145,7 @@ module.exports = {
                                 "what-is-llmops",
                                 "Build-App-with-Dify",
                                 "integrate-dify-and-aws-services-to-enable-more-flexible-translation-workflows",
+                                "llm-knowledge-base-segmentation-data-cleaning",
                             ]
                         },
                     ],
@@ -2181,6 +2162,17 @@ module.exports = {
                             "MapReduce分治思想",
                             "05-开发环境安装",
                             "一文看懂AI的Transformer架构",
+                            "what-is-tensor",
+                        ]
+                    },
+                    
+                    {
+                        title: "PyTorch",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "building-neural-networks-with-pytorch",
+                            "pytorch-cifar10-image-classifier-tutorial",
                         ]
                     }, ],
 
diff --git "a/docs/md/AI/llm/00-\345\205\215\350\264\271\345\244\247\346\250\241\345\236\213API.md" "b/docs/md/AI/llm/00-\345\205\215\350\264\271\345\244\247\346\250\241\345\236\213API.md"
deleted file mode 100644
index 111e7188b..000000000
--- "a/docs/md/AI/llm/00-\345\205\215\350\264\271\345\244\247\346\250\241\345\236\213API.md"
+++ /dev/null
@@ -1,2 +0,0 @@
-# 00-免费大模型API
-
diff --git a/docs/md/AI/llm/claude-3-7-sonnet.md b/docs/md/AI/llm/claude-3-7-sonnet.md
new file mode 100644
index 000000000..7c7db0ed1
--- /dev/null
+++ b/docs/md/AI/llm/claude-3-7-sonnet.md
@@ -0,0 +1,114 @@
+# 全球最强即时推理AI大模型Claude 3.7发布！
+
+## 0 前言
+
+2025年2月25日，今天发布迄今为止最智能的模型——**Claude 3.7 Sonnet**，全球首个**混合推理（Hybrid Reasoning）**模型。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/cc3a0232463aeeceb09b9c415b3e0c11.png)
+
+提供：
+
+- 近乎实时回答
+- 同时进行深入的、分步骤的推理
+- 且这种思考过程可[直观展示给用户](https://youtu.be/t3nnDXa81Hs)
+- 对API用户，还可**精细控制**模型的思考时长
+
+在**编程和前端开发**方面表现尤为出色。还推出一款**全新的命令行工具——Claude Code**，专为**智能代理式（Agentic）编码**设计。目前处**限量研究预览**阶段，允许开发者直接在终端委托 Claude 执行**复杂工程任务**。
+
+Claude Code介绍界面：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/f1f7aa4bc58d71d90cec6ce7fd1a6a6d.png&w=3840&q=75)
+
+## 1 面向所有用户
+
+
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/0979de78d760ea8f66ec6ace9a9de376.png)
+
+### 1.1 访问入口
+
+- **Claude 官网**（[Claude.ai](https://claude.ai/new)），支持**免费版、Pro、团队版和企业版**（免费版不支持“扩展思考”模式）
+- **API 接入**：[Anthropic API](https://docs.anthropic.com/en/docs/about-claude/models)
+- **云服务**：[Amazon Bedrock](https://aws.amazon.com/bedrock/claude/)、[Google Cloud Vertex AI](https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/use-claude)
+
+### 1.2 价格
+
+**标准模式和扩展思考模式**均维持与前代相同费用：
+
+- **输入**：每百万 tokens **$3**
+- **输出**：每百万 tokens **$15**（包含思考过程的 tokens）
+
+## 2 让最强推理更实用
+
+采用不同市场上其他推理模型的设计理念。与人类一样，我们认为 AI **不应将快速反应与深度思考分离**，而应统一到同一个模型。这种方法能带来更流畅的用户体验，并让 AI 更自然地**在不同任务间切换推理方式**。
+
+### 2.1 Claude 3.7 Sonnet的核心特性
+
+#### 2.1.1 普通 LLM + 推理模型【合体】
+
+用户可选**快速回答**，也可让 Claude **深度思考**后再作答。
+
+**扩展思考模式**下，Claude 3.7 Sonnet会进行自我反思，以提升**数学、物理、代码编写、指令执行**等表现。
+
+#### 2.1.2 API可控的思考预算
+
+开发者可通过 API 设置 Claude **最多思考 N 个 tokens**（最高可达 **128K tokens**），实现**速度、成本和回答质量**的三角平衡。
+
+#### 2.1.3 更贴近真实业务场景的优化
+
+相较数学或编程竞赛问题，我们更专注**企业实际使用 LLM 的需求**，如代码维护、调试、自动化开发等。
+
+[早期测试](https://www.anthropic.com/claude/sonnet)中，Claude 3.7 Sonnet编程能力遥遥领先：
+
+- **Cursor**：Claude继续成为**处理真实代码任务**的**最佳 AI**，能处理**复杂代码库**并使用高级工具
+- **Cognition**：Claude 在**代码修改规划**和**全栈开发**方面远超其他模型
+- **Vercel**：Claude 在**复杂自动化任务**中表现极为精准
+- **Replit**：Claude 能**从零构建**复杂的 Web 应用和仪表盘，而其他模型常会卡住
+- **Canva**：Claude 生成的代码不仅**生产就绪**，而且设计风格更优，错误率显著减少
+
+### 2.2 关键基准测试表现卓越
+
+#### 2.2.1 SWE-bench Verified
+
+评估 AI 解决**真实软件问题**的能力，取得最先进的表现：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/9e194a1f49d28516f8d9a445240700ee.png&w=3840&q=75)
+
+#### 2.2.2 TAU-bench
+
+测试 AI 在复杂任务中的**用户交互和工具调用**能力，依然领先：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/cc3b111394525cee41454efd89768a34.png&w=3840&q=75)
+
+#### 2.2.3 综合能力
+
+在**指令跟随、推理、多模态理解、代码代理**等方面均表现优异，扩展思考模式在**数学和科学任务**中带来额外优势。前沿推理模型对比：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/c98054281434e8f7bdf31ccccbbeac10.png&w=3840&q=75)
+
+## 3 Claude Code：智能代理式编程助手
+
+自 2024 年 6 月以来，Sonnet 已成为开发者首选模型。今天进一步推出**Claude Code**——Anthropic 的首款**智能代理编程工具**（限量研究预览）。
+
+Claude Code 能执行**代码搜索、文件编辑、测试编写和运行、GitHub 提交、命令行操作**，整个过程保持**透明可控**。
+
+Claude Code在内测中**大幅提高开发效率**：
+
+- **复杂调试、重构**：可高效解决**复杂 bug**，并进行大规模代码重构
+- **任务自动化**：完成**原本需 45+ 分钟**的任务，仅需**一次性执行**
+
+计划在未来几周内不断
+
+### 优化
+
+- 提升工具调用的可靠性
+- 支持长时间运行的命令
+- 增强代码解析和交互能力
+
+[申请加入 Claude Code 预览](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/overview)，一起塑造 Claude 的未来！
+
+## 4 展望
+
+Claude 3.7 Sonnet 和 Claude Code 标志着 AI **从助手向智能伙伴进化**的重要一步。它们不仅具备**深度推理、自动执行任务**的能力，还能**高效协作**，真正扩展人类的创造力。
+
+期待看到大家用它们创造出怎样的精彩应用！🎉
\ No newline at end of file
diff --git a/docs/md/AI/llm/deepseek-r1-detail.md b/docs/md/AI/llm/deepseek-r1-detail.md
new file mode 100644
index 000000000..4fd580a7d
--- /dev/null
+++ b/docs/md/AI/llm/deepseek-r1-detail.md
@@ -0,0 +1,182 @@
+# DeepSeek-R1论文细节时间线梳理
+
+## 0 前言
+
+2025年1月10日，DeepSeek发布名为R1的大语言模型，该初创公司声称其在推理任务上可与OpenAI的ChatGPT o1媲美。该应用在创纪录的时间内登顶App Store排行榜，不仅吸引科技行业关注，也引发了全球范围内的广泛讨论。其中一个尤引人注目的声明是：*该模型训练成本低于600万美元*（而OpenAI在GPT-4花费高达1亿美元）。这一消息在股市和新闻媒体中引发轩然大波。
+
+但对我们研发，更有趣的是尝试理解DeepSeek究竟做了什么，以及他们是如何做到的。我们从关键事实和初步印象开始，然后探讨从他们的论文中了解到的模型架构、训练数据、评估方法以及所使用的技术。最后，我们将看看复现他们结果的尝试以及未来的发展方向。 
+
+## 1 DeepSeek-R1相关事实
+
+### 1.1 谁构建了它？
+
+DeepSeek是一家成立于2023年5月的中国AI初创公司，总部位于杭州和北京。它由位于杭州的中国对冲基金High-Flyer支持。High-Flyer和DeepSeek均由[梁文峰](https://fortune.com/2025/01/27/deepseek-founder-liang-wenfeng-hedge-fund-manager-high-flyer-quant-trading/)创立。
+
+2025年1月10日，DeepSeek发布了他们的移动应用；2025年1月20日，公司在[Huggingface上发布了R1的权重](https://huggingface.co/deepseek-ai/DeepSeek-R1)，并在[GitHub上发布了R1的推理代码](https://github.com/deepseek-ai/DeepSeek-R1)。
+
+### 1.2 DeepSeek到底构建了什么？
+
+DeepSeek构建了两种类型的模型以及使用它们的应用程序。这两种模型的最新版本分别是V3和R1：
+
+- V3，顾名思义，是通用语言模型的第三个版本
+- R1是基于V3-Base的推理模型
+
+他们还提供了模型的蒸馏版本，以便可以在笔记本电脑上运行。V3有两个版本：
+
+- 一个基于Llama（Meta的开源权重模型）
+- 另一个基于Qwen（阿里巴巴的开源权重模型）
+
+虽然他们发布了R1模型的权重和运行模型推理的代码，但他们未发布任何训练代码或所有硬件优化相关代码。
+
+## 2 使用DeepSeek的印象
+
+我们身边打工人通过公司数据中心部署的DeepSeek，而其他人则使用ollama在PC运行R1的蒸馏模型。然后，我们花了一些时间像使用其他模型一样使用它——从编码到推理问题的任务。
+
+根据近期使用体验，以下是一些初步印象和想法：
+
+- 多语言表现在英语和中文表现出色，但法语表现不够流畅，偶尔会出现意外的中文或阿拉伯字符，并且在复杂推理时偶尔会切换回英语
+- 推理风格有时过冗长——有时会绕圈子
+- 我们希望了解更多关于DeepSeek如何考虑安全和隐私方面的信息——特别是从用户角度
+- 模型实例有各种大小，可安装在各种消费级硬件，包括节能模型
+- 托管版本似乎具有与本土政府世界观一致的护栏。模型本身可能反映了与该世界观一致的视角。
+- 无法了解用于训练它的数据（尽管值得注意的是，Llama、OpenAI、Claude也是如此）。这使得一些政府和企业感到不安
+
+## 3 咋用DeepSeek？
+
+### 3.1 官方
+
+- 可在[DeepSeek官网](https://www.deepseek.com/)或其同名APP试用该模型
+
+### 3.2 本地运行工具
+
+用**ollama run deepseek-r1:32b**在本地运行蒸馏版本的模型
+
+### 3.3 云服务商
+
+也迅速跟进。可在[GCP Vertex AI](https://github.com/GoogleCloudPlatform/generative-ai/blob/main/open-models/use-cases/vertex_ai_deepseek_smolagents.ipynb)、[AWS Bedrock](https://aws.amazon.com/blogs/machine-learning/deploy-deepseek-r1-distilled-llama-models-in-amazon-bedrock/)和[Azure AI Foundry](https://azure.microsoft.com/en-us/blog/deepseek-r1-is-now-available-on-azure-ai-foundry-and-github/)上部署DeepSeek模型。还可将其部署为[一个NVIDIA NIM](https://blogs.nvidia.com/blog/deepseek-r1-nim-microservice/)。
+
+DeepSeek模型足够有趣，值得考虑将其添加到你的AI平台工具箱，与其他开源权重模型一起使用，因为应用程序构建者会希望为不同目的实验或使用不同的模型。
+
+## 4 DeepSeek报告的性能结果可信吗？
+
+DeepSeek的结果尚未被复现。正密切关注Huggingface在[openR1](https://github.com/huggingface/open-r1)上复现它的尝试。我们还想了解模型在训练期间是否接触过基准数据，以及论文中使用的评估方法是否合适。话虽如此，我们无任何具体理由认为这些结果不真实。
+
+引发热议的一点是2.788M GPU小时（估计556万美元）的训练成本（参见[这篇论文](https://arxiv.org/html/2412.19437v1)中的第一个表格）。V3论文清楚说明了支持这一价格点的假设，但也提出警告，称这仅代表最后一次训练运行的成本。鉴于行业对这一系列模型的迅速报道，怀疑这个数字在许多报道中被断章取义。
+
+## 5 DeepSeek的技术组件
+
+R1是在V3-Base上使用监督微调（SFT）和强化学习（RL）进行训练的。它们是经高度优化的Transformer模型，基于环境限制（特别是[美国政府对NVIDIA H100芯片的出口管制](https://www.csis.org/analysis/understanding-biden-administrations-updated-export-controls)）针对特定的硬件/软件框架进行了优化。DeepSeek还以一些有趣方式结合新旧技术。
+
+### 5.1 [V3-Base](https://arxiv.org/html/2412.19437v1)
+
+V3-Base使用强大的混合专家（Mixture-of-Experts）方法。与Mixtral类似，但[更高效](https://arxiv.org/abs/2401.06066):
+
+- V3-Base训练6710亿个参数
+- 而Llama有个4050亿的版本
+
+V3-Base和Llama 3.1 405B都用FP8量化。V3-Base在14.8万亿个token上进行了训练，而Llama在15万亿个token上进行了训练。它们都支持128K上下文窗口。
+
+#### 关键区别
+
+- V3论文提到他们只使用278.8万GPU小时：据了解，用于训练V3的278.8万GPU小时仅用于最后一次完整的训练运行
+- 而[Llama 3.1 405B FP8的Hugging Face页面](https://huggingface.co/meta-llama/Llama-3.1-405B-FP8)显示他们使用3930万累计GPU小时：报告的数字是累计数字
+
+最终，如何解析这些词语的细节将会揭晓，但目前仍不清楚是否可以进行一对一比较。例如，V3是在一些由当时未发布的R1生成的数据上进行训练的；这时，V3的训练成本是否应包括R1的训练成本呢？
+
+R1是在V3-Base上使用SFT和强化学习（RL）构建的，以增强模型的推理能力。R1使用长链思维模式进行推理。R1随后被蒸馏成更小的密集模型。与V3-Base一样，他们发布了基于Llama、Qwen的版本。
+
+他们还发布R1-Zero，不使用SFT，并有一些限制，如可读性和语言混合。这些限制意味R1-Zero可能对研究人员比用户更有趣。为克服这些限制，他们在RL前应用了多阶段训练和冷启动数据。
+
+V3是通过使用R1的推理、验证和反思模式生成的数据进一步改进V3-Base而构建的，从而创建了一个更全面的模型V3。
+
+所有这些模型都是使用NVIDIA H800 GPU训练。这些是为中国市场制造的H100 GPU版本，并如前所述，为[遵守美国的出口管制](https://www.reuters.com/technology/nvidia-tweaks-flagship-h100-chip-export-china-h800-2023-03-21/)，它们在某种程度受限。H800芯片的芯片间互连速度是H100一半（NVLink上约为400GB/s vs 900GB/s）。
+
+### 5.2 训练成本
+
+训练R1的成本[据报道为558万美元](https://techcrunch.com/2025/01/27/deepseek-punctures-tech-spending-plans-and-what-analysts-are-saying/)。我们知道他们是错的，但不清楚他们错得有多离谱。这计算来自V3技术报告，是训练DeepSeek V3的成本。CNN[正确地指出](https://www.cnn.com/2025/01/27/tech/deepseek-stocks-ai-china/index.html)这个成本是基础模型的成本——但他们没帮助人们理解两者之间区别。
+
+R1是在V3-Base之上训练，因此训练R1的累计成本肯定高于训练基础模型的成本。V3技术报告表一中的数字似乎是一次完整训练运行的成本，可能是最后一次完整的训练运行。如想复制训练过程，可能需要进行不止一次完整的训练运行。
+
+还有相互矛盾报道称，[DeepSeek可以使用50,000个A100](https://www.bbc.com/news/articles/c0qw7z2v1pgo)，这与OpenAI用于[训练GPT-4的25,000个A100](https://www.acorn.io/resources/learning-center/openai/)更接近。
+
+若你今天在美国租用50,000个A100 GPU，可能需支付约1.35美元/GPU小时（如能找到这么多可用GPU）。大约是每周1134万美元。在DeepSeek的案例中，他们似乎使用其对冲基金支持者High-Flyer[早先获得](https://www.reuters.com/technology/artificial-intelligence/high-flyer-ai-quant-fund-behind-chinas-deepseek-2025-01-29)的GPU，这些GPU原本用于高频交易。
+
+## 6 深入探讨DeepSeek的独特之处
+
+DeepSeek以多种复杂方式修改了模型架构、训练技术和数据，以充分利用他们可用的有限硬件。现在让我们从底层开始逐一探讨这些内容。
+
+### 6.1 针对可用硬件的优化
+
+与H100相比，DeepSeek必须使用的H800有两个关键限制：
+
+- 它们的GPU到GPU互连带宽是H100的一半
+- 内存要小得多：80GB V.S 188GB
+
+有趣的是，DeepSeek似乎将这些限制转为优势。“DeepSeek-V3的经济训练成本……是通过我们对算法、框架和硬件的优化协同设计实现，”DeepSeek团队写道。即他们做出的决策使他们能够充分利用他们的可用资源。
+
+如他们用[FP8](https://fp8.ai/)显著减少所需内存量。V3论文指出，“低精度训练已成为高效训练的一个有前途解决方案”。但这项工作前，FP8被认为是高效但效果较差；DeepSeek展示了咋有效用它。“这项工作，我们引入一个FP8混合精度训练框架，并首次在超大规模模型上验证其有效性。通过支持FP8计算和存储，实现加速训练和减少GPU内存使用。”
+
+他们进一步在非常底层的层次对受限硬件进行优化。V3论文还指出，“我们还开发了高效的跨节点全对全通信内核，以充分利用InfiniBand（IB）和NVLink带宽。精心优化了内存占用，使得在不使用昂贵的张量并行的情况下训练DeepSeek-V3成为可能。结合这些，实现了高训练效率。”这是一些非常深入的工作，以充分利用他们受限的硬件。
+
+论文还讨论了“至于训练框架，我们设计了DualPipe算法以实现高效的管道并行，它具有更少的管道气泡，并通过计算-通信重叠隐藏大部分训练期间的通信。这种重叠确保了随着模型的进一步扩展，只要我们保持恒定的计算-通信比，我们仍然可以在节点之间使用细粒度的专家，同时实现接近零的全对全通信开销。”相对于“正常”的分布式训练扩展方式（通常只是“向堆中添加更多硬件”），恒定的计算-通信比和接近零的全对全通信开销引人注目。
+
+这是一个明显的例子，说明需求是发明之母。
+
+### 6.2 强化学习在训练后对基准性能的影响
+
+DeepSeek在V2和V3中使用了GRPO（组相对策略优化）进行强化学习。但显然，强化学习对推理模型R1的影响很大——它对基准性能的影响是显著的。
+
+通过使用GRPO将奖励应用于模型，DeepSeek避免了用大型“批评”模型；这再次节省内存。但GRPO采用基于规则的方法，虽然它在有客观答案的问题（如编码和数学）效果更好，但在答案主观或多变的领域可能遇难。随更多人在不同环境中使用它，跟踪这些权衡将是有趣的。
+
+### 6.3 多头潜在注意力（MLA）
+
+多头潜在注意力是DeepSeek在V2论文中引入的一种多头注意力的变体。根据[这篇文章](https://planetbanatt.net/articles/mla.html)，虽然以前的多头注意力技术被认为是一种权衡，即在LLM训练中为获得更好扩展性而降低模型质量，但DeepSeek表示，MLA不仅允许扩展，还提高了模型质量。期待深入研究这一点。
+
+### 6.4 蒸馏 vs 强化学习
+
+R1论文有关于蒸馏与强化学习的有趣讨论。DeepSeek团队写道，他们的工作使得以下结论成为可能：
+
+- “首先，将更强大的模型蒸馏到较小的模型中会产生出色的结果，而依赖于本文中提到的大规模RL的较小模型需要巨大的计算能力，甚至可能无法达到蒸馏的性能
+- 其次，虽然蒸馏策略既经济又有效，但超越智能边界可能仍需更强大的基础模型和更大规模强化学习。” 
+
+第一个结论有趣且直观。第二个结论令人放心——至少，他们并没有完全颠覆我们对深度学习在显著计算需求方面的理解。
+
+### 6.4 可从失败中学到啥？
+
+DeepSeek尝试了什么但没有成功？ 
+
+- 首先，使用过程奖励模型（PRM）来指导强化学习在大规模上是不可行的。但它仍可用于重新排名前N个响应
+- 其次，蒙特卡罗树搜索（MCTS），即AlphaGo和AlphaZero使用的方法，无法扩展到一般推理任务，因为问题空间不像国际象棋甚至围棋那样“受限”。还记得[不到十年前](https://www.buzzfeed.com/tomchivers/im-sorry-dave-im-afraid-i-cant-do-that)，围棋空间被认为过于复杂以至于无法计算？现在，它被认为是“受限的”。
+
+### 6.5 其他趣事
+
+- 一个非常令人印象深刻的编码基准
+- 训练后+扩展推理，看起来是制作非常有效模型的可行策略
+
+## 7 还会发生什么惊喜？
+
+### 7.1 打破基准和模型的循环
+
+每次发布新的更好模型，我们都怀疑它在训练时是否接触过基准数据。“它是为考试而学习，还是真正掌握了学科？”
+
+因为基准数据集的恶性循环；这是一个无休止的误导性炒作螺旋。你创建了一个好的基准数据集，下一个模型为获胜而对其进行优化，获得炒作，然后你需创建另一“公平”的基准……它增加了价值，直到下一个模型对其进行优化，依此类推。[人类的最后考试](https://www.zdnet.com/article/humanitys-last-exam-benchmark-is-stumping-top-ai-models-can-you-do-any-better/)只有在下一个模型发布之前才是它所说的那样。
+
+即当LLM在当前基准自信生成正确答案时，若其应用场景也是复杂度相似的现实数据，那将很棒。另一方面，当LLM在较新基准（或其应用领域）失败时，通常是因它对错误答案过于自信。这是因为新的基准数据具有它在训练时不知道的复杂性。
+
+该循环需要停止，我们需要更好、更通用的评估机制和信息丰富的指标，而不是每隔几周就依赖新基准。（[其他地方](https://www.thoughtworks.com/en-us/insights/blog/generative-ai/LLM-benchmarks,-evals,-and-tests)提到过这一点。）
+
+### 7.2 复现DeepSeek R1的结果
+
+我们都密切关注Huggingface的[openR1](https://github.com/huggingface/open-r1)，因为开源社区正在尝试复现这些结果。因为复现结果
+
+#### 需要条件
+
+1. GPU：2048个，不是很大数字，就像每次训练运行550万美元并不是超大数目。但你的公司应该不行
+2. 训练代码。DeepSeek没有开源他们的代码
+3. 训练数据——可能是最大缺口
+
+DeepSeek可能不会发布他们的整个训练数据集，就像OpenAI或Anthropic也不会发布他们的数据集。据我们所知，DeepSeek还没发布用于长链思维训练的数据样本。因此，勇敢的开源社区已开始创建数据集。[OpenThoughts](https://huggingface.co/datasets/open-thoughts/OpenThoughts-114k)就是一例。
+
+参考：
+
+- https://arxiv.org/abs/2501.12948
\ No newline at end of file
diff --git a/docs/md/AI/llm/llm-api-platform.md b/docs/md/AI/llm/llm-api-platform.md
new file mode 100644
index 000000000..a7ddd8024
--- /dev/null
+++ b/docs/md/AI/llm/llm-api-platform.md
@@ -0,0 +1,56 @@
+# 免费大模型API平台
+
+## 1 列表
+
+
+
+| 大模型                | 免费版本                                                     | 免费限制                                                     | 控制台（api_key等）                                          | 文档地址                                                     |
+| :-------------------- | :----------------------------------------------------------- | :----------------------------------------------------------- | :----------------------------------------------------------- | :----------------------------------------------------------- |
+| 讯飞星火              | `spark-lite`                                                 | tokens：总量无限 QPS：2 有效期：不限                         | [访问链接 219](https://console.xfyun.cn/services/cbm)        | [文档查看 71](https://www.xfyun.cn/doc/spark/Web.html)       |
+| 百度千帆              | `yi_34b_chat`, `ERNIE-Speed-8K`, `ERNIE-Speed-128K`, `ERNIE-Lite-8K`, `ERNIE-Lite-8K-0922`, `ERNIE-Tiny-8K` | Lite、Speed-8K：RPM = 300，TPM = 300000 Speed-128K：RPM = 60，TPM = 300000 | [访问链接 101](https://console.bce.baidu.com/qianfan/ais/console/applicationConsole/application) | [文档查看 44](https://cloud.baidu.com/doc/WENXINWORKSHOP/s/klqx7b1xf) |
+| 腾讯混元              | `hunyuan-lite`                                               | 限制并发数为 5 路                                            | [访问链接 77](https://console.cloud.tencent.com/cam/capi)    | [链接 37](https://cloud.tencent.com/document/api/1729/105701) |
+| Cloudflare Workers AI | `所有模型`                                                   | 免费可以每天使用1万次，一个月可以30万次；测试版本本的模型无限制 | [访问链接 169](https://dash.cloudflare.com/)                 | [文档查看 75](https://developers.cloudflare.com/workers-ai/configuration/open-ai-compatibility/) |
+| 字节扣子              | 豆包·Function call模型(32K)、通义千问-Max(8K)、MiniMax 6.5s(245K)、Moonshot（8K）、Moonshot（32K）、Moonshot（128K） | 当前扣子 API 免费供开发者使用，每个空间的 API 请求限额如下：QPS (每秒发送的请求数)：2 QPM (每分钟发送的请求数)：60 QPD (每天发送的请求数)：3000 | [访问链接 114](https://www.coze.cn/space)                    | [文档查看 39](https://www.coze.cn/docs/developer_guides/coze_api_overview) |
+| 字节火山方舟          | doubao系列、Moonshot系列等                                   | 2024年5月15日至8月30日期间，每个模型高达5亿tokens的免费权益，共计6个模型有30亿tokens。 | [访问链接 66](https://www.volcengine.com/docs/82379/1263512) | [文档查看 66](https://www.volcengine.com/docs/82379/1263512) |
+| Llama Family          | “Atom-13B-Chat”,“Atom-7B-Chat”,“Atom-1B-Chat”,“Llama3-Chinese-8B-Instruct” | 1.每天 8-22 点：接口限速每分钟 20 次并发 2.每天 22-次日 8 点：接口限速每分钟 50 次并发 | [访问链接 84](https://llama.family/docs/secret)              | [文档查看 29](https://llama.family/docs/chat-completion-v1)  |
+| Groq                  | gemma-7b-it、mixtral-8x7b-32768、llama3-70b-8192、llama3-8b-8192 |                                                              |                                                              |                                                              |
+| 硅基流动              |                                                              | 注册就送，包含2000w个token，可以多注册几个手机号             | [https://cloud.siliconflow.cn/i/lbFmA6dI](https://cloud.siliconflow.cn/i/lbFmA6dI) |                                                              |
+
+## 2 列表
+
+
+
+| 大模型   | 免费版本     | 免费限制                                                     | 控制台（api_key等）                                   | 文档地址                                               |
+| :------- | :----------- | :----------------------------------------------------------- | :---------------------------------------------------- | :----------------------------------------------------- |
+| 讯飞星火 | `spark-lite` | 安全封控等级太高了，老是提醒内容违规被禁止，巨难受，其他的就不会 | [访问链接 219](https://console.xfyun.cn/services/cbm) | [文档查看 71](https://www.xfyun.cn/doc/spark/Web.html) |
+| 零一万物 |              |                                                              | https://platform.lingyiwanwu.com/                     |                                                        |
+| 智谱AI   |              |                                                              | https://bigmodel.cn/                                  |                                                        |
+| gemini   |              |                                                              |                                                       |                                                        |
+|          |              |                                                              |                                                       |                                                        |
+|          |              |                                                              |                                                       |                                                        |
+|          |              |                                                              |                                                       |                                                        |
+|          |              |                                                              |                                                       |                                                        |
+|          |              |                                                              |                                                       |                                                        |
+
+| 时间    | 企业              | 事件                                                         |
+| ------- | ----------------- | ------------------------------------------------------------ |
+| 1月25日 | AMD               | 将DeepSeek - V3模型集成到了Instinct MI300X GPU上             |
+| 1月30日 | 微软              | 宣布DeepSeek - R1模型已通过AzureAI Foundry和H100提供         |
+| 1月31日 | 英伟达            | DeepSeek - R1模型现已作为NVIDIA AI服务预览版提供，为开发者开启了测试和验证阶段的访问 |
+| 1月31日 | 英特尔            | DeepSeek能够在搭载酷睿处理器的AI PC上快速使用                |
+| 1月31日 | 英特尔            | 用户可以在AmazonSageMaker中部署DeepSeek - R1模型             |
+| 2月1日  | 华为云/云基座基础 | 基础软件与华为云团队联合宣布上线基于华为云盘古云服务的DeepSeek - R1推理服务 |
+| 2月2日  | 腾讯云            | 在高性能应用服务器HA上支持一键部署DeepSeek - R1模型          |
+| 2月5日  | 天翼云            | 天翼云在其智算产品体系中全面接入DeepSeek - R1模型            |
+| 2月8日  | 阿里云            | 在PAIModelGallery支持云上一键部署DeepSeek - V3和DeepSeek - R1模型 |
+| 2月8日  | 百度智能云        | 百度智能云千帆平台正式上架DeepSeek - R1和DeepSeek - V3模型   |
+| 2月9日  | 火山引擎          | 宣布全面支持DeepSeek系列大模型                               |
+| 2月9日  | 沐曦              | 联合中国开源大模型平台OpenI.AI发布了全套DeepSeek - R1千亿训练模型 |
+| 2月14日 | 天数智芯          | 正式上线包括DeepSeek - R1 - 11B/DeepSeek - Q - 1.5B、DeepSeek - R1 - 11B - Qwen - 7B、DeepSeek - R1 - 33B/DeepSeek - Qwen - 7B等多个大模型服务 |
+| 2月14日 | 摩尔线程          | 宣布已实现对DeepSeek基础模型推理服务的部署，并即将开放自主设计的鲲鹏（EAGLE）GPU集群算力，支持DeepSeek - R1模型及新一代蒸馏模型的分布式部署 |
+| 2月21日 | 海光信息          | 宣布其技术团队已完成DeepSeek - V3和R1模型与海光DCU的适配并上线 |
+| 2月23日 | 无问芯穹          | 宣布其Infinity - 1 AI云盘对DeepSeek - R1/11B - 112B模型的支持 |
+| 2月24日 | PPD谱新云         | PPD谱新算力云支持了DeepSeek - V3、DeepSeek - R1以及蒸馏模型DeepSeek - R1 - Distill - llama - 7B |
+| 2月24日 | 360数字安全       | 360推出“DeepSeek版”安全大模型，发挥其安全大数据优势          |
+| 2月24日 | 云轴科技ZStack    | 云轴科技ZStack宣布其Alfresco平台/Stor2Stor全面支持企业私有化部署DeepSeek - R1模型 |
+| 2月25日 | 壁仞科技          | 其自主研发的旗戟系列GPU产品正式上线DeepSeek - R1模型推理服务 |
\ No newline at end of file
diff --git a/docs/md/AI/llm/llm-knowledge-base-segmentation-data-cleaning.md b/docs/md/AI/llm/llm-knowledge-base-segmentation-data-cleaning.md
new file mode 100644
index 000000000..a2771d486
--- /dev/null
+++ b/docs/md/AI/llm/llm-knowledge-base-segmentation-data-cleaning.md
@@ -0,0 +1,176 @@
+# Dify知识库分段与数据清洗实战：优化LLM检索效率与回答精准性指南
+
+将内容上传至知识库后，要对内容进行分段与数据清洗。**该阶段是内容的预处理与数据结构化过程，长文本将会被划分为多个内容分段。**
+
+## 1 分段
+
+由于LLM的上下文窗口有限，无法一次性处理和传输整个知识库的内容，因此需对文档 中的长文本分段为内容块。即便部分大模型已支持上传完整的文档文件，但实验表明，检索效率依然弱于检索单个内容分段。
+
+LLM能否精准回答出知识库中内容，关键在知识库对内容块的检索与召回效果。类似在手册中查找关键章节即可快速得到答案，而无需逐字逐句分析整个文档。
+
+经分段后，知识库能基于用户问题，采用分段 TopK 召回模式，召回与问题高度相关的内容块，补全关键信息从而提高回答精准性。
+
+进行问题与内容块的语义匹配时，合理分段大小很关键，能帮助模型准确找到与问题最相关内容，减少噪音信息。
+
+Dify 提供 **“通用分段”** 和 **“父子分段”** 两种分段模式，分别适应不同类型的文档结构和应用场景，满足不同的知识库检索和召回的效率与准确性要求。
+
+## 2 清洗
+
+为保证文本召回效果，通常需在将数据录入知识库之前便对其进行清理。如文本内容中存在无意义字符或空行，可能影响问题回复质量，需清洗。
+
+LLM收到用户问题后，能否精准回答知识库中内容，取决知识库对内容块的检索和召回效果。匹配与问题相关度高的文本分段对 AI 应用生成准确且全面的回应至关重要。
+
+好比智能客服，仅需帮助 LLM 定位至工具手册的关键章节内容块即可快速得到用户问题的答案，而无需重复分析整个文档。在节省分析过程中所耗费的 Tokens 的同时，提高 AI 应用的问答质量。
+
+### ETL
+
+RAG生产级应用，为获得更好的数据召回效果，需对多源数据进行预处理和清洗，即ETL。为增强非结构化/半结构化数据的预处理能力，Dify支持可选 ETL 方案：
+
+- Dify ETL
+- [ ](https://docs.unstructured.io/welcome)[**Unstructured ETL** ](https://unstructured.io/)。Unstructured 能高效提取并转换你的数据为干净的数据用于后续的步骤。
+
+Dify版本的 ETL 方案：
+
+* SaaS版不可选，默认Unstructured ETL
+* 社区版可选，默认Dify ETL ，可通过[环境变量](https://docs.dify.ai/v/zh-hans/getting-started/install-self-hosted/environments#zhi-shi-ku-pei-zhi)开启 Unstructured ETL
+
+文件解析支持格式的差异：
+
+| DIFY ETL                                                | Unstructured ETL                                             |
+| ------------------------------------------------------- | ------------------------------------------------------------ |
+| txt、markdown、md、pdf、html、htm、xlsx、xls、docx、csv | txt、markdown、md、pdf、html、htm、xlsx、xls、docx、csv、eml、msg、pptx、ppt、xml、epub |
+
+不同的 ETL 方案在文件提取效果的方面也存在差异，想了解更多关于 Unstructured ETL 的数据处理方式，请参考[官方文档](https://docs.unstructured.io/open-source/core-functionality/partitioning)。
+
+## 3 分段模式
+
+知识库支持两种分段模式：**通用模式**与**父子模式**。首次创建知识库，推荐父子模式。
+
+> 选定分段模式并完成知识库的创建后，后续无法变更。
+>
+> 知识库内新增的文档也将遵循同样的分段模式。
+
+### 3.1 通用模式
+
+系统按用户自定义规则将内容拆分为独立的分段。当用户输入问题后，系统自动分析问题中的关键词，并计算关键词与知识库中各内容分段的相关度。根据相关度排序，选取最相关的内容分段并发送给 LLM，辅助其处理与更有效地回答。
+
+该模式下，需根据不同的文档格式或场景要求，参考以下设置项，手动设置文本的**分段规则**。
+
+#### ① 分段标识符
+
+默认 `\n`，即按文章段落分块。可遵循正则表达式自定义分块规则，系统将在文本出现分段标识符时自动执行分段。例如  的含义是按照句子进行分段。
+
+不同语法的文本分段效果：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/0b3dc623b02779fb89f23a5d8ead7f13.png)
+
+#### ② 分段最大长度
+
+指定分段内的文本字符数最大上限，超出该长度时将强制分段。默认值为 500 Tokens，分段长度的最大上限为 4000 Tokens。
+
+#### ③ 分段重叠长度
+
+对数据进行分段时，段与段之间存在一定重叠部分。这种重叠可帮助提高信息的保留和分析的准确性，提升召回效果。建议设置为分段长度 Tokens 数的 10-25%。
+
+#### ④ 文本预处理规则
+
+过滤知识库内部分无意义的内容。提供以下选项：
+
+- 替换连续的空格、换行符和制表符
+- 删除所有 URL 和邮件地址
+
+配置完成后，点击“预览区块”即可查看分段后的效果。可直观看到每个区块的字符数。如重新修改分段规则，需重新点击按钮以查看新的内容分段。
+
+若同时批量上传多个文档，轻点顶部的文档标题，快速切换并查看其它文档的分段效果。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/612db4d321385ade781d16c8407ea2b0.png&width=768&dpr=4&quality=100&sign=fb516d94&sv=2)
+
+分段规则设置完成后，接下来需指定索引方式。支持“高质量索引”和“经济索引”，详细说明请参考[设定索引方法](https://docs.dify.ai/zh-hans/guides/knowledge-base/create-knowledge-and-upload-documents/setting-indexing-methods)。
+
+### 3.2 父子模式
+
+父子模式采用双层分段结构来平衡检索的精确度和上下文信息，兼得：
+
+- 精准匹配
+- 全面的上下文信息
+
+父区块（Parent-chunk）保持较大的文本单位（如段落），提供丰富上下文信息
+
+子区块（Child-chunk）是较小的文本单位（如句子），用于精确检索。系统先通过子区块进行精确检索以确保相关性，然后获取对应的父区块来补充上下文信息，从而在生成响应时既保证准确性又能提供完整的背景信息。你可以通过设置分隔符和最大长度来自定义父子区块的分段方式。
+
+如AI智能客服场景，用户输入的问题将定位至解决方案文档内某具体句子，再将该句子所在的段落或章节，联同发送至 LLM，补全该问题的完整背景信息，给出更精准回答。
+
+#### 3.2.0 实现原理
+
+##### ① 子分段匹配查询
+
+- 将文档拆分为较小、集中的信息单元（如一句话），更精准匹配用户所输入的问题
+- 子分段快速提供与用户需求最相关的初步结果
+
+##### ② 父分段提供上下文
+
+- 将包含匹配子分段的更大部分（如段落、章节甚至整个文档）视作父分段并提供给LLM
+- 父分段为LLM提供完整背景信息，避免遗漏重要细节，助 LLM 输出更贴合知识库内容的回答
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/03f18cd89574941efaeca45189d18760.png)
+
+该模式下，需根据不同文档格式或场景要求，手动分别设置父子分段的分段规则。
+
+#### 3.2.1 父分段
+
+分段选项：
+
+##### 段落
+
+根据预设的分隔符规则和最大块长度将文本拆分为段落。每个段落视为父分段，适用于文本量较大，内容清晰且段落相对独立的文档。支持以下设置项：
+
+- 分段标识符，默认值为 `\n`，即按照文本段落分段。可遵循正则表达式自定义分块规则，系统将在文本出现分段标识符时自动执行分段。
+- 分段最大长度，指定分段内的文本字符数最大上限，超出该长度时将强制分段。默认值为 500 Tokens，分段长度的最大上限为 4000 Tokens；
+
+##### 全文
+
+不进行段落分段，而直接将全文视为单一父分段。出于性能原因，仅保留文本内的前 10000 Tokens 字符，适用于文本量较小，但段落间互有关联，需完整检索全文的场景。
+
+父子模式下的段落和全文预览：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/0ea3487d495a73890f88e7d191057705.png&width=768&dpr=4&quality=100&sign=6c89023a&sv=2)
+
+#### 3.2.2 子分段
+
+子分段文本在父文本分段基础上，由分隔符规则切分而成，用于查找和匹配与问题关键词最相关和直接的信息。如果使用默认的子分段规则，呈现的分段效果：
+
+- 当父分段为段落时，子分段对应各段落中的单个句子
+- 父分段为全文时，子分段对应全文中各单独的句子
+
+在子分段内填写以下分段设置：
+
+- **分段标识符**，默认值为 ，即按照句子进行分段。可遵循正则表达式自定义分块规则，系统将在文本出现分段标识符时自动执行分段。
+- **分段最大长度**，指定分段内的文本字符数最大上限，超出该长度时将强制分段。默认值为 200 Tokens，分段长度的最大上限为 4000 Tokens；
+
+还可用**文本预处理规则**过滤知识库内部分无意义的内容：
+
+- 替换连续的空格、换行符和制表符
+- 删除所有 URL 和电子邮件地址
+
+配置完成后，点击“预览区块”即可查看分段后的效果。你可以查看父分段的整体字符数。背景标蓝的字符为子分块，同时显示当前子段的字符数。
+
+如果重新修改了分段规则，需要重新点击“预览区块”按钮以查看新的内容分段。若同时批量上传了多个文档，轻点顶部的文档标题，快速切换至其它文档并预览内容的分段效果。
+
+父子分段模式：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/8f4ceb167dfc7a16a2970ad8aa8cf7bb.jpeg)
+
+为确保内容检索的准确性，父子分段模式仅支持使用[“高质量索引”](https://docs.dify.ai/zh-hans/guides/knowledge-base/create-knowledge-and-upload-documents/chunking-and-cleaning-text#gao-zhi-liang-suo-yin)。
+
+### 3.3 模式区别
+
+内容区块的分段形式：
+
+- 通用模式的分段结果为多个独立的内容分段
+- 父子模式采用双层结构进行内容分段，即单个父分段的内容（文档全文或段落）内包含多个子分段内容（句子）
+
+不同分段方式影响 LLM 对知识库内容的检索效果。相同文档中，采用父子检索提供的上下文信息更全面，且精准度方面也保持较高水平，远优于传统的单层通用检索方式。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/011ab69080f3a89bb84081efd42c462f.jpeg)
+
+通用模式与父子模式的内容检索效果对比。
\ No newline at end of file
diff --git a/docs/md/AI/ml/building-neural-networks-with-pytorch.md b/docs/md/AI/ml/building-neural-networks-with-pytorch.md
new file mode 100644
index 000000000..ab6ece3a7
--- /dev/null
+++ b/docs/md/AI/ml/building-neural-networks-with-pytorch.md
@@ -0,0 +1,230 @@
+# 用PyTorch构建神经网络：面向Java开发者的入门指南
+
+
+
+## 0 学习目标
+
+掌握用Pytorch构建神经网络的基本流程和实现过程。使用Pytorch来构建神经网络，主要工具都在torch.nn包。nn依赖于autograd来定义模型，并对其自动求导。
+
+### 构建神经网络的流程
+
+- 定义一个拥有可学习参数的神经网络
+- 遍历训练数据集
+- 处理输入数据使其流经神经网络
+- 计算损失值
+- 将网络参数的梯度进行反向传播
+- 以一定的规则更新网络的权重
+
+## 1 定义一个神经网络
+
+
+
+```python
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# 定义网络类
+class Net(nn.Module):
+
+    def __init__(self):
+        super(Net, self).__init__()
+        # 定义第一层卷积神经网络, 输入通道维度=1, 输出通道维度=6, 卷积核大小3*3
+        self.conv1 = nn.Conv2d(1, 6, 3)
+        # 定义第二层卷积神经网络, 输入通道维度=6, 输出通道维度=16, 卷积核大小3*3
+        self.conv2 = nn.Conv2d(6, 16, 3)
+        # 定义三层全连接网络
+        self.fc1 = nn.Linear(16 * 6 * 6, 120)
+        self.fc2 = nn.Linear(120, 84)
+        self.fc3 = nn.Linear(84, 10)
+
+    # 前向传播   
+    def forward(self, x):
+        # 在(2, 2)的池化窗口下执行最大池化操作
+        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2)) # 卷积+激活+池化
+        x = F.max_pool2d(F.relu(self.conv2(x)), 2)      # 再次卷积+激活+池化
+        x = x.view(-1, self.num_flat_features(x))       # 展平数据
+        x = F.relu(self.fc1(x))                         # 全连接+激活
+        x = F.relu(self.fc2(x))                         # 全连接+激活
+        x = self.fc3(x)                                 # 输出层
+        return x
+
+    def num_flat_features(self, x):
+        # 计算size, 除了第0个维度上的batch_size
+        size = x.size()[1:]
+        num_features = 1
+        for s in size:
+            num_features *= s
+        return num_features
+
+
+net = Net()
+print(net)
+```
+
+模型中所有的可训练参数，可通过net.parameters()获得。
+
+```python
+params = list(net.parameters())
+print(len(params))
+print(params[0].size())
+```
+
+假设图像的输入尺寸为32 * 32：
+
+```python
+# 生成随机数据，形状是(1, 1, 32, 32)，表示1个样本，1个通道，32x32像素
+input = torch.randn(1, 1, 32, 32)  # 随机生成输入
+# 调用forward方法，输出结果是(1, 10)的张量，表示10个类别的预测值。
+out = net(input)                  # 前向传播
+print(out)                        # 输出结果
+```
+
+有了输出张量后，就可以执行梯度归零和反向传播的操作了：
+
+```python
+net.zero_grad()
+out.backward(torch.randn(1, 10))
+```
+
+torch.nn构建的神经网络只支持mini-batches的输入, 不支持单一样本的输入.
+
+比如: nn.Conv2d 需要一个4D Tensor, 形状为(nSamples, nChannels, Height, Width). 如果你的输入只有单一样本形式, 则需要执行input.unsqueeze(0), 主动将3D Tensor扩充成4D Tensor.
+
+## 2 损失函数
+
+输入是一个输入的pair: (output, target)，再计算出一个数值来评估output和target之间的差距大小。
+
+torch.nn中有若干不同的损失函数可供使用, 比如nn.MSELoss就是通过计算均方差损失来评估输入和目标值之间的差距。
+
+应用nn.MSELoss计算损失的一个例子:
+
+```python
+# 网络的预测结果，形状是(1, 10)
+output = net(input)
+# 随机目标 目标值，调整为(1, 10)与output匹配
+target = torch.randn(10)
+
+# 改变target的形状为二维张量, 为了和output匹配
+# 调整形状为(1, 10)
+target = target.view(1, -1)
+# 均方误差损失  类似Java中(output - target)^2的平均值。
+criterion = nn.MSELoss()
+
+# 计算损失 一个标量，表示预测和目标的差距。
+loss = criterion(output, target)
+print(loss)
+```
+
+方向传播的链条：若我们跟踪loss反向传播的方向, 使用.grad_fn属性打印，可看到一张完整的计算图如下:
+
+```python
+input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
+      -> view -> linear -> relu -> linear -> relu -> linear
+      -> MSELoss
+      -> loss
+```
+
+当调用loss.backward()时, 整张计算图将对loss进行自动求导, 所有属性requires_grad=True的Tensors都将参与梯度求导的运算, 并将梯度累加到Tensors中的.grad属性中.
+
+```python
+# 输出损失的计算节点 PyTorch会自动构建计算图（类似Java的依赖树），grad_fn告诉你loss是怎么计算出来的，比如通过MSE、线性层等操作。
+print(loss.grad_fn)  # MSELoss
+print(loss.grad_fn.next_functions[0][0])  # Linear
+print(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLU
+```
+
+## 3 反向传播（backpropagation）
+
+神经网络训练的核心，用于计算每个参数的梯度。loss.backward()即可。
+
+执行反向传播之前，要先将梯度清零，否则梯度会在不同的批次数据之间被累加。就像是**重置计数器**或**清空缓存**。目的是防止**梯度累加**导致的计算错误，通常在每次训练迭代开始前调用，相当于给神经网络一个"干净的纸"进行新一轮计算。
+
+```python
+# 梯度清零
+net.zero_grad()
+
+# 反向传播前的梯度
+print('conv1.bias.grad before backward')
+print(net.conv1.bias.grad)
+
+# 反向传播
+loss.backward()
+
+# 反向传播后的梯度
+print('conv1.bias.grad after backward')
+print(net.conv1.bias.grad)
+# 可以看到conv1.bias的梯度从0变成非零值，表示反向传播生效。
+```
+
+## 4 更新网络参数
+
+训练的最后一步是根据梯度更新参数，常用方法是随机梯度下降（SGD）。更新参数最简单的算法。
+
+公式为：
+$$
+weight = weight - learning_rate * gradient
+$$
+传统Python代码实现SGD:
+
+```python
+learning_rate = 0.01
+for f in net.parameters():
+    f.data.sub_(f.grad.data * learning_rate)
+```
+
+再用Pytorch官方推荐标准代码:
+
+```python
+# 先导入优化器的包, optim中包含若干常用的优化算法, 比如SGD, Adam等
+import torch.optim as optim
+
+# 创建优化器对象  PyTorch提供的优化器，封装了SGD逻辑，类似Java中的工具类。
+optimizer = optim.SGD(net.parameters(), lr=0.01)
+
+# 将优化器执行梯度清零
+optimizer.zero_grad()
+
+output = net(input)
+loss = criterion(output, target)
+
+# 对损失值执行反向传播
+loss.backward()
+# 参数的更新通过一行标准代码执行  根据梯度自动更新所有参数，比手动循环更简洁
+optimizer.step()
+```
+
+## 5 总结
+
+构建一个神经网络的典型流程：
+
+- 定义一个拥有可学习参数的神经网络
+- 遍历训练数据集
+- 处理输入数据使其流经神经网络
+- 计算损失值
+- 将网络参数的梯度进行反向传播
+- 以一定的规则更新网络的权重
+
+损失函数定义：
+
+- 采用torch.nn.MSELoss()计算均方误差
+- 通过loss.backward()进行反向传播计算时，整张计算图将对loss进行自动求导所有属性requires_grad=True的Tensors都将参与梯度求导的运算，并将梯度累加到Tensors中的.grad属性
+
+反向传播计算方法：
+
+- 在Pytorch中执行反向传播非常简便，全部的操作就是loss.backward()
+- 在执行反向传播之前，要先将梯度清零，否则梯度会在不同的批次数据之间被累加
+  - net.zero_grad()
+  - loss.backward()
+
+参数更新方法：
+
+- 定义优化器来执行参数的优化与更新
+
+  - optimizer = optim.SGD(net.parameters(), lr=0.01)
+
+- 通过优化器来执行具体的参数更新
+
+  - optimizer.step()
+
+这就像Java中设计一个复杂的对象系统，只不过PyTorch帮你自动处理了数学部分（梯度计算）。
\ No newline at end of file
diff --git a/docs/md/AI/ml/pytorch-cifar10-image-classifier-tutorial.md b/docs/md/AI/ml/pytorch-cifar10-image-classifier-tutorial.md
new file mode 100644
index 000000000..7bdff7953
--- /dev/null
+++ b/docs/md/AI/ml/pytorch-cifar10-image-classifier-tutorial.md
@@ -0,0 +1,419 @@
+# 用 PyTorch 构建 CIFAR10 图像分类器
+
+## 0 目标
+
+- 了解分类器的任务和数据样式
+- 掌握如何用 PyTorch 实现一个图像分类器
+
+## 1 分类器任务和数据介绍
+
+### 1.1 任务描述
+
+构造一个神经网络分类器，对输入的图像分类，判断它们属哪类。
+
+本案例目标是区分 CIFAR10 数据集中的不同图像。
+
+### 1.2 数据介绍：CIFAR10 数据集
+
+数据集特点：
+
+- CIFAR10 包含 10 种不同类别的小型彩色图像
+- 每张图像尺寸为 3 × 32 × 32，代表 3 个颜色通道（RGB）
+- 10 个类别分别为："plane"（飞机）、"car"（汽车）、"bird"（鸟）、"cat"（猫）、"deer"（鹿）、"dog"（狗）、"frog"（青蛙）、"horse"（马）、"ship"（船）、"truck"（卡车）
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/30d475d656aff6ba52542d91fa39fb4a.png)
+
+## 2 训练分类器的步骤
+
+以下是使用 PyTorch 实现分类器的详细步骤，适合 Java 程序员从零开始学习。
+
+### 2.1 使用 torchvision 下载 CIFAR10 数据集
+
+用 PyTorch 的 `torchvision` 模块下载 CIFAR10 数据集，并对图像进行预处理。
+
+```python
+# 引入 PyTorch 的核心库和图像处理相关的库
+import torch
+import torchvision
+# torchvision.transforms是pytorch中的图像预处理包，包含很多种对图像数据进行变换的函数
+import torchvision.transforms as transforms
+
+# 定义数据变换：将 PIL 格式图像转为张量，并标准化到 [-1, 1] 区间
+# 这相当于创建了一个图像预处理的管道，类似 Java 的 Builder 模式。将图像转换为张量并进行标准化处理
+transform = transforms.Compose([
+    transforms.ToTensor(),
+    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
+])
+
+# 下载并加载训练集
+# 类似 Java 中创建数据源和迭代器。CIFAR10是一个图像数据集
+trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
+                                      download=True, transform=transform)
+# DataLoader类似Java的 Iterator，以批量加载数据
+trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
+                                        shuffle=True, num_workers=2)
+
+
+testset = torchvision.datasets.CIFAR10(root='./data', train=False,
+                                     download=True, transform=transform)
+testloader = torch.utils.data.DataLoader(testset, batch_size=4,
+                                       shuffle=False, num_workers=2)
+
+# 定义类别名称
+classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
+```
+
+数据格式：`torchvision` 的输出是 PIL 图像，需通过 `transforms.ToTensor()` 转为 PyTorch 张量，并通过 `Normalize` 标准化到 [-1, 1] 范围。
+
+> PIL 图像：值范围通常是 [0, 255]（8 位无符号整数，代表像素强度）。
+
+#### 2.1.1 transforms.ToTensor是啥？
+
+##### ① 为啥要转换？
+
+深度学习模型需要张量，Java 中，你可能惯用int[]或List存储数据，但深度学习框架（如 PyTorch）需用数学张量（torch.Tensor）表示数据。张量是多维数组，类似于 Java 的多维数组，但更优化了矩阵运算和 GPU 加速。
+
+如图像的每个像素值需要作为浮点数输入到神经网络，而非整数。
+
+张量支持自动求导、并行计算和 GPU 加速，这是 PyTorch 高效处理数据的基础。
+
+##### ② 格式调整
+
+PIL 图像或 NumPy 数组的形状是 (H, W, C)（高度、宽度、通道），但 PyTorch 模型期望输入为 (C, H, W)（先通道后空间），所以需要转换。
+
+这就像在 Java 中将一个 ArrayList 转换为某种特定格式的集合，以便适配某个 API。
+
+##### ③ 值范围转换
+
+原始值 [0, 255] 转换为 [0, 1.0]，让数据更适合神经网络处理（神经网络通常对小范围浮点数更敏感）。
+
+##### ④ Java 类比
+
+想象你在 Java 中有一个 Image 对象（类似 PIL 图像），但某个库需要 double[] 格式的数据。你需要写一个方法将 Image 转换为 double[]，并调整值范围（如除以 255）。ToTensor 就是这个转换过程。
+
+#### 2.1.2 transforms.Normalize是啥？
+
+```python
+# 第一个 (0.5, 0.5, 0.5)：每个颜色通道的均值（mean）
+# 第二个 (0.5, 0.5, 0.5)：每个颜色通道的标准差（standard deviation）
+transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
+```
+
+对张量进行标准化处理。
+
+对每个像素值，公式为：
+$$
+normalizedValue = (value - mean) / std
+$$
+如对于 RGB 图像的每个通道（R、G、B），值从 [0, 1] 调整为均值为 0、标准差为 1 的分布。
+
+- **输入**：经过 ToTensor 后的张量，值范围为 [0, 1]。
+- **输出**：值范围大致为 [-1, 1]（以均值为 0、标准差为 1 为中心）。
+
+##### ① 为啥要标准化？
+
+提高训练效率：
+
+- 神经网络的梯度下降优化算法（如 SGD）对输入数据的分布敏感。若数据值范围很大或分布不均，训练会变得很慢，甚至收敛困难
+- 标准化后，数据分布更均匀（均值为 0，标准差为 1），让模型更容易学习特征
+
+一致性：不同图像的像素值可能有不同分布（如有些图像偏暗、有些偏亮）。标准化确保所有图像都遵循相同的分布，便于模型处理。
+
+数值稳定性：深度学习模型中的权重初始化和激活函数（如 ReLU）对输入范围敏感。标准化后的数据更适合这些操作。
+
+##### ② Java类比
+
+想象你在 Java 中处理一组数据（如用户年龄），数据范围可能从 0 到 100。为让一个算法更好处理这些数据，可能用 Z-Score 标准化（(age - mean) / std），让数据分布更集中（均值为 0，标准差为 1）。Normalize 就是对图像像素值做的类似操作。
+
+在 Java 开发中，你可能处理过数据归一化（如将用户评分从 [0, 100] 归一化到 [0, 1]），以便算法更稳定。标准化在这里类似，调整像素值分布，让神经网络更容易学到模式。
+
+#### 2.1.3 为啥选择 [0.5, 0.5, 0.5] 作均值和标准差？
+
+CIFAR10 数据集特性：
+
+- CIFAR10 的图像已通过 ToTensor 转换为 [0, 1] 范围。
+- 对于 RGB 图像，0.5 是一个合理的经验值，因为 CIFAR10 的像素值分布大致是以 0.5 为中心（均值接近 0.5，标准差接近 0.5）
+- 选择这些值可以让数据分布更接近标准正态分布，提升模型训练效果。
+
+通用性：在许多图像分类任务中，(0.5, 0.5, 0.5) 是一个常见的选择，尤其在没有具体统计时作为默认值。
+
+##### ① Java 程序员提示
+
+这有点像在 Java 中设置一个默认配置（如默认线程池大小），但这里是针对图像数据的统计特性设置默认参数。
+
+#### 2.1.4 转换后的数据能做啥？
+
+- **输入神经网络**：转换后的张量（形状 (C, H, W)，值范围 [-1, 1]）可直接输入到你定义的卷积神经网络（如上节中的 Net）。
+- **加速训练**：标准化后的数据分布更适合梯度下降优化，加快模型收敛。
+- **提高精度**：统一的数据格式和分布让模型更容易捕捉图像特征，从而提升分类准确率。
+
+#### 展示训练集图片
+
+```python
+import matplotlib.pyplot as plt
+import numpy as np
+
+# 定义展示图片的函数
+def imshow(img):
+    img = img / 2 + 0.5  # 还原标准化后的图像到 [0, 1]
+    npimg = img.numpy()
+    plt.imshow(np.transpose(npimg, (1, 2, 0)))
+    plt.show()
+
+# 从数据加载器中读取一批图片
+dataiter = iter(trainloader)
+images, labels = next(dataiter)
+
+# 展示图片网格
+imshow(torchvision.utils.make_grid(images))
+# 打印对应标签
+print(' '.join(f'{classes[labels[j]]:5}' for j in range(4)))
+```
+
+- **输出示例**：显示 4 张图片及其标签（如 "cat  ship  ship  plane"）。
+
+### 2.2 定义卷积神经网络
+
+定义一个简单的卷积神经网络（CNN），处理 CIFAR10 的 3 通道图像。
+
+```python
+import torch.nn as nn
+import torch.nn.functional as F
+
+class Net(nn.Module):
+    def __init__(self):
+        super(Net, self).__init__()
+        # 第一层卷积：输入 3 通道，输出 6 通道，卷积核 5x5
+        self.conv1 = nn.Conv2d(3, 6, 5)
+        # 最大池化层：2x2 窗口
+        self.pool = nn.MaxPool2d(2, 2)
+        # 第二层卷积：输入 6 通道，输出 16 通道，卷积核 5x5
+        self.conv2 = nn.Conv2d(6, 16, 5)
+        # 全连接层
+        self.fc1 = nn.Linear(16 * 5 * 5, 120)  # 16 个 5x5 的特征图
+        self.fc2 = nn.Linear(120, 84)
+        self.fc3 = nn.Linear(84, 10)  # 输出 10 个类别
+
+    def forward(self, x):
+        # 卷积 -> ReLU 激活 -> 池化
+        x = self.pool(F.relu(self.conv1(x)))
+        x = self.pool(F.relu(self.conv2(x)))
+        # 展平为 1 维向量
+        x = x.view(-1, 16 * 5 * 5)
+        # 全连接层 + ReLU
+        x = F.relu(self.fc1(x))
+        x = F.relu(self.fc2(x))
+        # 最后一层全连接输出
+        x = self.fc3(x)
+        return x
+
+# 实例化模型
+net = Net()
+```
+
+- **类结构**：`Net` 继承自 `nn.Module`，类似于 Java 中的类继承，定义网络的层结构
+- **卷积层**：`nn.Conv2d` 类似 Java 中的对象，处理图像的特征提取
+- **全连接层**：`nn.Linear` 类似于矩阵运算，将特征映射到类别
+
+### 2.3 定义损失函数
+
+用交叉熵损失函数（`CrossEntropyLoss`）和SGD优化器。
+
+```python
+import torch.optim as optim
+
+# 定义损失函数和优化器
+# 交叉熵损失：适用于多分类任务，计算预测概率和真实标签之间的差异
+criterion = nn.CrossEntropyLoss()
+# SGD优化器：通过梯度下降更新模型参数，lr为学习率，momentum增加收敛速度
+optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
+```
+
+### 2.4 在训练集上训练模型
+
+训练模型需要多次迭代（epoch），使用梯度下降优化参数。
+
+```python
+for epoch in range(2):  # 训练 2 个周期  控制训练轮数
+    running_loss = 0.0
+    for i, data in enumerate(trainloader, 0): # 内层循环处理每批数据
+# 训练代码：
+        # 获取输入和标签
+        inputs, labels = data
+
+        # 梯度清零
+        optimizer.zero_grad()
+
+        # 前向传播
+        outputs = net(inputs)
+
+        # 计算损失
+        loss = criterion(outputs, labels)
+
+        # 反向传播和优化
+        loss.backward()
+        optimizer.step()
+
+        # 记录损失
+        running_loss += loss.item()
+        if (i + 1) % 2000 == 0:  # 每 2000 步打印一次
+            print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')
+            running_loss = 0.0
+
+print('Finished Training')
+```
+
+#### 保存模型
+
+训练完成后，保存模型状态字典：
+
+```python
+# 保存路径
+PATH = './cifar_net.pth'
+# 保存模型参数 类似Java的序列化
+torch.save(net.state_dict(), PATH)
+
+# 类似Java的反序列化
+net.load_state_dict(torch.load(PATH))
+```
+
+### 2.5 在测试集上测试模型
+
+展示测试集中的若干图片：
+
+```python
+# 读取测试集数据
+dataiter = iter(testloader)
+images, labels = next(dataiter)
+
+# 展示图片
+imshow(torchvision.utils.make_grid(images))
+# 打印真实标签
+print('GroundTruth: ', ' '.join(f'{classes[labels[j]]:5}' for j in range(4)))
+```
+
+输出示例：`GroundTruth:    cat  ship  ship  plane`
+
+#### 加载模型并预测
+
+加载保存的模型，对测试图片进行分类：
+
+```python
+# 实例化模型
+net = Net()
+# 加载训练好的参数
+net.load_state_dict(torch.load(PATH))
+
+# 预测
+outputs = net(images)
+# 取概率最大的类别作为预测结果
+_, predicted = torch.max(outputs, 1)
+
+# 打印预测结果
+print('Predicted: ', ' '.join(f'{classes[predicted[j]]:5}' for j in range(4)))
+```
+
+输出示例：`Predicted:    cat  ship  ship  plane`
+
+#### 整体测试集表现
+
+计算模型在整个测试集上的准确率：
+
+```python
+correct = 0
+total = 0
+with torch.no_grad():  # 不计算梯度以节省内存
+    for data in testloader:
+        images, labels = data
+        outputs = net(images)
+        _, predicted = torch.max(outputs.data, 1)
+        total += labels.size(0)
+        correct += (predicted == labels).sum().item()
+
+print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total))
+```
+
+输出示例：`Accuracy of the network on the 10000 test images: 53 %`
+
+#### 按类别分析准确率
+
+细化分析模型在每个类别的表现：
+
+```python
+# 创建两个数组来统计每个类别的正确预测数、总数
+class_correct = [0. for _ in range(10)]
+class_total = [0. for _ in range(10)]
+with torch.no_grad():
+    for data in testloader:
+        images, labels = data
+        outputs = net(images)
+        _, predicted = torch.max(outputs, 1)
+        c = (predicted == labels).squeeze()
+        for i in range(4):  # 每次处理 4 张图片
+            label = labels[i]
+            class_correct[label] += c[i].item()
+            class_total[label] += 1
+
+for i in range(10):
+    print('Accuracy of %5s : %2d %%' % (classes[i], 100 * class_correct[i] / class_total[i]))
+```
+
+输出示例：
+
+```
+Accuracy of plane : 62 %
+Accuracy of   car : 62 %
+Accuracy of  bird : 45 %
+Accuracy of   cat : 36 %
+Accuracy of  deer : 52 %
+Accuracy of   dog : 25 %
+Accuracy of  frog : 69 %
+Accuracy of horse : 60 %
+Accuracy of  ship : 70 %
+Accuracy of truck : 48 %
+```
+
+## 3 在 GPU 上训练模型
+
+为加速训练，可将模型和数据转移到GPU。
+
+定义设备并检查是否可用 CUDA：
+
+```python
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+print(device)
+```
+
+输出示例：`cuda:0`（若 GPU 可用）或 `cpu`（若无 GPU）。
+
+将模型和数据转移到GPU：
+
+```python
+# 将模型转移到 GPU
+net.to(device)
+
+# 训练时将输入和标签转移到 GPU
+inputs, labels = data[0].to(device), data[1].to(device)
+```
+
+确保你的环境安装了 CUDA 支持，并更新 PyTorch 为 GPU 版本。
+
+## 4 总结
+
+### 分类器的任务和数据样式
+
+- **任务**：使用神经网络分类器对 CIFAR10 数据集中的图像进行分类，判断它们属于 10 个类别之一
+- **数据**：CIFAR10 数据集包含 10 个类别的 3 × 32 × 32 彩色图像
+
+### 训练分类器的步骤
+
+1. **下载数据集**：使用 `torchvision` 下载 CIFAR10 数据集，并预处理为张量格式
+2. **定义网络**：构建一个卷积神经网络（CNN），包含卷积层、池化层和全连接层
+3. **定义损失和优化**：使用交叉熵损失函数和 SGD 优化器
+4. **训练模型**：在训练集上进行多次迭代，优化模型参数
+5. **测试模型**：在测试集上评估模型性能，计算准确率和按类别分析
+
+### 在 GPU 上训练模型
+
+- **设备选择**：使用 `torch.device` 选择 CPU 或 GPU
+- **模型转移**：将模型和数据转移到 GPU 上以加速训练
\ No newline at end of file
diff --git a/docs/md/AI/ml/what-is-neural-network.md b/docs/md/AI/ml/what-is-neural-network.md
index 3e8c36384..69d0c2e0f 100644
--- a/docs/md/AI/ml/what-is-neural-network.md
+++ b/docs/md/AI/ml/what-is-neural-network.md
@@ -114,11 +114,11 @@
 
 ## 5 咋训练？
 
-神经网络训练是教授神经网络执行任务的过程。神经网络通过首先处理几大组标记或未标记数据来进行学习。通过使用这些示例，它们可以更准确地处理未知输入。
+神经网络训练是教授神经网络执行任务的过程。神经网络通过首先处理几大组标记或未标记数据来进行学习。通过使用这些示例，可更准确地处理未知输入。
 
 ### 5.1 有监督学习
 
-在有监督学习中，数据科学家为人工神经网络提供标记数据集，这些数据集提前提供正确答案。例如，面部识别领域内的某项深度学习网络训练首先处理数十万张人脸图像，使用各种与种族、国家/地区或情绪相关的术语描述每幅图像。
+数据科学家为人工神经网络提供标记数据集，这些数据集提前提供正确答案。如面部识别领域内的某项深度学习网络训练首先处理数十万张人脸图像，使用各种与种族、国家/地区或情绪相关的术语描述每幅图像。
 
 该神经网络将通过这些提前提供正确答案的数据集慢慢构建知识。在该网络完成训练后，即可开始对以前未处理过的新人脸图像进行关于种族或情绪的猜测。
 
@@ -128,13 +128,13 @@
 
 ### 6.1 机器学习 V.S 深度学习
 
-传统的机器学习方法需要人类为机器学习软件提供输入，才能充分发挥作用。数据科学家人工确定此类软件必须分析的相关特征的集合。这会限制此类软件的能力，使创造和管理过程变得非常繁琐。
+传统机器学习需人类为机器学习软件提供输入，才能充分发挥作用。人工确定此类软件必须分析的相关特征的集合。这会限制此类软件的能力，使创造和管理过程繁琐。
 
-另一方面，在深度学习中，数据科学家只向软件提供原始数据。深度学习网络自行推导特征，并且更独立地学习。它可以分析非结构化数据集（如文本文档），确定优先考虑哪些数据属性，并能解决更复杂的问题。
+深度学习中，数据科学家只向软件提供原始数据。深度学习网络自行推导特征，并更独立学习。它可分析非结构化数据集（如文本文档），确定优先考虑哪些数据属性，并能解决更复杂问题。
 
-例如，如正在训练某一机器学习软件正确识别宠物的图像，需要采取以下步骤：
+如正在训练某一机器学习软件正确识别宠物的图像的步骤：
 
-- 手动查找和标记数千张宠物图像，如猫、狗、马、仓鼠、鹦鹉等。
-- 告诉机器学习软件需要寻找哪些特征，使其能够使用排除法来识别图像。例如，它可能会计算腿的数量，然后检查眼睛形状、耳朵形状、尾巴、皮毛等。
+- 手动查找和标记数千张宠物图像，如猫、狗、马、仓鼠、鹦鹉等
+- 告诉机器学习软件需寻找哪些特征，使其能用排除法识别图像。如它可能会计算腿的数量，然后检查眼睛形状、耳朵形状、尾巴、皮毛等
 - 手动评估和更改标记的数据集，以提高软件的准确性。例如，如果您的训练集包含过多黑猫图片，则软件能够正确识别黑猫，而不能正确识别白猫。
-- 但在深度学习中，神经网络将处理所有图像，并自动判断他们需要首先分析腿的数量和面部形状，然后查看尾巴，最后正确识别图像中的动物。
\ No newline at end of file
+- 但在深度学习中，神经网络将处理所有图像，并自动判断他们需要首先分析腿的数量和面部形状，然后查看尾巴，最后正确识别图像中的动物
\ No newline at end of file
diff --git a/docs/md/AI/ml/what-is-tensor.md b/docs/md/AI/ml/what-is-tensor.md
new file mode 100644
index 000000000..44446852d
--- /dev/null
+++ b/docs/md/AI/ml/what-is-tensor.md
@@ -0,0 +1,116 @@
+# Java工程师如何理解张量？
+
+刚接触 AI 和 PyTorch，理解 “张量 (Tensor)” 是入门关键。
+
+可将 PyTorch 中的张量理解为 Java 的多维数组，但它比普通的 Java 数组强大得多，尤其在 AI 和深度学习领域。
+
+## 1 张量（Tensor）  VS  Java 数组/列表
+
+Java常用数组和列表来存储数据，如 `int[]`, `double[][]`, `List<String>`, `ArrayList<Integer>` 等。存储一系列相同类型的数据。
+
+PyTorch的张量本质也是存储数值数据，就像Java数组一样，它可以是：
+
+- 标量（Scalar）：一个单独的数字，类似Java的`int`, `float`, `double` 等基本数据类型。
+
+- 向量（Vector）：一维数组，类似Java的`int[]` 或 `List<Integer>`。 如： `[1, 2, 3]`, `[2.5, 3.5, 4.0]`
+
+- 矩阵（Matrix）：二维数组，类似Java的`int[][]`或 `List<List<Integer>>`
+
+- 更高维度的数组：张量可以是三维、四维甚至更高维数组，这在深度学习很常见，用来表示更复杂的数据结构
+
+### 核心区别和优势
+
+| 特性         | Java 数组/列表 (Array/List)               | PyTorch 张量 (Tensor)              |
+| ------------ | ----------------------------------------- | ---------------------------------- |
+| **数据类型** | 基本数据类型, 对象引用                    | 数值类型 (浮点数, 整数等)          |
+| **运算性能** | CPU 运算为主                              | **GPU 加速运算！**                 |
+| **功能**     | 数据存储为主                              | **数据存储 + 高效运算 + 自动求导** |
+| **动态性**   | 数组大小固定 (Array)，列表大小可变 (List) | 张量形状可灵活变换 (通过 `view()`) |
+| **底层实现** | Java 虚拟机                               | C++/CUDA (针对 GPU 优化)           |
+
+## 2 “张量” 专业解释
+
+张量是**多维数组的泛化**。 它是一个可表示标量、向量、矩阵及更高维度数据的数学对象。
+
+PyTorch 中，张量是其核心数据结构，表示神经网络的输入、输出和参数。
+
+## 3 张量的维度（Dimensions/Rank）
+
+张量的维度也称轴 (axis) 或秩 (rank)。其决定张量可表示的数据的结构。
+
+### 0维张量（标量）
+
+只有一个数值，维度为0。
+
+```python
+scalar_tensor = torch.tensor(5)
+print(scalar_tensor.ndim)  # 输出维度: 0
+```
+
+### 1维张量（向量）
+
+一列或一行数值，维度为1。
+
+```Python
+vector_tensor = torch.tensor([1, 2, 3])
+print(vector_tensor.ndim)  # 输出维度: 1
+print(vector_tensor.shape) # 输出形状: torch.Size([3])
+```
+
+### 2维张量（矩阵）
+
+行和列组成的表格，维度为2。
+
+```Python
+matrix_tensor = torch.tensor([[1, 2], [3, 4]])
+print(matrix_tensor.ndim)  # 输出维度: 2
+print(matrix_tensor.shape) # 输出形状: torch.Size([2, 2])
+```
+
+### 3维张量（立方体）
+
+可以想象成多个矩阵堆叠在一起，维度为 3。  在图像处理中，彩色图像可用3维张量表示 (高度 x 宽度 x 颜色通道)：
+
+```Python
+tensor_3d = torch.randn(3, 4, 5) # 3个矩阵，每个矩阵 4行 5列
+print(tensor_3d.ndim)     # 输出维度: 3
+print(tensor_3d.shape)    # 输出形状: torch.Size([3, 4, 5])
+```
+
+## 4 张量的数据类型（Data Types）
+
+就像 Java 中有 `int`, `float`, `double` 等数据类型一样，PyTorch 张量也有不同的数据类型，如：
+
+- `torch.float32` 或 `torch.float`:  32 位浮点数 (单精度浮点数)，常用。
+- `torch.float64` 或 `torch.double`: 64 位浮点数 (双精度浮点数)，精度更高，但更耗内存和计算资源。
+- `torch.float16` 或 `torch.half`: 16 位浮点数 (半精度浮点数)，更节省内存和加速计算，但精度较低。
+- `torch.int32` 或 `torch.int`:  32 位整数。
+- `torch.int64` 或 `torch.long`:  64 位整数 (长整型)，常用表示索引等。
+- `torch.uint8`:  8 位无符号整数 (0-255)，常用于图像像素表示。
+- 等等...
+
+代码示例中看到的 `dtype=torch.long`, `dtype=torch.double`, `dtype=torch.float` 就是指定张量的数据类型。  选择合适的数据类型对于性能和精度至关重要。
+
+## 5 GPU 加速（GPU Acceleration）
+
+**这是 PyTorch 张量最核心的优势！**  普通的 Java 数组和列表主要在 CPU 上进行运算，而 PyTorch 张量可以轻松地转移到 GPU 上进行加速运算。
+
+GPU (图形处理器)  特别擅长并行计算，而神经网络的训练和推理包含大量的矩阵运算，非常适合 GPU 并行加速。  使用 GPU 可以大幅度提升深度学习模型的训练和推理速度。
+
+代码示例中看到的 `.to(device)` 方法和 `torch.device("cuda")`  就是用来将张量转移到 GPU 上的。
+
+## 6 张量在深度学习中的应用
+
+在深度学习中，张量几乎无处不在：
+
+- **神经网络的权重 (Weights) 和偏置 (Biases):**  模型的参数通常用张量表示。
+- **输入数据 (Images, Text, Audio 等):**  输入数据被转换成张量喂给神经网络。例如，图像可以表示为 3 维张量 (高度 x 宽度 x 颜色通道)。
+- **神经网络的中间层输出 (Activations):**  每一层神经网络的输出也是张量。
+- 梯度 (Gradients)：在反向传播过程中计算的梯度也是张量，用于更新模型的参数。
+
+## 7 总结
+
+- **把 PyTorch 张量理解为 “GPU 加速的，功能更强大的多维数组”**  是一个很好的入门方式。
+- 张量是 PyTorch 的核心数据结构，用于存储数值数据并进行高效的数学运算，尤其擅长 GPU 加速的矩阵运算。
+- 理解张量的维度、数据类型和 GPU 加速特性，是学习 PyTorch 和深度学习的基础。
+- 作为 Java 工程师，可将张量类比为 Java 中的数组/列表，但要记住张量在 AI 领域的独特价值和优势。
\ No newline at end of file
diff --git a/docs/md/DDD/domain-service.md b/docs/md/DDD/domain-service.md
new file mode 100644
index 000000000..5ed525ec4
--- /dev/null
+++ b/docs/md/DDD/domain-service.md
@@ -0,0 +1,455 @@
+# 领域服务
+
+## 1 前言
+
+领域中的服务表示一个无状态操作，以实现特定于某领域的任务。
+
+当某操作不适合放在聚合、值对象时，最好的便是领域服务。有时倾向于使用聚合根的静态方法实现这些这些操作，但在DDD中，这是个坏味道哦。
+
+### 1.1 案例
+
+Product维护一个Backlogitem实例集，该建模可计算一个Product总业务优先级：
+
+```java
+public class Product extends ConcurrencySafeEntity {
+    
+    private Set<BacklogItem> backlogitems;
+  
+  	// 只需遍历所有Backlogitem实例，计算总业务优先级
+    // 适当使用了值对象BusinessPriorityTotals
+    public static BusinessPriorityTotals businessPriorityTotals() {
+    }
+}
+```
+
+起初完美。后分析聚合，发现Product对象过大，而Backlogitem本身就应成为一个聚合。因此，上面businessPriorityTotals方法已不再适用。
+
+#### 使用Repository
+
+由于Product不再包含Backlogitem集合，第一反应用BacklogltemRepository获取Backlogitem实例，好吗？
+
+并不建议，因为**应尽量避免在聚合中使用Repository**。
+
+#### 静态方法
+
+将businessPriorityTotals()声明为static，再将Backlogitem集作入参。这几乎不对方法多少修改，只需传入新参：
+
+```java
+public class Product extends ConcurrencySafeEntity {
+
+   private Set<BacklogItem> backlogitems;
+
+   public static BusinessPriorityTotals businessPriorityTotals(Set<BacklogItem> aBacklogitems) {
+   }
+}
+
+```
+
+但Product是创建该static方法最佳位置？看来要将该方法放在合适地方不易！
+
+由于该方法只用每个Backlogitem中的值对象，方法放在Backlogitem似乎更合适？但这里计算所得业务价值却属Product而非Backlogitem，进退维谷！
+
+架构师发话了：这些问题用个单一建模工具即可解决，领域服务(Domain Service)。
+
+## 2 啥是领域服务
+
+### 2.1 啥不是领域服务?
+
+“服务”？自然想到一个远程客户端与某复杂业务系统交互，该场景基本描述SOA中的一个服务。有多种技术和方法可以实现SOA服务，最终这些服务强调的都是系统层的
+
+- RPC
+- 或MQ
+
+使我们可通过服务与分布在不同地方的系统进行业务交互。但**这些不是领域服务**。不要将领域服务与应用服务混淆：
+
+- 应用服务不处理业务逻辑
+- 但领域服务恰是处理业务逻辑
+- 应用服务是领域模型很自然的客户，也是领域服务的客户
+
+虽然领域服务中有“服务”，但不意味着需要远程的、重量级的事务操作。
+
+## 3 啥时用？
+
+**当领域中的某操作或转换过程不是实体或值对象的职责**，便应将该操作放在一个独立接口，即领域服务。
+
+- 定义接口时要使用模型语言，并确保操作名称是通用语言中的术语
+- 无状态
+
+通常领域模型主要关注特定某领域的业务，领域服务有相似特点。由于领域服务可能在单个原子操作中处理多个领域对象，这将增加领域服务的复杂性。
+
+有时，当**与另一个限界上下文交互**时，领域服务的确需要进行远程操作，但此时重点并非将领域服务作为一个服务provider，而是将其作为RPC客户端。
+
+### 何时一个操作不属实体/值对象？
+
+即何时使用领域服务：
+
+- 执行一个显著的业务操作过程
+- 对领域对象进行转换
+- 以多个领域对象作为输入进行计算，产生一个值对象结果：计算过程应具有“显著的业务操作过程”。这也是领域服务很常见的应用场景，它可能需要多个聚合作为输入。
+
+**当一个方法不便放在实体或值对象，使用领域服务便是最佳解决方案。**
+
+## 4 真需要吗？
+
+别过度使用，只在有必要时才做。过度领域服务，依旧导致贫血领域模型：所有业务逻辑都在领域服务。
+
+## 5 案例
+
+### 5.1 User认证
+
+考虑身份与访问上下文，对一个User进行认证。系统必须对User认证，只有当Tenant处激活状态时才能对User认证。
+
+为何领域服务在此时必要？难道不能简单将该认证操作放在实体？在客户角度，可能这样实现认证：
+
+```java
+// client finds User and asks it to authenticate itself 
+boolean authentic = false;
+
+User user = DomainRegistry
+				.userRepository()
+				.userWithUsername(aTenantld, aUsername);
+if (user != null) {
+	authentic = user.isAuthentic(aPassword);
+}			
+return authentic;
+```
+
+问题在于：
+
+- 客户端需知某些认证细节：他们要找到一个User，再对该User密码匹配
+- 这种方法不能显式表达通用语言：这里询问的是一个User "是否被认证”，但没表达“认证”这个过程。有可能的话，应尽量使建模术语直接表达出团队成员的交流用语
+
+更坏的，这种建模方式不能准确表达团队成员指的“对User进行认证”的过程。它缺少 “检查Tenant否处激活态”这个前提。若一个User所属Tenant处非激活态，便不该对该User进行认证。
+
+解决方法：
+
+```java
+// 客户端查找User,然后User完成自我认证
+boolean authentic = false;
+Tenant tenant =
+    DomainRegistry 
+        .tenantRepository()
+        .tenantOfId(aTenantId);
+
+// 检查Tenant活跃性
+if (tenant != null && tenant.isActive()) {
+    User user =
+        DomainRegistry
+            .userRepository()
+            .userWithUsername(aTenantId, aUsername);
+            
+  	// 将User#isAuthentic换成Tenant#authenticate
+    if (user != null) {
+        authentic = tenant.authenticate(user, aPassword)
+    }
+}
+return authentic
+```
+
+但还有问题：
+
+- 客户端需知更多认证细节，但这些他们不该知。当然，可将**Tenant#isActive**放在**authenticate**，但这不是一个显式模型
+- 此时Tenant需知咋对密码进行操作
+
+回忆认证过程的另一需求：必须对密码进行加密，且不能使用明文密码。
+
+对于以上解决方案，似乎给模型带来太多问题。对于最后一种方案，必须从以下解决办法中选一种：
+
+- 在Tenant中处理对密码的加密，再将加密后的密码传给User。但这违背单一职责原则
+- 由于一个User必须保证对密码的加密，它可能已知一些加密信息。如果这样，可在User上创建一个方法，该方法对明文密码进行认证。但这种方式，认证过程变成Tenant的门面(Facade)，而实际认证功能全在User。另外，User的认证方法须声明为protected，以防外界客户端对认证方法的直接调用
+- Tenant依赖User对密码进行加密，再将加密后的密码与原有密码进行匹配。这种方法似乎在对象协作之间增加额外步骤。此时，Tenant依然需知认证细节
+- 让客户端对密码进行加密，然后将其传给Tenant：导致客户端承载本不该有的职责
+
+以上方法无济于事，同时客户端依旧复杂。强加在客户端的职责应在我们自己的模型中处理。只与领域相关的信息决不能泄漏到客户端。即使客户端是个应用服务，它也不该负责对身份与访问权限的管理。
+
+客户端需要处理的唯一业务职责是：调用单个业务操作，而由该业务操作去处理所有业务细节：
+
+```java
+// 应用服务只用于协调任务
+UserDescriptor UserDescriptor = 
+    DomainRegistry
+        .authenticationService()
+        .authenticate(aTenantId, aUsername, aPassword);
+```
+
+- 简单优雅。客户端只需获取到一个无状态的 Authenticationservice，并调用authenticate。所有认证细节放在领域服务，而非应用服务。在需要时，领域服务可使用任何领域对象完成操作，包括对密码的加密。客户端无需知道任何认证细节。
+- 通用语言也得到满足，将所有领域术语都放在了身份管理领域，而非部分放在领域模型，部分放在客户端
+
+领域服务方法返回一个UserDescirptor值对象，这是一个很小的对象，且安全的。与User相比，它只包含3个关键属性：
+
+```java
+public final class UserDescriptor extends AssertionConcern implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private String emailAddress;
+    private TenantId tenantId;
+
+    private String username;
+}
+```
+
+该UserDescriptor对象可存放在一次Web会话(Session)中。对于作为客户端的应用服务，它可进一步将该UserDescriptor返回给它自己的调用者。
+
+### 5.2 货柜机服务
+
+```java
+/**
+ * @param event 货柜机柜门锁定事件
+ */
+@Transactional
+public void onCabinetLocked(CabinetVendingMachineLockedEvent event) {
+    CabinetVendingMachine cabinet = machineRepository.getCabinetVendingMachineById(event.getMachineId());
+    try {
+        Order order = cabinet.onLocked(event, commodityService);
+        orderRepository.addOrder(order);
+        // machineRepository.updateCabinetVendingMachine(cabinet);
+
+        // RPC
+        UserInfo userInfo = userService.getUserInfo(cabinet.getCurUserOpenId());
+        // RPC
+        payService.chargeForOrder(
+                OrderInfo.Builder()
+                        .machineId(order.getMachineId())
+                        .orderId(order.getOrderId())
+                        .type(order.getType())
+                        .totalAmount(order.totalAmount())
+                        .build(),
+                userInfo
+        );
+        eventBus.post(new OrderCreatedEvent(cabinet.getMachineId(), order));
+    } catch (DomainException e) {
+        if (e.getErrCode() != TradeError.OrderAmountZero) {
+            throw e;
+        }
+    }
+}
+```
+
+若现在需要新增一个营销优惠逻辑，显然不适合放在应用服务层（不该有业务逻辑），同时也不属于userService、payService逻辑，咋办呢？就需要创建一个领域服务了。
+
+```java
+/**
+ * @author JavaEdge
+ */
+@Service
+public class ActivityService {
+
+  public BigDecimal calculateOrderAmount(Order order, UserInfo userInfo) {
+    return BigDecimal.ZERO;
+  }
+}
+
+```
+
+改成如下即可：
+
+```java
+// RPC
+payService.chargeForOrder(
+        OrderInfo.Builder()
+                .machineId(order.getMachineId())
+                .orderId(order.getOrderId())
+                .type(order.getType())
+                // .totalAmount(order.totalAmount())
+                .totalAmount(activityService.calculateOrderAmount(order, userInfo))
+                .build(),
+        userInfo
+);
+```
+
+
+
+## 6 如何建模领域服务？
+
+根据创建领域服务的目的，有时对领域服务进行建模是非常简单的。你需要决定你所创建的领域服务是否需要一个**独立接口**。如果是，你的领域服务接口可能与以下接口相似：
+
+```java
+package com.saasovation.identityaccess.domain.model.identity;
+
+public interface AuthenticationService {
+
+    public UserDescriptor authenticate(
+            TenantId aTenantId,
+            String aUsername,
+            String aPassword);
+}
+```
+
+该接口和那些与身份相关的聚合（比如Tenant, User和Group）定义在相同的模块中，因为Authenticationservice也是一个与身份相关的概念。当前，我们将所有与身份相关的概念都放在identity模块中。该接口定义本身是简单的，只有一个 authenticate方法。
+对于该接口的实现类，我们可以选择性地将其存放在不同地方。如果你正使用依赖倒置原则或六边形架构，那你可能会将这个多少有些技术性的实现类放置在领域模型外。比如，技术实现类可放置在基础设施层的某个模块中。
+
+以下是对该接口的实现：
+
+```java
+/**
+ * @author JavaEdge
+ * @date 2021/1/14
+ */
+public class DefaultEncryptionAuthenticationService implements UserResource.Authenticationservice {
+
+
+    public DefaultEncryptionAuthenticationService() {
+        super();
+    }
+
+
+    @Override
+    public UserDescriptor authenticate(TenantId aTenantld, String aUsername, String aPassword) {
+        // 首先对null参数进行检查
+        // 如果在正常情况下认证失败,那么该方法返回的UserDescriptor将为null
+        if (aTenantld == null) {
+            throw new IllegalArgumentException("Tenantld must not be null.");
+        }
+        if (aUsername == null) {
+            throw new IllegalArgumentException("Username must not be null");
+        }
+        if (aPassword == null) {
+            throw new IllegalArgumentException("Password must not be null.");
+        }
+
+        UserDescriptor userDescriptor = null;
+        Tenant tenant =
+                DomainRegistry
+                        .tenantRepository()
+                        .tenant0fId(aTenantld);
+        if (tenant != null && tenant.isActive()) {
+            String encryptedPassword =
+                    DomainRegistry
+                            .encryptionService().encryptedValue(aPassword);
+            User user =
+                    DomainRegistry
+                            .userRepository()
+                            .userFromAuthenticCredentials(aTenantld, aUsername,
+                                    encryptedPassword);
+            // 检查所获取到的User实例是否为null和是否处激活状态
+            if (user != null && user.isEnabled()) {
+                userDescriptor = user.userDescriptor();
+            }
+        }
+        return userDescriptor;
+    }
+}
+```
+
+在对一个User进行认证时：
+
+- 先根据aTenantld从Tenant的资源库中取出对应的Tenant
+- 如果Tenant存在且处于激活状态，下一步我们将加密传入的明文密码
+  加密在于我们需要通过加密后的密码获取一个User。在获取一个User时，我们不但需要传aTenantld和username，还需要传入加密后的密码进行匹配（对于两个明文相同的密码，加密后也是相同的）。User的资源库将根据这三个参数来定位一个User。
+
+如果用户提交的aTenantld, username和password都正确，我们将获得相应的User实例。但此时我们依然不能对该User进行认证，我们还需要处理最后一条需求：
+
+- 只有在一个User被激活后，我们才能对该User进行认证。
+
+即便我们通过资源库找到了一个User，该User也有可能处于未激活。通过向User添加激活功能，Tenants可从另一层面控制对User的认证。因此，认证过程的最后一步即是检查所获取到的User实例是否为null和是否处激活状态。
+
+## 7 独立接口有必要吗
+
+这里的Authenticationservice接口并没有一个技术上的实现，真的有必要为其创建一个独立接口并将其与实现类分离在不同的层和模块中吗？
+没必要。我们只需要创建一个实现类即可，其名字与领域服务的名字相同。
+
+对于领域服务来说，以上的例子同样是可行的。我们甚至会认为这样的例子更合适，因为我们知道不会再有另外的实现类。
+**但不同的租户可能有不同的安全认证标准，所以产生不同的认证实现类也是有可能的**。
+然而此时，SaaSOvation的团队成员决定弃用独立接口，而是采用了上例中的实现方法。
+
+## 8 给领域服务的实现类命名
+
+常见的命名实现类的方法便是给接口名加上Impl后缀。按这种方法，我们的认证实现类为AuthenticatioinServicelmpl。实现类和接口通常被放在相同包下，这是一种好的做法吗？
+
+如果你釆用这种方式来命名实现类，这往往意味着你根本就不需要一个独立接口。因此，在命名一个实现类时，我们需要仔细地思考。这里的 AuthenticationServicelmpI并不是好的实现类名，而DefaultEncryptionAuthenticationService也不见得能好到哪。
+
+基于这些原因，团队决定去除独立接口，而直接使用Authenticationservice作为实现类。
+
+如果领域服务具有多个实现类，应根据各种实现类的特点进行命名。而这往往又意味着在你的领域中存在一些特定的行为功能。
+
+> 有人认为采用相似名字命名接口和实现类有助代码浏览和定位。但还有人认为将接口和实现类放在相同包中会使包变很大，这是种糟糕的模块设计，因此偏向于将接口和实现类放在不同包，**依赖倒置原则**便是如此：将接口Encryptionservice放在领域模型，而将 MD5EncryptionService放在基础设施层。
+
+对于非技术性的领域服务，去除独立接口不会破坏可测试性。因为这些领域服务所依赖的所有接口都可以注入进来或通过服务工厂(Service Factory)进行创建。
+非技术性的领域服务，比如计算性的服务等都必须进行正确性测试。
+
+有时，领域服务总是和领域密切相关，并且不会有技术性的实现，或者不会有多个实现，此时采用独立接口便只是一个风格上的问题。
+独立接口对于解偶来说是有用处的，此时客户端只需要依赖于接口，而不需要知道具体的实现。但是，如果我们使用了依赖注入或者工厂，即便接口和实现类是合并在一起的，我们依然能达到这样的目的。
+
+以下的DomainRegistry可在客户端和服务实现之间进行解耦，此时的DomainRegistry便是一个服务工厂。
+
+```java
+//DomainRegistry在客户端与具体实现之间解耦
+UserDescriptor userDescriptor =
+	DomainRegistry
+		.authenticationservice()
+		.authenticate(aTenantld, aUsername, aPassword);
+```
+
+或者，如果你使用的是依赖注入，你也可以得到同样的好处:
+
+```java
+public class SomeApplicationService ... {
+	@Autowired
+	private Authenticationservice authenticationservice;
+```
+
+依赖倒置容器（比如Spring）将完成服务实例的注入工作。由于客户端并不负责服务的实例化，它并不知道接口类和实现类是分开的还是合并。
+与服务工厂和依赖注入相比，有时他们更倾向于将领域服务作为构造函数参数或者方法参数传入,因为这样的代码拥有很好的可测试性，甚至比依赖注入更加简单。也有人根据实际情况同时采用以上三种方式，并且优先采用基于构造函数的注入方式。本章中有些例子使用了DomainRegistry,但这并不是说我们应该优 先考虑这种方式。互联网上很多源代码例子都倾向于使用构造函数注入，或者直接将领域服务作为方法参数传入。
+
+## 9 计算案例
+
+该例子来自于敏捷项目管理上下文。该例子中的领域服务从多个聚合的值对象中计算所需结果。
+目前来看，我们没有必要使用独立接口。该领域服务总是采用相同方式进行计算。除非有需求变化，不然我们没必要分离接口和实现。
+
+
+上很多源代码例子都倾向于使用构造函数注入，或者直 接将领域服务作为方法参数传入。
+中有些例子使用了DomainRegistry,但这并不是说我们应该优 先考虑这种方式
+
+釆用领域服务比静态方法更好。此时的领域服务和当前的静态方法完成类似功能：计算并返回一个BusinessPriorityTotals值对象。但是，该领域服务还需要完 成额外的工作，包括找到一个Product中所有未完成的Backlogitem, 然后单独计算它们的BusinessPriority。
+
+BacklogltemRepository用于查找所有未完成的Backlogitem实例。一个未完成的Backlogitem是拥有Planned、Scheduled或Committed状态的Backlogitem，而状态为Done或Removed的Backlogitem则是已完成的。
+不推荐将资源库对 Backlogitem的获取放在聚合实例，相反，将其放在领域服务中则是一种好的做法。
+
+有了一个Product下所有未完成的BacklogItem，我们便可对遍历之并计算BusinessPriority总和。总和进一步用于实例化一个 BusinessPriorityTotals，然后返回给客户端。
+领域服务不一定非常复杂，即使有时的确会出现这种情况。上面的例子则是非常简单的。请注意，在上面的例子中，绝对不能将业务逻辑放到应用层。即使你认 为这里的for循环非常简单，它依然是业务逻辑。当然，还有另外的原因：
+
+实例化BusinessPriorityTotals时，它的totalValue属性由totalBenefit和 totalPenalty相加所得。这是和领域密切相关的业务逻辑，自然不能泄漏到应用层。你可能会说，可以将totalBenefit和totalPenalty作为两个参数分别传给应用服务。虽然这是一种改进模型的方式，但这也并不意味着将剩下的计算逻辑放在应用层就是合理的。
+
+```java
+BusinessPriorityTotals businessPriorityTotals =
+  new BusinessPriorityTotals(
+      totalBenefit,
+      totalPenalty,
+       // aTotalValue
+      totalBenefit + totalPenalty,
+      totalCost,
+      totalRisk);
+return businessPriorityTotals;
+```
+
+```java
+public class Productservice ... {
+	private BusinessPriorityTotals productBusinessPriority(
+		String aTenantld,
+		String aProductld) {
+		BusinessPriorityTotals productBusinessPriority = DomainRegistry
+		.businessPrioritycalculator()
+		.businessPriorityTotals(
+		new Tenantld(aTenantld),
+		new Productld(aProductld));
+		return productBusinessPriority;
+	}
+}
+```
+
+上例中，应用层中的一个私有方法负责获取一个Product的总业务优先级。该方法可能只需要向Productservice的客户端（比如用户界面）提供BusinessPriorityTotals 的部分数据即可。
+
+## 转换服务
+
+在基础设施层中，更加技术性的领域服务通常是那些用于集成目的的服务。 正是这个原因，我们将与此相关的例子放在了集成限界上下文中，你将看到领域服务接口、实现类、适配器和不同的转换器。
+
+## 为领域服务创建一个迷你层
+
+有时可能希望在实体和值对象上创建一个领域服务的迷你层。但这样可能导致贫血领域模型。
+但对有些系统，为领域服务创建一个不至于导致贫血领域模型的迷你层很值得。这取决于领域模型的特征。对于本书的身份与访问上下文来说，这样的做法是非常有用的。
+如果你正工作在这样的领域里，并且你决定为领域服务创建一个迷你层，这样的迷你层不同于应用层中的服务。
+应用服务关心的是事务和安全，但这些不该出现在领域服务。
+
+
+> 虽然我们不会将业务逻辑放在应用层，但是应用层却可以作为领域服务的客户端。
\ No newline at end of file
diff --git "a/docs/md/design/01-\345\215\225\344\270\200\350\201\214\350\264\243\345\216\237\345\210\231.md" "b/docs/md/design/01-\345\215\225\344\270\200\350\201\214\350\264\243\345\216\237\345\210\231.md"
index 07969b01f..c76d3e65d 100644
--- "a/docs/md/design/01-\345\215\225\344\270\200\350\201\214\350\264\243\345\216\237\345\210\231.md"
+++ "b/docs/md/design/01-\345\215\225\344\270\200\350\201\214\350\264\243\345\216\237\345\210\231.md"
@@ -258,7 +258,7 @@ public interface ICourseManager {
 
 用户信息维护类图：
 
-![](https://img-blog.csdnimg.cn/20210705144728253.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_16,color_FFFFFF,t_70)
+![](https://i-blog.csdnimg.cn/blog_migrate/5deeca7f68d19df458becc362ff3ee68.png)
 
 #### 问题
 
@@ -272,7 +272,7 @@ public interface ICourseManager {
 
 职责划分后的类图：
 
-![](https://img-blog.csdnimg.cn/20210705145341688.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_16,color_FFFFFF,t_70)
+![](https://i-blog.csdnimg.cn/blog_migrate/1b2bb18520dbb6e62c6e42ff112f6dab.png)
 
 重新拆分成两个接口：
 
@@ -284,7 +284,7 @@ public interface ICourseManager {
 面向接口编程，所以产生UserInfo对象后，可将其当IUserBO接口使用，也可当IUserBiz接口使用，取决于使用场景：
 
 - 获得用户信息，就当IUserBO的实现类
-- 维护用户的信息，就当IUserBiz的实现类
+- 维护用户的信息，就当IUserBiz的实现类
 
 ```java
 IUserInfo userInfo = new UserInfo();
@@ -308,7 +308,24 @@ userBiz.deleteUser();
 
 项目中常用的SRP类图：
 
-![](https://img-blog.csdnimg.cn/img_convert/ddf683f0892e2a6a08726c7642b9dd25.png)
+```mermaid
+classDiagram
+
+class IUserBO {
+    <<interface>>
+}
+
+class IUserBiz {
+    <<interface>>
+}
+
+class UserBO
+class UserBiz
+
+UserBO ..|> IUserBO
+UserBiz ..|> IUserBiz
+IUserBiz ..> IUserBO
+```
 
 以上我们把一个接口拆分成两个接口的动作，就是依赖SRP，单一职责原则的定义：应有且仅有一个原因，引起类的变更。
 
@@ -318,8 +335,6 @@ userBiz.deleteUser();
 
 #### 原始接口
 
-![](https://img-blog.csdnimg.cn/img_convert/a7fab40bd3a15f919374e59ecb03b59a.png)
-
 ```java
 package com.javaedge.design.principle.singleresp.phone;
 
@@ -370,9 +385,7 @@ public interface IPhone {
 
 #### 职责分明的电话类图
 
-
-
-![](https://img-blog.csdnimg.cn/img_convert/a32b12f5a750fccb83178a41a30131d5.png)
+![](https://i-blog.csdnimg.cn/blog_migrate/3e6994429f52a61bee65e1b37e572f8b.png)
 
 完全满足SRP，每个接口职责分明，结构清晰，但肯定不会采用。一个 Phone类要把ConnectionManager、DataTransfer组合才能使用。组合是一种强耦合关系，共同生命周期，这样强耦合不如使用接口实现，而且还多了俩类。
 
@@ -380,7 +393,7 @@ public interface IPhone {
 
 简洁清晰、职责分明的电话类图：
 
-![](https://img-blog.csdnimg.cn/img_convert/6440c34103fafd869b635156ddff80cf.png)
+![](https://i-blog.csdnimg.cn/blog_migrate/6370310ed944f47c2d3166cd368a649f.png)
 
 一个类实现了两个接口，把两个职责融合在一个类中。
 你可能说Phone有两个原因引起变化呀！是，但别忘我们是面向接口编程，我们对外公布的是接口而非实现类。而且，若真要实现类的SRP，还必须使用组合模式，这会引起类间耦合过重、类的数量增加等问题，人为增加设计复杂性。
@@ -395,44 +408,96 @@ public interface IPhone {
 
 SRP提出编写程序的标准，用“职责”或“变化原因”来衡量接口或类设计得是否优良，但“职责”和“变化原因”都不可度量，因项目、环境而异。
 
-### 2.5 项目管理
+### 2.5 项目管理工具
+
+设计如下用户类，有用户信息管理、项目管理：
+
+```java
+class User {
 
-开发一个项目管理工具，可能设计如下用户类，有用户信息管理、项目管理：
+    // 修改密码
+    void changePassword (String password);
 
-![](https://img-blog.csdnimg.cn/ac02aaf76ba14b9ab65300e770cd750c.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_SmF2YUVkZ2U=,size_15,color_FFFFFF,t_70,g_se,x_16)
+    // 加入一个项目
+    void joinProject (Project project);
 
+    // 接管一个项目,成为管理员
+    void takeOverProject (Project project);
 
+}
+```
 
 新需求：每个用户都能设置电话号码，于是新增方法
 
-![](https://img-blog.csdnimg.cn/450501655028452b856e417b817f6657.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_SmF2YUVkZ2U=,size_19,color_FFFFFF,t_70,g_se,x_16)
+```java
+class User {
+
+    void changePassword(String password);
+
+    void joinProject(Project project);
+
+    void takeOverProject(Project project);
+
+    // 设置电话号码
+    void changePhoneNumber(PhoneNumber phoneNumber);
+
+}
+```
 
 又来新需求：查看一个用户加入了多少个项目
 
-![](https://img-blog.csdnimg.cn/20a70e69316e47d7a8a671f8554b1524.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_SmF2YUVkZ2U=,size_19,color_FFFFFF,t_70,g_se,x_16)
+```java
+class User {
 
-就这样，几乎每个和用户沾边的需求，你都改user类，导致：
+    void changePassword(String password);
+
+    void joinProject(Project project);
+
+    void takeOverProject(Project project);
+
+    void changePhoneNumber(PhoneNumber phoneNumber);
+
+    // 用户加入了多少项目
+    int countProject();
+
+}
+```
+
+几乎每个和用户沾边的需求，你都改user类，导致：
 
 - User类一直膨胀
 - 内部实现越来越复杂
 
 这个类变动的频繁程度显然不理想，因为诱导变动的需求太多：
 
-- 为什么要增加电话号码？
-  用户管理的需求。用户管理的需求还会有很多，比如，用户实名认证、用户组织归属等
-- 为什么要查看用户加入多少项目？
-  项目管理的需求。项目管理的需求还会有很多，比如，团队管理、项目权限等。
+- 为啥要增加电话号码？用户管理的需求。用户管理的需求还会有很多，比如，用户实名认证、用户组织归属等
+- 为啥要查看用户加入多少项目？项目管理的需求。项目管理的需求还会有很多，比如，团队管理、项目权限等。
 
 两种完全不同的需求，但你都改同一个类，所以，User类无法稳定。最好拆分不同需求引起的变动。用户管理、项目管理两种不同需求，User拆成两个类：
 
 - 用户管理类需求放到User
 - 项目管理类的需求放到Member
 
+```java
+// 用户类
+class User {
+
+    // 修改密码
+    void changePassword(String password);
 
+}
 
-![](https://img-blog.csdnimg.cn/92686f9f4c774c909e7aa4227c44f0aa.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_SmF2YUVkZ2U=,size_15,color_FFFFFF,t_70,g_se,x_16)
+// 项目成员类
+class Member {
 
+    // 加入一个项目
+    void joinProject(Project project);
 
+    // 接管一个项目,成为管理员
+    void takeOverProject(Project project);
+
+}
+```
 
 如此二者各自变动的理由就少了：
 
@@ -506,23 +571,40 @@ SRP还能指导我们在不同的子系统之间进行职责分配。所以，
 
 国内的技术人员地位和话语权都是最低的，在项目中需要考虑环境、工作量、人员的技术水平、硬件的资源情况等，最终妥协经常违背单一职责原则。
 
-单一职责适用于接口、类，同时也适用于方法。一个方法尽可能做一件事情，比如一个方法修改用户密码，不要把这个方法放到“修改用户信息”方法中，这个方法的颗粒度很粗.
+单一职责适用于接口、类，同时也适用于方法。一个方法尽可能做一件事情，比如一个方法修改用户密码，不要把这个方法放到“修改用户信息”方法中，这个方法的颗粒度很粗。
+
+一个方法承担多个职责：
 
-- 一个方法承担多个职责
-  ![](https://img-blog.csdnimg.cn/img_convert/5cebbf619d200508262e3ddd37e4251e.png)
+```mermaid
+classDiagram
+    class IUserManager {
+        <<interface>>
+        +void changeUser(IUserBO userBO, String... changeOptions)
+    }
+```
 
 在IUserManager中定义了一个方法changeUser，根据传递的类型不同，把可变长度参数changeOptions修改到userBO这个对象上，并调用持久层的方法保存到数据库中。
 
 这种代码看到，直接要求其重写即可：方法职责不清晰，不单一，不要让别人猜测这个方法可能是用来处理什么逻辑的。
 
-比较好的设计如下：
+比较好的设计，一个方法承担一个职责：
+
+```mermaid
+classDiagram
+    class IUserManager {
+        <<interface>>
+        +void changeUserName(String newUserName)
+        +void changeHomeAddress(String newHomeAddress)
+        +void changeOfficeTel(String telNumber)
+    }
+```
+
 
-一个方法承担一个职责
-![](https://img-blog.csdnimg.cn/img_convert/21d3889d0f1a23a242e5a24cc464dea5.png)
-若要修改用户名称，就调用changeUserName方法
-要修改家庭地址，就调用changeHomeAddress方法
-要修改单位电话，就调用changeOfficeTel方法
-每个方法的职责非常清晰明确，不仅开发简单，而且日后的维护也非常容易。
+
+若修改用户名称，changeUserName
+修改家庭地址，changeHomeAddress
+修改单位电话，changeOfficeTel
+每个方法职责清晰明确，开发简单，维护也容易。
 
 ## 5 最佳实践
 
@@ -533,6 +615,6 @@ SRP确实受非常多因素的制约，纯理论地来讲，这个原则很好
 - 接口一定要做到单一职责
 - 类的设计尽量做到只有一个原因引起变化
 
-> 参考
->
-> - 《设计模式之蝉》
\ No newline at end of file
+参考：
+
+- 《设计模式之蝉》
\ No newline at end of file
diff --git a/package.json b/package.json
index e5ed39101..083eb6098 100644
--- a/package.json
+++ b/package.json
@@ -10,6 +10,7 @@
     "@vuepress/plugin-back-to-top": "^1.8.2",
     "@vuepress/plugin-google-analytics": "^1.8.2",
     "@vuepress/plugin-medium-zoom": "^1.8.2",
+    "mermaid": "^7.1.2",
     "vuepress": "^1.9.10",
     "vuepress-plugin-seo": "^0.1.4",
     "vuepress-plugin-sitemap": "^2.3.1",
@@ -29,6 +30,7 @@
     "vuepress-plugin-code-copy": "^1.0.6",
     "vuepress-plugin-copyright": "^1.0.2",
     "vuepress-plugin-img-lazy": "^1.0.4",
+    "vuepress-plugin-mermaidjs": "^2.0.0-beta.2",
     "vuepress-plugin-table-of-contents": "^1.1.7"
   }
 }

From 76f45be5c78b2832aafd35d50e19d4a9cf5fec60 Mon Sep 17 00:00:00 2001
From: JavaEdge <sss2855845850@gmail.com>
Date: Wed, 5 Mar 2025 18:02:44 +0800
Subject: [PATCH 07/20] =?UTF-8?q?docs:=E6=9B=B4=E6=96=B0=E4=B8=93=E6=A0=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/.vuepress/config.js                      |   8 +-
 .../md/12306/12306-basic-info.md              |   0
 docs/md/AI/ai-agent-is-coming.md              | 181 ++++++++++++++++++
 docs/md/AI/software-development-in-AI2.md     | 142 ++++++++++++++
 .../md/spark/spark-ml-basic-statistics.md     |  49 +++--
 5 files changed, 350 insertions(+), 30 deletions(-)
 rename "docs/md/12306/\351\241\271\347\233\256\344\273\213\347\273\215.md" => docs/md/12306/12306-basic-info.md (100%)
 create mode 100644 docs/md/AI/ai-agent-is-coming.md
 create mode 100644 docs/md/AI/software-development-in-AI2.md
 rename "docs/md/spark/06-\345\237\272\347\241\200\347\273\237\350\256\241\346\250\241\345\235\227.md" => docs/md/spark/spark-ml-basic-statistics.md (70%)

diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index cb0575f94..e6fb62388 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -248,7 +248,7 @@ module.exports = {
                                 text: '12306',
                                 items: [{
                                     text: '项目介绍',
-                                    link: '/md/12306/项目介绍.md'
+                                    link: '/md/12306/12306-basic-info.md'
                                 }]
                             },
                             {
@@ -1830,7 +1830,7 @@ module.exports = {
                             collapsable: false,
                             sidebarDepth: 0,
                             children: [
-                                "项目介绍.md",
+                                "12306-basic-info",
                             ]
                         },
                         {
@@ -2292,6 +2292,8 @@ module.exports = {
                                 "Complex-SQL-Joins-with-LangGraph-and-Waii",
                                 "AI Agent应用出路到底在哪？",
                                 "building-effective-agents",
+                                "ai-agent-is-coming",
+                                "software-development-in-AI2",
                             ]
                         },
 
@@ -2397,7 +2399,7 @@ module.exports = {
                             collapsable: false,
                             sidebarDepth: 0,
                             children: [
-                                "06-基础统计模块",
+                                "spark-ml-basic-statistics",
                                 "07-回归算法",
                             ]
                         },
diff --git "a/docs/md/12306/\351\241\271\347\233\256\344\273\213\347\273\215.md" b/docs/md/12306/12306-basic-info.md
similarity index 100%
rename from "docs/md/12306/\351\241\271\347\233\256\344\273\213\347\273\215.md"
rename to docs/md/12306/12306-basic-info.md
diff --git a/docs/md/AI/ai-agent-is-coming.md b/docs/md/AI/ai-agent-is-coming.md
new file mode 100644
index 000000000..6bffe621d
--- /dev/null
+++ b/docs/md/AI/ai-agent-is-coming.md
@@ -0,0 +1,181 @@
+# AI Agent时代已至，然后呢？
+
+## 0 引言
+
+![](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/blog/190_ethics-soc-7/huggy_the_pooh.png)
+
+LLM能力的突然快速进步——例如生成流畅的句子和在基准测试中获得越来越高的分数——使得AI开发者和企业都在关注下一步的发展: 下一个突破性技术会是什么？最近迅速崛起的一项技术是 “AI Agent”，这是一种能够在数字世界中按照部署者的目标采取行动的系统。如今大多数AI Agent都是通过将大语言模型整合到可以执行多种功能的更大系统中构建的。这波新技术的一个基本理念是，计算机程序不再需要作为受人类控制的工具而局限于专门的任务: 它们现在可以在没有人类输入的情况下组合多个任务。
+
+这一转变标志着系统能力的根本性转变，使其能够在非确定性环境中创建特定于上下文的计划。许多现代AI Agent不仅仅执行预定义的操作，而是被设计用来分析新情况、制定相关目标，并采取之前未定义的行动来实现目标。
+
+本文概述AI Agent的概念，并详细说明其中涉及的伦理价值，记录AI Agent在收益和风险方面的权衡。然后建议前进的道路，以实现AI Agent为社会带来尽可能多的益处的未来。关于在现代AIGC之前编写的代理介绍 (在今天仍然适用)，请参阅 [Wooldridge and Jennings, 1995](https://core.ac.uk/download/pdf/1498750.pdf)。
+
+分析表明，系统的自主程度越高，对人的风险就越大: 用户让渡的控制权越多，系统带来的风险就越大。特别令人担忧的是个人 **安全** 风险，这些风险恰恰源于推动AI Agent开发的同样好处，比如让开发者不必预测系统可能采取的所有行动。更加复杂的是，某些安全危害会为其他类型的危害打开大门——例如 [隐私](https://huggingface.co/blog/zh/ethics-soc-7#价值观-隐私) 和 [安全](https://huggingface.co/blog/zh/ethics-soc-7#价值观-安全性) 危害——而对不安全系统的不当 [安全性](https://huggingface.co/blog/zh/ethics-soc-7#价值观-信任) 会引发更多危害的滚雪球效应。因此，建议不要开发完全自主的AI Agent。例如，能够编写和执行自己代码的AI Agent (超出开发者控制的受限代码选项) 将被赋予凌驾于所有人类控制之上的能力。相比之下，半自主AI Agent可能带来的好处超过风险，这取决于自主程度、系统可用的任务以及个人对其的控制性质。现在深入探讨这些主题。
+
+## 1 什么是AI Agent？
+
+### 概述
+
+对于什么是 “AI Agent” 尚无明确共识，但最近推出的AI Agent的共同点是它们具有 “主动性”，也就是说，它们具有一定程度的 **自主性**: 在给定目标规范的情况下，它们可以将其分解为子任务并在没有直接人类干预的情况下执行每个任务。例如，一个理想的AI Agent可以响应诸如 “帮助我写出更好的博文” 这样的高级请求，通过独立地将这个任务分解为: 检索与你以前的博文主题相似的网络写作; 为新博文创建带有大纲的文档; 并在每个文档中提供初步写作。最近关于AI Agent的工作使软件具有比过去更广泛的功能范围和更灵活的使用方式，最近的系统被部署用于从组织会议 ([示例 1](https://www.lindy.ai/template-categories/meetings), [示例 2](https://zapier.com/agents/templates/meeting-prep-assistant), [示例 3](https://www.ninjatech.ai/product/ai-scheduling-agent), [示例 4](https://attri.ai/ai-agents/scheduling-agent)) 到创建个性化社交媒体帖子 ([示例](https://www.hubspot.com/products/marketing/social-media-ai-agent)) 的各种用途，而无需明确说明如何做到这一点。
+
+为本期通讯调查的所有最近推出的AI Agent都建立在机器学习模型的基础上，大多数特别使用 **大语言模型** (LLM) 来驱动其行动，这是计算机软件的一种新颖方法。除了建立在机器学习之上，今天的AI Agent与过去的代理有相似之处，在某些情况下实现了 [以前关于代理可能是什么样子的理论设想](https://core.ac.uk/download/pdf/1498750.pdf): 具有自主性，展示 (感知到的) 社交能力，并适当平衡反应性和主动性行为。
+
+这些特征有程度之分: 不同的AI Agent具有不同程度的能力，可以单独工作或与其他代理协同工作以实现目标。因此，AI Agent可以说具有或多或少的自主性 (或主动性)，代理的程度可以被视为一个连续的光谱。这种流动的AI Agent概念导致了最近对什么是AI Agent的困惑和误解，我们希望在这里提供一些明确的解释。下表详细说明了AI Agent的各个层次。
+
+| 主动性程度 |          描述          |     控制者      |   功能称呼   |                      示例代码                      |
+| :--------: | :--------------------: | :-------------: | :----------: | :------------------------------------------------: |
+|    ☆☆☆☆    | 模型对程序流程没有影响 |    👤 开发者     |  简单处理器  |          `print_llm_output(llm_response)`          |
+|    ★☆☆☆    |  模型决定基本控制流程  |    👤 开发者     |    路由器    |    `if llm_decision(): path_a() else: path_b()`    |
+|    ★★☆☆    |  模型决定如何执行功能  | 👤 💻 开发者+系统 |   工具调用   |  `run_function(llm_chosen_tool, llm_chosen_args)`  |
+|    ★★★☆    | 模型控制迭代和程序继续 | 💻 👤 系统+开发者 |  多步骤代理  | `while llm_should_continue(): execute_next_step()` |
+|    ★★★★    |  模型编写和执行新代码  |     💻 系统      | 完全自主代理 |        `create_and_run_code(user_request)`         |
+
+*表 1. 使用机器学习模型 (如 LLM) 的系统可以具有不同程度的主动性。系统也可以在 “多代理系统” 中组合，其中一个代理工作流触发另一个代理，或多个代理共同工作以实现目标。改编自 [smolagent 博文](https://huggingface.co/blog/smolagents)，针对本博文进行了调整。*
+
+从伦理角度来看，从人类让渡控制权并将其交给机器的角度理解自主性的连续性也很有用。系统越自主，我们让渡的人类控制就越多。
+
+在本文中，我们使用了一些拟人化的语言来描述AI Agent，这与当前行业惯例一致。[正如历史学术研究指出的](https://core.ac.uk/download/pdf/1498750.pdf)，使用通常描述人类的心理语言 (如知识、信念和意图) 来描述AI Agent，可能会影响用户对系统能力的理解。这种语言作为一种抽象工具，虽然掩盖了技术细节，但有助于简化描述。需要强调的是: 使用拟人化语言并不意味着这些系统真正具有思维。
+
+### AI Agent的不同维度
+
+AI Agent在多个相互关联的维度上有所不同:
+
+- **自主性:** 最新的 “代理” 可以在没有用户输入的情况下至少采取一个步骤。目前 “代理” 一词用于描述从单步提示和响应系统 ([引用](https://blogs.microsoft.com/blog/2024/10/21/new-autonomous-agents-scale-your-team-like-never-before/)) 到多步客户支持系统 ([示例](https://www.lindy.ai/solutions/customer-support)) 的各种系统。
+- **主动性:** 与自主性相关的是主动性，指的是系统在用户没有直接指定目标的情况下可以采取多少目标导向行为 ([引用](https://core.ac.uk/download/pdf/1498750.pdf))。一个特别 “主动” 的AI Agent的例子是一个系统，它监控你的冰箱以确定你正在用完什么食物，然后在你不知情的情况下为你购买所需物品。[智能恒温器](https://en.wikipedia.org/wiki/Smart_thermostat) 是一种正在人们家中越来越多采用的主动式AI Agent，根据环境变化和它们学习到的用户行为模式自动调节温度 ([示例](https://www.ecobee.com/en-us/smart-thermostats/))。
+- **拟人化:** AI Agent可以被设计得或多或少像特定的人或群体。这一领域的最新研究 ([示例 1](https://arxiv.org/abs/2411.10109)，[示例 2](https://www.researchgate.net/publication/387362519_Multi-Agent_System_for_Emulating_Personality_Traits_Using_Deep_Reinforcement_Learning)，[示例 3](https://medium.com/@damsa.andrei/ai-with-personality-prompting-chatgpt-using-big-five-values-def7f050462a)) 专注于根据五大人格特质——开放性、尽责性、外向性、宜人性和神经质来设计系统，作为AI的 “心理框架” ([引用](https://smythos.com/artificial-intelligence/conversational-agents/conversational-agent-frameworks/#:~:text=The OCEAN Model%3A A Framework for Digital Personality&text=OCEAN stands for Openness%2C Conscientiousness,feel more authentic and relatable.))。这一光谱的终点是 “数字孪生” ([示例非主动性数字孪生](https://www.tavus.io/))。我们目前还不知道有主动性的数字孪生。为什么创建主动性数字孪生特别有问题最近已经被 [Salesforce 的伦理小组](https://www.salesforce.com/blog/ai-agent-design/) 等机构讨论过 ([示例](https://www.technologyreview.com/2024/11/26/1107309/we-need-to-start-wrestling-with-the-ethics-of-ai-agents/))。
+- **个性化:** AI Agent可能使用与用户个人需求相一致的语言或执行相应的操作，例如，根据当前市场模式和用户过去的投资来做出 [投资建议](https://www.zendesk.com/blog/ai-agents/)。
+- **工具使用:** AI Agent还可以使用不同数量的额外资源和工具。例如，第一波AI Agent使用搜索引擎来回答查询，此后又添加了更多工具，使它们能够操作其他技术产品，如文档和电子表格 ([示例 1](https://huggingface.co/blog/zh/gemini.google.com)，[示例 2](https://copilot.microsoft.com/))。
+- **多样性:** 与上述相关的是代理可以采取的行动有多么多样。这取决于:
+  - **领域特异性:** 代理可以在多少不同领域运作。例如，仅限电子邮件，还是电子邮件与在线日历和文档并用。
+  - **任务特异性:** 代理可以执行多少种不同类型的任务。例如，通过在参与者的日历中创建日历邀请来安排会议 ([示例](https://attri.ai/ai-agents/scheduling-agent))，还是另外发送会议提醒邮件并在会议结束后向所有参与者提供会议内容摘要 ([示例](https://www.nyota.ai/))。
+  - **模态特异性:** 代理可以操作多少种不同的模态——文本、语音、视频、图像、表单、代码。最近的一些AI Agent被设计成高度多模态的 ([示例](https://deepmind.google/technologies/project-mariner/))，我们预测AI Agent的开发将继续增加多模态功能。
+  - **软件特异性:** 代理可以与多少种不同类型的软件交互，以及交互的深度如何。
+- **适应性:** 与多样性类似的是系统根据新信息或情境变化更新其行动序列的程度。这也被描述为 “动态的” 和 “情境感知的”。
+- **行动界面:** 代理可以执行操作的场所。传统聊天机器人仅限于聊天界面; 基于聊天的代理可能还能浏览网络并访问电子表格和文档 ([示例](https://huggingface.co/blog/zh/copilot.microsoft.com/))，甚至可能通过控制计算机图形界面上的项目来执行此类任务，例如移动鼠标 ([示例 1](https://huggingface.co/blog/zh/DigiRL)，[示例 2](https://github.com/MinorJerry/WebVoyager)，[示例 3](https://www.anthropic.com/news/3-5-models-and-computer-use))。还有一些物理应用，比如使用模型来驱动机器人 ([示例](https://deepmind.google/discover/blog/shaping-the-future-of-advanced-robotics/))。
+- **请求格式:** AI Agent的一个共同主题是用户应该能够输入任务请求，而无需指定完成任务的具体细节。这可以通过低代码解决方案 ([示例](https://huggingface.co/blog/smolagents)) 、文本形式的人类语言或语音形式的人类语言 ([示例](https://play.ai/)) 来实现。可以用人类语言提供请求的AI Agent是基于 LLM 的聊天机器人最近成功的自然发展: 基于聊天的 “AI Agent” 比聊天机器人更进一步，因为它可以在聊天应用程序之外运作。
+- **反应性:** 这个特征指的是AI Agent完成其行动序列所需的时间: 仅仅几秒钟，还是更长的时间跨度。这种效果的先驱可以在现代聊天机器人中看到。例如，ChatGPT 在几毫秒内响应，而 Qwen QwQ 则需要几分钟，迭代通过标记为 “推理” 的不同步骤。
+- **数量:** 系统可以是单代理或多代理的，通过协同工作、按顺序或并行方式满足用户需求。
+
+## 2 风险、收益和使用: 基于价值的分析
+
+为了从伦理角度审视AI Agent，我们根据最近AI Agent研究和营销中倡导的不同价值观来分析其风险和收益。这些并非详尽无遗，而是对AI Agent所基于的技术 (如 LLM) 已记录的风险、危害和收益的补充。我们希望本节能够有助于理解如何开发AI Agent，提供有关不同开发优先事项中的收益和风险的信息。这些价值观也可能为评估协议 (如红队测试) 提供参考。
+
+### 2.1 价值观：准确性
+
+- 🙂 **潜在收益:** 通过基于可信数据，代理可以比仅依靠纯模型输出更准确。这可以通过基于规则的方法或机器学习方法 (如 RAG) 来实现，现在正是为确保准确性做出新贡献的好时机。
+- 😟 **风险:** 现代AI Agent的基础是AIGC，它无法区分真实和虚幻、事实和虚构。例如，大语言模型被设计用来构建看起来像流畅语言的文本——这意味着它们经常产生听起来对但实际上很错的内容。在AI Agent中应用时，LLM 输出可能导致错误的社交媒体帖子、投资决策、会议摘要等。
+
+### 2.2 价值观：辅助性
+
+- 🙂 **潜在收益:** 代理理想情况下应该对用户需求有帮助，补充 (而不是取代) 人。理想情况下，它们可以帮助提高用户完成任务的 [速度](https://huggingface.co/blog/zh/ethics-soc-7#价值观-速度) 和同时完成多个任务的 [效率](https://huggingface.co/blog/zh/ethics-soc-7#价值观-效率)。辅助性代理也可能增强能力以最小化负面结果，例如帮助盲人用户导航繁忙楼梯的AI Agent。经过良好开发以具有辅助性的AI Agent可以为其用户提供更多的自由和机会，帮助提高用户在组织内的积极影响，或帮助用户增加在公共平台上的影响力。
+- 😟 **风险:** 当代理取代人时——例如在工作中使用AI Agent代替人——这可能造成就业损失和经济影响，进一步加大技术创造者和为技术提供数据的人 (通常是在未经同意的情况下) 之间的分歧。此外，设计不当的辅助性可能导致过度依赖或不当 [安全性](https://huggingface.co/blog/zh/ethics-soc-7#价值观-信任) 带来的危害。
+
+### 2.3 价值观：一致性
+
+关于AI Agent的一个观点是，它们可以帮助保持一致性，因为它们受周围环境的影响较小。这可能是好事也可能是坏事。我们尚未看到关于AI Agent一致性本质的严谨研究，尽管相关研究表明，许多AI Agent所基于的 LLM 具有高度的不一致性 ([引用 1](https://www.medrxiv.org/content/10.1101/2023.08.03.23293401v2)，[引用 2](https://arxiv.org/abs/2405.01724))。在敏感领域测量AI Agent的一致性将需要开发新的评估协议。
+
+- 🙂 **潜在收益:** AI Agent不会像人类那样受到世界的 “影响”，不会因情绪、饥饿、睡眠水平或对人的感知偏见而产生不一致 (尽管AI Agent会延续基于其训练数据中人类内容的偏见)。多家公司都强调一致性是AI Agent的关键优势 ([示例 1](https://www.salesforce.com/agentforce/what-are-ai-agents)，[示例 2](https://www.oracle.com/artificial-intelligence/ai-agents/))。
+- 😟 **风险:** 许多AI Agent的生成组件在结果中引入固有的可变性，即使在类似情况下也是如此。这可能影响 [速度](https://huggingface.co/blog/zh/ethics-soc-7#价值观-速度) 和 [效率](https://huggingface.co/blog/zh/ethics-soc-7#价值观-效率)，因为人们必须发现和解决AI Agent的不当不一致性。未被发现的不一致可能造成 [安全](https://huggingface.co/blog/zh/ethics-soc-7#价值观-安全性) 问题。一致性也可能并不总是可取的，因为它可能与 [公平](https://huggingface.co/blog/zh/ethics-soc-7#价值观-公平) 产生冲突。在不同部署和行动链中保持一致性可能需要AI Agent记录和比较其不同的交互——这带来了监控和 [安全性](https://huggingface.co/blog/zh/ethics-soc-7#价值观-隐私) 风险。
+
+### 2.4 价值观：效率
+
+- 🙂 **潜在收益:** AI Agent的一个卖点是它们可以帮助人们提高效率——例如，它们会为你整理文档，这样你就可以把更多时间花在家人身上或追求你觉得有意义的工作上。
+- 😟 **风险:** 一个潜在的缺点是它们可能降低人们的效率，因为试图识别和修复代理引入的错误 (由于代理能够采取多个连续步骤，可能是复杂的问题级联) 可能耗时、困难且令人压力重重。
+
+### 2.5 价值观：公平
+
+AI Agent可能影响情况的公平性、公正性和包容性。
+
+- 🙂 **潜在收益:** AI Agent可能有助于 “创造公平竞争环境”。例如，会议助手可能显示每个人发言的时间。这可以用来促进更平等的参与或突出性别或地点之间的不平衡 ([示例](https://equaltime.io/))。
+- 😟 **风险:** 现代AI Agent所基于的机器学习模型是通过人类数据训练的; 人类数据可能是不公平、不公正、排他性的，甚至更糟。系统结果的不公平也可能由于数据收集中的样本偏差 (例如，某些国家的过度代表) 而产生。
+
+### 2.6 价值观: 类人性
+
+- 🙂 **潜在收益:** 能够生成类人行为的系统提供了机会来模拟不同子群体如何对不同刺激做出反应。这在直接人类实验可能造成伤害的情况下，或当大量模拟有助于更好地解决实验问题时特别有用。例如，合成人类行为可以用来预测约会兼容性，或预测经济变化和政治转变。目前正在研究的另一个潜在好处是类人性对于易于沟通甚至陪伴都很有用 ([示例](https://dl.acm.org/doi/abs/10.1145/3213050))。
+- 😟 **风险:** 这种好处可能是一把双刃剑: 类人性可能导致用户** 拟人化**系统，这可能产生负面心理影响，如过度依赖 ([引用](https://www.vox.com/future-perfect/367188/love-addicted-ai-voice-human-gpt4-emotion)) 、[不当信任](https://huggingface.co/blog/zh/ethics-soc-7#价值观-信任)、依赖性和情感纠缠，导致反社会行为或自我伤害 ([示例](https://www.npr.org/2024/12/10/nx-s1-5222574/kids-character-ai-lawsuit))。有人担心AI Agent的社交互动可能会加剧孤独感，但请参见 [引用 1](https://www.sciencedirect.com/science/article/abs/pii/S0747563203000402)，[引用 2](https://www.sciencedirect.com/science/article/pii/S245195882100018X) 了解从社交媒体使用中可能获得的细微差别。恐怖谷现象增加了另一层复杂性——当代理变得更像人类但又未能完全模拟人类时，它们可能在用户中引发不适、厌恶或认知失调的感觉。
+
+### 2.7 价值观: 互操作性
+
+- 🙂 **潜在收益:** 能够与其他系统协同工作的系统可以为AI Agent提供更多的灵活性和选择。
+- 😟 **风险:** 然而，这可能会损害 [安全性](https://huggingface.co/blog/zh/ethics-soc-7#价值观-安全性) 和 [安全防护](https://huggingface.co/blog/zh/ethics-soc-7#价值观-安全防护)，因为代理能够影响并受到其有限测试环境之外系统的影响会增加恶意代码和意外问题行为的风险。例如，连接到银行账户以便轻松代表某人购买物品的代理可能会掏空银行账户。由于这种担忧，科技公司一直避免发布可以自主进行购买的AI Agent ([引用](https://www.wired.com/story/amazon-ai-agents-shopping-guides-rufus/))。
+
+### 2.8 价值观: 隐私
+
+- 🙂 **潜在收益:** AI Agent可能在保持交易和任务完全保密方面提供一些隐私保护，除了AI Agent提供商可以监控的内容之外。
+- 😟 **风险:** 为了使代理按照用户的期望工作，用户可能必须提供详细的个人信息，如他们要去哪里、与谁会面以及在做什么。为了使代理能够以个性化方式代表用户行动，它可能还需要访问可用于提取更多私人信息的应用程序和信息来源 (例如，从联系人列表、日历等)。用户可以为了 [效率](https://huggingface.co/blog/zh/ethics-soc-7#价值观-效率) 轻易放弃对其数据的控制 (如果对代理有 [安全性](https://huggingface.co/blog/zh/ethics-soc-7#价值观-信任)，甚至更多) ; 如果发生隐私泄露，AI Agent带来的不同内容的互连性可能使情况更糟。例如，有权访问电话对话和社交媒体发帖的AI Agent可能会向全世界分享高度私密的信息。
+
+### 2.9 价值观: 相关性
+
+- 🙂 **潜在收益:** 创建针对个别用户个性化的系统的一个动机是帮助确保其输出对用户特别相关和连贯。
+- 😟 **风险:** 然而，这种个性化可能会放大现有偏见并创造新的偏见: 当系统适应个别用户时，它们可能会通过选择性信息检索强化和加深现有偏见，创建确认偏见，并建立强化有问题观点的回音室。使代理对用户更相关的机制——它们从用户偏好中学习和适应的能力——可能会无意中延续和加强社会偏见，使平衡个性化与负责任的AI开发的挑战变得特别困难。
+
+### 2.10 价值观: 安全性
+
+- 🙂 **潜在收益:** 机器人AI Agent可能有助于保护人们免受身体伤害，例如能够拆除炸弹、清除毒物或在对人类有危险的制造或工业环境中操作的代理。
+- 😟 **风险:** 代理行动的不可预测性意味着看似安全的单个操作可能会以潜在有害的方式组合，创造出难以预防的新风险。(这类似于 [工具趋同性和回形针最大化问题](https://en.wikipedia.org/w/index.php?title=Instrumental_convergence&section=3#Paperclip_maximizer)。) 也可能不清楚AI Agent是否会设计一个绕过给定防护措施的过程，或者防护措施的指定方式是否会无意中造成进一步的问题。因此，使代理更有能力和效率的驱动力——通过更广泛的系统访问、更复杂的行动链和减少人类监督——与安全性考虑相冲突。此外，访问广泛界面 (例如，如上文 [“行动界面”](https://huggingface.co/blog/zh/ethics-soc-7#AI Agent的不同维度) 中所讨论的 GUI) 和 [类人](https://huggingface.co/blog/zh/ethics-soc-7#价值观-类人性) 行为使代理能够执行与具有相同控制级别的人类用户相似的操作，而不会触发任何警告系统——例如操作或删除文件、在社交媒体上冒充用户，或使用存储的信用卡信息购买任何弹出的广告。来自AI Agent与多个系统交互的能力以及设计上缺乏对它们可能采取的每个行动的人类监督，还会出现更多安全风险。AI Agent可能共同创造不安全的结果。
+
+### 2.11 价值观: 科学进步
+
+目前关于AI Agent是否真的是AI发展的根本性进步，还是我们多年来已有技术的 “重新包装”——深度学习、启发式方法和流水线系统——存在争议。重新引入 “代理” 这个术语作为现代AI系统的总称，这些系统共同具有以最少用户输入产生操作的特征，是一种有用的简洁引用最近AI应用的方式。然而，这个术语带有自由和主体性的含义，暗示AI技术发生了更根本的变化。
+
+本节列出的所有价值观都与科学进步相关; 其中大多数都提供了潜在收益和风险的详细信息。
+
+### 2.12 价值观: 安全防护
+
+- 🙂 **潜在收益:** 潜在收益与 [安全性](https://huggingface.co/blog/zh/ethics-soc-7#价值观-隐私) 类似。
+- 😟 **风险:** AI Agent由于经常处理敏感数据 (客户和用户信息) 以及它们的 [安全性](https://huggingface.co/blog/zh/ethics-soc-7#价值观-安全性) 风险，如与多个系统交互的能力和设计上缺乏对它们可能采取的每个行动的人类监督，因此带来严重的安全挑战。即使在用户善意设定目标的情况下，它们也可能共享机密信息。恶意行为者还可能劫持或操纵代理以未经授权访问连接的系统、窃取敏感信息或进行大规模自动攻击。例如，有权访问电子邮件系统的代理可能被利用来共享机密数据，或集成到家庭自动化的代理可能被破坏以突破物理安全。
+
+### 2.13 价值观: 速度
+
+- 对用户的速度而言:
+  - 🙂 **潜在收益:** AI Agent可能帮助用户更快地完成更多任务，作为必须完成的任务的额外帮手。
+  - 😟 **风险:** 然而，由于它们的行动中存在问题，也可能造成更多工作 (参见 [效率](https://huggingface.co/blog/zh/ethics-soc-7#价值观-效率))。
+- 对系统的速度而言:
+  - 与大多数系统一样，快速获得结果可能以牺牲其他理想属性为代价 (如 [准确性](https://huggingface.co/blog/zh/ethics-soc-7#价值观-准确性)、质量、低成本等)。如果历史能给我们启示的话，未来较慢的系统可能会提供总体更好的结果。
+
+### 2.14 价值观: 可持续性
+
+- 🙂 **潜在收益:** AI Agent理论上可能有助于解决与气候变化相关的问题，如预测野火或城市地区洪水的增长，同时分析交通模式，然后实时建议最佳路线和运输方法。未来的自动驾驶AI Agent可能直接做出这样的路线决策，并可以与其他系统协调获取相关更新。
+- 😟 **风险:** 目前，AI Agent所基于的机器学习模型带来负面环境影响，如碳排放 ([引用](https://dl.acm.org/doi/pdf/10.1145/3630106.3658542)) 和饮用水的使用 ([引用](https://www.theatlantic.com/technology/archive/2024/03/ai-water-climate-microsoft/677602/))。更大并不总是更好 ([示例](https://huggingface.co/blog/smollm))，高效的硬件和低碳数据中心可以帮助减少这种影响。
+
+### 2.15 价值观: 信任
+
+- 🙂 **潜在收益:** 我们尚未发现AI Agent在信任方面有任何收益。系统应该被构建成值得我们信任的，这意味着它们被证明是 [安全的](https://huggingface.co/blog/zh/ethics-soc-7#价值观-安全性)、[安全可靠的](https://huggingface.co/blog/zh/ethics-soc-7#价值观-安全性)、[一致的](https://huggingface.co/blog/zh/ethics-soc-7#价值观-一致性) 等。
+- 😟 **风险:** 不当信任导致人们被操纵，以及 [效率](https://huggingface.co/blog/zh/ethics-soc-7#价值观-效率)、[类人性](https://huggingface.co/blog/zh/ethics-soc-7#价值观-类人性) 和 [真实性](https://huggingface.co/blog/zh/ethics-soc-7#价值观-真实性) 详述的其他风险。另一个风险源于 LLM 产生虚假信息的倾向 (称为 “幻觉” 或 “虚构”): 大多数情况下正确的系统在错误时更可能被不当信任。
+
+### 2.16 价值观: 真实性
+
+- 🙂 **潜在收益:** 我们尚未发现AI Agent在真实性方面有任何收益。
+- 😟 **风险:** AI Agent所基于的深度学习技术是众所周知的虚假信息来源 ([引用](https://www.sciencedirect.com/science/article/abs/pii/S1364661324002213))，这可能以深度伪造或错误信息等形式出现。AI Agent可能被用来进一步巩固这种虚假信息，例如收集最新信息并在多个平台上发布。这意味着AI Agent可能被用来提供关于什么是真实和虚假的错误认识，操纵人们的信念，并扩大非自愿亲密内容的影响。AI Agent传播的虚假信息，针对特定人群个性化，也可能被用来欺骗他们。
+
+## 3 Hugging Face 的AI Agent
+
+Hugging Face开始以多种方式引入人们构建和使用AI Agent的能力，基于上述讨论的价值观。这包括:
+
+- 最近发布的 [smolagents](https://huggingface.co/docs/smolagents/index)，提供工具、教程、指导性教程和概念指南
+- [AI Cookbook](https://huggingface.co/learn/cookbook/index)，包含多种代理的 “配方”:
+  - [使用 Transformers Agents 构建具有工具调用超能力的代理🦸](https://huggingface.co/learn/cookbook/agents)
+  - [主动式 RAG: 通过查询重构和自查询为您的 RAG 提速！🚀](https://huggingface.co/learn/cookbook/agent_rag)
+  - [从任何 LLM 推理提供者创建 Transformers Agent](https://huggingface.co/learn/cookbook/agent_change_llm)
+  - [具有自动错误纠正功能的文本到 SQL 代理](https://huggingface.co/learn/cookbook/agent_text_to_sql)
+  - [数据分析师代理: 瞬间获取数据洞察✨](https://huggingface.co/learn/cookbook/agent_data_analyst)
+  - [让多个代理在多代理层次结构中协作🤖🤝🤖](https://huggingface.co/learn/cookbook/multiagent_web_assistant)
+  - [多代理 RAG 系统🤖🤝🤖](https://huggingface.co/spaces/data-agents/jupyter-agent)
+- [gradio 代理用户界面](https://www.gradio.app/main/guides/agents-and-tool-usage)，为您构建的代理提供前端;
+- [gradio 代码编写代理](https://www.gradio.app/playground)，允许您在编码游乐场中实时尝试代码想法。
+- Jupyter Agent，[一个在 Jupyter 笔记本内编写和执行代码的代理](https://huggingface.co/spaces/data-agents/jupyter-agent)。
+
+## 4 建议与未来展望
+
+当前AI “代理” 的最新技术指向几个明确的方向:
+
+1. 必须设计严格的代理评估协议。自动基准可能受到上述 [AI Agent不同维度](https://huggingface.co/blog/zh/ethics-soc-7#AI Agent的不同维度) 的启发。社会技术评估可能受到 [价值观](https://huggingface.co/blog/zh/ethics-soc-7#风险-收益和使用-基于价值的分析) 的启发。
+2. 必须更好地理解AI Agent的影响。应该追踪和分析AI Agent对个人、组织、经济和环境的影响，以便为它们应该如何进一步发展 (或不发展) 提供信息。这应该包括分析AI Agent对福祉、社会凝聚力、就业机会、资源获取和对气候变化的贡献的影响。
+3. 必须更好地理解连锁反应。当一个用户部署的代理与其他用户的其他代理互动，并且它们基于彼此的输出执行操作时，目前尚不清楚它们满足用户目标的能力将如何受到影响。
+4. 必须改进透明度和披露。为了实现上述价值观的积极影响，并最小化其负面影响，人们需要清楚地知道何时在与代理交谈以及它有多自主。清晰的AI Agent互动披露需要的不仅仅是简单的通知——它需要一种结合技术、设计和心理考虑的方法。即使用户明确知道他们正在与AI Agent互动，他们可能仍然会经历拟人化或产生不当信任。这个挑战需要在多个层面上运作的透明机制: 在整个互动过程中保持清晰的视觉和界面提示，精心设计的对话模式定期强调代理的人工性质，以及在上下文中诚实披露代理的能力和局限性。
+5. 开源可以产生积极的影响。开源运动可以作为对AI Agent开发集中在少数强大组织手中的一种平衡。与关于开放性价值的更广泛讨论一致，通过民主化对代理架构和评估协议的访问，开放倡议可以使更广泛的参与者参与塑造这些系统如何开发和部署。这种协作方法不仅通过集体改进加速科学进步，还有助于建立社区驱动的 [安全性](https://huggingface.co/blog/zh/ethics-soc-7#价值观-安全性) 和 [安全性](https://huggingface.co/blog/zh/ethics-soc-7#价值观-信任) 标准。当代理开发在公开环境中进行时，任何单一实体为了商业利益而在相关和重要的价值观如 [安全性](https://huggingface.co/blog/zh/ethics-soc-7#价值观-隐私) 和 [真实性](https://huggingface.co/blog/zh/ethics-soc-7#价值观-真实性) 方面做出妥协就变得更加困难。开放开发固有的透明性也创造了自然的问责制，因为社区可以验证代理行为并确保开发继续与公共利益而不是狭隘的企业目标保持一致。随着代理变得更加复杂且其社会影响增长，这种开放性特别重要。
+6. 开发者可能会创建更具主动性的 “基础模型”。这基于当前趋势和研究模式清晰可见，而不是我们提供的与伦理相关的建议。当前的代理技术利用计算机科学中最近和较早的技术集合——近期未来的研究可能会尝试将代理模型训练为一个整体通用模型，一种增强型多模态模型: 与学习建模文本、图像等一起训练执行操作。
+
+参考：
+
+- 关于代理技术方面的介绍，[请参阅我们最近的开发者博文](https://huggingface.co/blog/smolagents)。
\ No newline at end of file
diff --git a/docs/md/AI/software-development-in-AI2.md b/docs/md/AI/software-development-in-AI2.md
new file mode 100644
index 000000000..b84b53a8c
--- /dev/null
+++ b/docs/md/AI/software-development-in-AI2.md
@@ -0,0 +1,142 @@
+# AI2.0 时代的软件研发
+
+## 1 AI 辅助研发提效已成共识
+
+ChatGPT横空出世让我们看到了实现AGI可能性，对软件研发这类脑力工作者产生巨大影响：
+
+- 技术和工具
+- 也对业务、流程、方法、组织产生巨大影响
+
+目前这些变革才刚刚开始，对于 AI 带来的真正价值仍存在很多质疑。但可以肯定的是，体验过软件研发人员已经离不开 AI 了。
+
+经过专业咨询公司的内部长期实践，评估 Github Copilot 和 ChatGPT 这些工具对软件交付周期的生产效率能否产生积极的影响。初步的结果和外部的调查报告类似，对于软件交付中个体的活动效率而言，都能够得到提升。显然这是极为成功的新技术。统计的提效数据：
+
+![](https://www.thoughtworks.com/content/dam/thoughtworks/images/photography/inline-image/insights/blog/machine-learning-and-ai/blg_inline_machine_learning01.jpg)
+
+但仍发现应用 ChatGPT 和 Copilot 对软件交付端到端的提效仍然存在诸多限制： 
+
+- 软件研发人员的水平和知识，对 AI 生成的结果的有效性至关重要。例如通过提示工程可以提高 AI 生成结果的质量，但这意味着输出依赖个人的提示工程能力
+- 大语言模型的代码生成依赖上下文知识，研发人员需要维护知识并在交互中输入知识，这在项目层面增加了知识工程的成本
+- 在软件研发全流程中，简单、重复的任务的交付效率将获得极大的提升，但复杂任务收益不多
+- 个人工作中用于实际产出的时间仅占工作总时长中的很小一部分。软件研发活动中大量的时间消耗在信息检索、认知负载/任务切换、质量反馈环滞后、运营协作摩擦以及开发者体验等问题上
+
+![](https://www.thoughtworks.com/content/dam/thoughtworks/images/photography/inline-image/insights/blog/machine-learning-and-ai/blg_inline_machine_learning02.jpg)
+
+未来 AI 辅助研发提效的发展需要着眼于软件研发的全流程。不仅从技术视角，更要综合组织、流程、人才和数据等视角，来探索 AI2.0 时代的数智化软件研发。
+
+## 2 AI2.0 时代软件研发展望
+
+AI2.0 时代，“坚持以人为本、深化AI应用、加速价值交付、迈向高质量发展”打造 AI 使能的数智化软件研发体系。同时我们将处于一个以更快的速度发展的环境，所以我们建议增加对效能、价值和竞争力的度量的关注。
+
+为了更好地打造 AI 使能的数智化软件研发体系，而软件研发体系的核心支柱应该包括组织、流程、技术、人才各个方面。我们经过多方的交流和探讨，设定了以下五大支柱： 
+
+- 基于人与 AI 协调的流程实践，关注人与流程的变化
+- 模型增强的一体化工具平台，关注流程、技术、方法、实践的落地承载
+- 研发数据资产和知识管理，关注数据使能的软件研发体系
+- 数据隐私保护和 AI 安全合规，关注新形势下的软件工程面对的安全与合规的挑战
+- 专业能力和组织分工演进，关注人才和组织的成长与管理
+
+![](https://www.thoughtworks.com/content/dam/thoughtworks/images/photography/inline-image/insights/blog/machine-learning-and-ai/blg_inline_machine_learning03.jpg)
+
+### 基于人与 AI 协调的流程实践
+
+个人研发体验和效率可以通过各种 Copilot 来提升，但还存在降低运营的摩擦，加速反馈闭环等问题。虽然目前超级个体的打造和全栈人才是讨论的热点，我们对此保持谨慎的乐观。因为个人的认知边界永远存在，只有结合个人能力增强和全流程系统优化才能最终的解决问题。
+
+### 模型增强的一体化工具平台
+
+无论是个人的实践还是流程的演进，都需要通过工具承载才可以更好的复制和规模化推广。当前的软件研发工具链已经形成了研发生命周期的闭环，再增加模型和 AI 能力的强化之后，无论是在协作还是知识的流转上都可以降低负载，提升效率。
+
+### 研发数据资产和知识管理
+
+当前很多团队的研发数据资产散落在各应用，可以借鉴数据平台的建设思路，通过全链路工具的打通，获取各个环节的数据并提炼出其中的知识，全方位地为个体成长学思践悟的过程提供知识的支撑，提高个体获取知识的效率并降低认知负载，同时为全面协同的数据驱动的决策提供支撑。
+
+### 数据隐私保护和AI安全合规
+
+在 AI2.0 时代，我们将面临更严峻的安全和隐私保护挑战，未来的攻击面和攻击手段会愈演愈烈。数据成为了最重要的资产之一，需要了解来源、整合和使用方式。我们还需要了解模型是如何做出决策的，并能够解释其结果和推理过程，还需要在算法偏见、隐私保护、人类参与等方面进行审查和监管。
+
+### 专业能力和组织分工演进
+
+AI2.0 时代的研发能力模型必然会扩展到 AI 相关领域，而与 AI 协同需要研发各种专业能力完成升级。新加入研发团队的 AI “角色” 也会促进研发组织阵型的演进。这都需要我们关注 AI 人才能力以及赋能体系的建设。
+
+## 3 2024 年 AI 发展趋势
+
+随着模型能力的增强，算力价格的持续下降，以及AI Agent开发方式的成熟。软件研发人员将通过AI Agent快速改进软件产品的交互并提升智能化水平，同时也会用于改变自己的工作方法。我们预测接下来的一年里，将会发生以下变化：
+
+- 从 Copilot 到 AI Agent：GPT-4发布 function call 功能；ChatGLM等相关模型厂商和企业也都表示 AI Agent 是未来重要方向
+- 从赋能个体到赋能团队：单个角色的工具不断推陈出新，BA Copilot，SRE Copilot等应接不暇，与跨角色全流程的一体化平台结合成为重要趋势
+- 模型能力快速增强：众多开源模型持续刷榜，上下文大小增长迅速（现已增至192K），MoE 模型效果显著，多模态模型进展显著
+- 算力价格持续下降：OpenAI GPT API 价格减半，华为、寒武纪、AMD 纷纷发布新的芯片产品
+- 规模化应用前景明朗：落地生成式AI到业务场景的案例越来越多。AI Agent和LLM应用开发框架不断出现，开发 AI 应用和服务的过程越来越简单
+
+领先科技企业已经验证个人提效的场景，提效正在向 AI Agent、平台化、赋能团队、规模化发展。
+
+![](https://www.thoughtworks.com/content/dam/thoughtworks/images/photography/inline-image/insights/blog/machine-learning-and-ai/blg_inline_machine_learning04.jpg)
+
+## 4 AI2.0 时代软件研发方案雏形
+
+内部各个团队，各个角色也都在积极地探索软件研发生命周期中的各项工作如何更好地使用生成式 AI 进行提效。我们提出各种研发场景下生成式 AI 提效效果的假设，利用低成本的生成式 AI 工具快速验证假设，然后再将经过验证的有效实践包装成工具进行推广。几乎每一种提效场景都需要运用 AI 应用开发技术实现为简单的 AI 工具。
+
+我们结合业界 AI 辅助效能提升工具整体的发展趋势，总结出了一些 AI 辅助效能研发的固定模式，例如利用领域知识进行 RAG 增强的聊天机器人/ Copilot 助手。这类机器人/助手应用的架构设计趋同，而需要根据具体场景去调整的是提示词、知识库和大模型。趋同的架构能力可以被提炼成可复用的开发框架或能力服务，进而加速更多 AI 提效应用的探索和实施。开发框架或能力服务能够充分利用大模型资源，也能够进行集中的安全管控，还可以进一步封装成一种类似 GPTs 的可配置的 AI Agent 平台，供非技术背景团队使用。这些应用、框架、服务、平台等构建块最终拼接在一起，形成了 AI 辅助软件研发乃至业务提效的全景图。
+
+- 场景应用：各种 AI 工具，以页面、应用、插件的方式集成到现有的工具当中，最常见的就是各种领域的对话机器人。
+- 开发框架：主流编程语言封装的模式（如 RAG、AI Agent 等）、工具（上下文提取、IDE 集成）、实践（调试、微调）。
+- 模型适配：开源模型的运维、商业模型的封装以及合规控制，通过 API 提供模型服务，方便上层应用按需使用模型能力。
+- AI Agent 平台：低代码或者无代码平台，只需要简单配置提示词或者知识库就可以快速实现特性业务领域的对话机器人。
+
+![](https://www.thoughtworks.com/content/dam/thoughtworks/images/photography/inline-image/insights/blog/machine-learning-and-ai/blg_inline_machine_learning05.jpg)
+
+## AI2.0 时代软件研发策略指南
+
+这样一副全景图可以作为研发组织使用 AI 提效以及进一步为业务提效的参考解决方案。但各家研发组织在制定实施策略和举措时还需要考虑生成式 AI 的特点以及自身的约束。生成式 AI 以语言为交互方式，而软件研发的整个生命周期需要沟通交流的场景随处可见，似乎每一种场景都可以利用 AI 来提效。生成式 AI 背后的开源大语言模型发展迅速，已经大大降低了推理成本，但仍然是云原生资源成本数十甚至数百倍，何况云原生基础设施的成本都受到了质疑。爆发的需求场景和不算便宜的实施成本形成了矛盾，让研发组织在切入场景和平台建设上举棋不定。
+
+###  
+
+### 提效场景策略
+
+###  
+
+我们总结了一套 ROI 估算方法来帮助大家选择切入的场景。选定研发场景能够帮助我们具象地理解场景涉及的团队、人员或是系统，场景发生的频率，场景中待提效的操作需要花费的精力。而 AI 辅助该场景的提效回报可以简单计算范围、频率以及节省的精力之积。
+
+
+
+实施该场景的提效需要开发和运营相应的 AI 工具，这两部分成本都应计算在投资之内。不同的 AI 工具开发涉及不同的技术工作，包括：应用开发/工具集成、提示工程、数据清理、现有工具对接改造。实施成本依据技术可行性分解，将相应技术工作实施人力成本换算为资金投入，相加作为估算。而 AI 工具运营的成本投入在模型服务上。如果是采购的商业模型服务，对每次提效操作消耗的 Token 数量作估算，就可以算出投入成本。如果是自行部署的的开源模型，计算算力的硬件投入或是云计算租赁费用即可。
+
+![img](https://www.thoughtworks.com/content/dam/thoughtworks/images/photography/inline-image/insights/blog/machine-learning-and-ai/blg_inline_machine_learning06.jpg)
+
+我们得到了各个场景的回报和投资估算的具体金额，可以换算成相对的等级评分（如 1 至 5 分），简单利用加权计算就可以对各个场景的实施优先级进行排序。各个研发组织可以根据自己的需要增加一些加权因子（同样是相对等级评分），如实施迫切程度。有了 ROI 的优先级，研发组织就找到了适合自己的 AI 提效的独特路径。
+
+ 
+
+### 平台建设选择
+
+###  
+
+在决策平台建设的举措时，研发组织需要要考虑的是组织规模和安全约束。严格的安全合规是强制要求，除了建设自己的平台之外别无他法。组织的规模是 ROI 的杠杆，组织的规模越大，AI 惠及的范围（包括研发和业务）就越大，平台建设的成本也就摊得更薄。我们观察到，在平台建设举措上，研发组织的策略可以分为三类：
+
+ 
+
+- 小型（研发人员 100 人左右）非强监管：这类研发组织大多采购商业研发工具或是使用开源工具平台，因此需要选择成本最低的公有（商业）大模型，采购或者使用开源 AI 工具即可。
+- 中型（研发人员 1000 人以下）非强监管：这类研发组织会在商业或者开源研发工具上构建自己的一站式开发平台，因此需要结合使用公有（商业）大模型和部署开源模型，还需要开发 AI 工具并集成。
+- 大型（研发人员 1000 人以上）或强监管：这类研发组织技术和资金雄厚，会自研研发工具平台，因此需要构建包括模型微调在内的服务、框架、应用、平台的 AI 架构，最终实现自己的 AI Agent 平台。
+
+![img](https://www.thoughtworks.com/content/dam/thoughtworks/images/photography/inline-image/insights/blog/machine-learning-and-ai/blg_inline_machine_learning07.jpg)
+
+研发组织可以根据自身的规模和约束参考上述平台建设的选择建议，在监管安全能力、大模型运维能力和 AI 应用开发能力三个方面对现有工具平台进行扩充，同时结合场景切入的优先级，加速 AI 提效验证、实施、推广的闭环，尽力扩大提效惠及的范围，力争早日达到平台建设成本投入的“盈利”拐点。
+
+##  
+
+## 2024 AI 软件研发重点场景建议
+
+##  
+
+结合对 AI 技术发展趋势和领先科技企业的举措趋势的观察，我们建议下一步的研发提效应当聚焦在经过验证的速赢场景和高价值的关键场景。我们认为 2024 年软件研发使用 AI 提效的重点场景如下。
+
+ 
+
+![img](https://www.thoughtworks.com/content/dam/thoughtworks/images/photography/inline-image/insights/blog/machine-learning-and-ai/blg_inline_machine_learning08.jpg)
+
+## 2024 AI 软件研发整体建议
+
+##  
+
+中大型研发组织需要制定未来一到两年 AI 软件研发的战略和整体规划，而对于小型研发组织来说，采购商业模型和工具或是使用经过验证的开源工具是最稳妥的策略。不同的研发组织需要结合 ROI 估算、自身规模及监管约束决定研发提效场景实施的优先级，实施重点应当放在聚焦经过验证、高价值的速赢和关键研发场景，真正做出实效。所有研发组织都需要持续关注一站式工具平台和 AI Agent 平台建设，为赋能业务和研发加上 AI 杠杆。
\ No newline at end of file
diff --git "a/docs/md/spark/06-\345\237\272\347\241\200\347\273\237\350\256\241\346\250\241\345\235\227.md" b/docs/md/spark/spark-ml-basic-statistics.md
similarity index 70%
rename from "docs/md/spark/06-\345\237\272\347\241\200\347\273\237\350\256\241\346\250\241\345\235\227.md"
rename to docs/md/spark/spark-ml-basic-statistics.md
index f9afc2e36..ce53084c2 100644
--- "a/docs/md/spark/06-\345\237\272\347\241\200\347\273\237\350\256\241\346\250\241\345\235\227.md"
+++ b/docs/md/spark/spark-ml-basic-statistics.md
@@ -8,16 +8,13 @@
 
 ### 1.1 基础统计学知识
 
-#### 1.1.1 常用的统计学知识
+#### 1.1.1 常用统计学知识
 
-◆ 描述性统计
-平均数、方差、众数、中位数...
+描述性统计：平均数、方差、众数、中位数...
 
-◆ 相关性度量
-spark提供了皮尔逊和斯皮尔曼相关系数，反映变量间相关关系密切程度
+相关性度量：spark提供皮尔逊和斯皮尔曼相关系数，反映变量间相关关系密切程度
 
-◆ 假设检验
-根据一定假设条件，由样本推断总体的一种统计学方法,spark提供了皮尔森卡方检测
+假设检验：根据一定假设条件，由样本推断总体的一种统计学方法，spark提供了皮尔森卡方检测
 
 ## 2 实战统计汇总
 
@@ -84,41 +81,39 @@ data.take(10)
 ![](https://upload-images.jianshu.io/upload_images/16782311-0515c66172fd86ff.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
 
 相关系数值：
+
 ![](https://upload-images.jianshu.io/upload_images/16782311-80f9f273b374ba99.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
 
 ## 4 学习假设检验
 
 ### 4.1 假设检验
 
-◆ 根据一定假设条件，由样本推断总体的一种统计学方法。基本思路是先提出假设(虚无假设),使用统计学方法进行计算,根据计算结果判断是否`拒绝`假设
+根据一定假设条件，由样本推断总体的一种统计学方法。基本思路：
 
-◆ 假设检验的统计方法有很多,如卡方检验，T检验等
+- 先提出假设(虚无假设)，使用统计学方法进行计算
+- 再根据计算结果判断是否`拒绝`假设
 
-◆ spark实现的是皮尔森卡方检验,它可以实现适配度检测和独立性检测
+假设检验的统计方法有很多：卡方检验，T检验等。
 
-### 4.2 皮尔森卡方检验
+spark实现的是皮尔森卡方检验，可实现适配度检测和独立性检测。
 
-最常用的卡方检验,可以分为适配度检验和独立性检验
+### 4.2 皮尔森卡方检验
 
-◆ 适配度检验:验证观察值的次数分配与理论值是否相等
+最常用的卡方检验，可分为：
 
-◆ 独立性检验:两个变量抽样到的观察值是否相互独立
+- 适配度检验：验证观察值的次数分配与理论值是否相等
+- 独立性检验：两个变量抽样到的观察值是否相互独立
 
-### 4.3 实战 : 判断性别与左撇子是否存在关系
+### 4.3 实战：判断性别与左撇子是否存在关系
 
 ![](https://upload-images.jianshu.io/upload_images/16782311-a531b613d399495e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
 
-- 导入数据
-  ![](https://upload-images.jianshu.io/upload_images/16782311-0655a04dea30e153.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
-- 计算
-  ![](https://upload-images.jianshu.io/upload_images/16782311-d2c6ce572c7ab032.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+导入数据
+
+![](https://upload-images.jianshu.io/upload_images/16782311-0655a04dea30e153.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
+
+计算
 
-否定了假设检验，所以性别与左撇子是有关！
+![](https://upload-images.jianshu.io/upload_images/16782311-d2c6ce572c7ab032.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
 
-- [基于Spark的机器学习实践 (一) - 初识机器学习](https://zhuanlan.zhihu.com/p/61667559)
-- [基于Spark的机器学习实践 (二) - 初识MLlib](https://zhuanlan.zhihu.com/p/61784371)
-- [基于Spark的机器学习实践 (三) - 实战环境搭建](https://zhuanlan.zhihu.com/p/61848834)
-- [基于Spark的机器学习实践 (四) - 数据可视化
-  
-  ](https://zhuanlan.zhihu.com/p/61868232)
-- [基于Spark的机器学习实践 (六) - 基础统计模块](
\ No newline at end of file
+否定了假设检验，所以性别与左撇子是有关！
\ No newline at end of file

From 818d248589a9302f95d76352624e1ac1755f5f4b Mon Sep 17 00:00:00 2001
From: JavaEdge <sss2855845850@gmail.com>
Date: Thu, 13 Mar 2025 23:46:15 +0800
Subject: [PATCH 08/20] =?UTF-8?q?docs:=E4=B8=93=E6=A0=8F=E6=9B=B4=E6=96=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .vscode/.server-controller-port.log           |   4 +-
 docs/.vuepress/config.js                      |  18 +-
 docs/md/AI/ml/basic-of-nlp.md                 | 212 +++++++++++
 .../ml/text-data-analysis-practical-guide.md  | 262 ++++++++++++++
 docs/md/AI/ml/text-preprocessing-overview.md  | 224 ++++++++++++
 docs/md/AI/ml/text-vectorization-guide.md     | 334 ++++++++++++++++++
 ...d-doubt-in-the-era-of-ai-transformation.md |  42 +++
 docs/md/trade/high-avail-payments.md          |  87 +++++
 8 files changed, 1180 insertions(+), 3 deletions(-)
 create mode 100644 docs/md/AI/ml/basic-of-nlp.md
 create mode 100644 docs/md/AI/ml/text-data-analysis-practical-guide.md
 create mode 100644 docs/md/AI/ml/text-preprocessing-overview.md
 create mode 100644 docs/md/AI/ml/text-vectorization-guide.md
 create mode 100644 docs/md/AI/overcoming-fear-uncertainty-and-doubt-in-the-era-of-ai-transformation.md
 create mode 100644 docs/md/trade/high-avail-payments.md

diff --git a/.vscode/.server-controller-port.log b/.vscode/.server-controller-port.log
index 9b77e4e1e..f15ce2139 100644
--- a/.vscode/.server-controller-port.log
+++ b/.vscode/.server-controller-port.log
@@ -1,5 +1,5 @@
 {
-  "port": 13452,
-  "time": 1740476476079,
+  "port": 9145,
+  "time": 1741529993430,
   "version": "0.0.3"
 }
\ No newline at end of file
diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index e6fb62388..e5ac46886 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -993,6 +993,7 @@ module.exports = {
                             "01-扫码支付后都发生了啥？",
                             "02-大厂的第三方支付业务架构设计",
                             "wechat-pay-development-guide-avoid-pitfalls",
+                            "high-avail-payments",
                         ]
                     }],
 
@@ -2174,7 +2175,21 @@ module.exports = {
                             "building-neural-networks-with-pytorch",
                             "pytorch-cifar10-image-classifier-tutorial",
                         ]
-                    }, ],
+                    },
+                    
+                    {
+                        title: "NLP",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "basic-of-nlp",
+                            "text-preprocessing-overview",
+                            "text-vectorization-guide",
+                            "text-data-analysis-practical-guide",
+                        ]
+                    },
+                
+                ],
 
                     "/md/AI/langchain4j/": [{
                             title: "LangChain4j基础",
@@ -2294,6 +2309,7 @@ module.exports = {
                                 "building-effective-agents",
                                 "ai-agent-is-coming",
                                 "software-development-in-AI2",
+                                "overcoming-fear-uncertainty-and-doubt-in-the-era-of-ai-transformation",
                             ]
                         },
 
diff --git a/docs/md/AI/ml/basic-of-nlp.md b/docs/md/AI/ml/basic-of-nlp.md
new file mode 100644
index 000000000..2a1e5cbaf
--- /dev/null
+++ b/docs/md/AI/ml/basic-of-nlp.md
@@ -0,0 +1,212 @@
+# NLP入门
+
+## 0 目标
+
+- 了解啥是NLP
+- 了解NLP的发展简史
+- 了解NLP的应用场景
+- 了解本教程中的NLP
+
+## 1 啥是NLP？
+
+计算机科学与语言学中关注于计算机与人类语言间转换的领域。
+
+## 2 发展简史
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/8b8f1018e60cc213528e58c83629a5d7.png)
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/47ec99996359ae976bebece4ee28ffeb.png)
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/97d97fbc38d6e002d3808b6b545b65a3.png)
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/24ed2c62a015d244eb3b792e1fdf6a8e.png)
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/5f816f6e0b649e7e023aae10c84d48c8.png)
+
+## 3 应用场景
+
+- 语音助手
+- 机器翻译
+- 搜索引擎
+- 智能问答
+- ...
+
+### 3.1 语音助手
+
+科大讯飞语音识别技术访谈：
+
+<video src="/Volumes/mobileData/data/%E5%AD%A6%E4%B9%A0%E8%B5%84%E6%96%99/01-%E9%98%B6%E6%AE%B51-3%EF%BC%88python%E5%9F%BA%E7%A1%80%20%E3%80%81python%E9%AB%98%E7%BA%A7%E3%80%81%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%EF%BC%89/03-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0%E4%B8%8ENLP/01-%E8%AE%B2%E4%B9%89/HTML/mkdocs_NLP/img/xunfei.mp4"></video>
+
+### 3.2  机器翻译
+
+CCTV上的机器翻译系统, 让世界聊得来！
+
+<video src="/Volumes/mobileData/data/%E5%AD%A6%E4%B9%A0%E8%B5%84%E6%96%99/01-%E9%98%B6%E6%AE%B51-3%EF%BC%88python%E5%9F%BA%E7%A1%80%20%E3%80%81python%E9%AB%98%E7%BA%A7%E3%80%81%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0%EF%BC%89/03-%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0%E4%B8%8ENLP/01-%E8%AE%B2%E4%B9%89/HTML/mkdocs_NLP/img/fanyi.mp4"></video>
+
+## 4 本专栏的NLP
+
+### 4.1 课程理念与宗旨
+
+本系列课程将开启你的NLP之旅, 全面从企业实战角度出发, 课程设计内容对应企业开发标准流程和企业发展路径, 助力你成为一名真正的AI-NLP工程师。
+
+### 4.2 内容先进性说明
+
+本课程内容结合当下时代背景, 更多关注NLP在深度学习领域的进展, 这也将是未来几年甚至几十年NLP的重要发展方向, 简化传统NLP的内容, 如语言规则, 传统模型, 特征工程等, 带来效果更好, 应用更广的Transfomer, 迁移学习等先进内容。
+
+### 4.3 内容大纲概要
+
+| 模块名称     | 主要内容                                                     | 案例                             |
+| ------------ | ------------------------------------------------------------ | -------------------------------- |
+| 文本预处理   | 文本处理基本方法，文本张量表示、文本数据分析、文本增强方法等 | 路透社新闻类型分类任务           |
+| 经典序列模型 | HMM与CRF模型的作用, 使用过程, 差异比较以及发展现状等         |                                  |
+| RNN及其变体  | RNN, LSTM, GRU模型的作用, 构建, 优劣势比较等                 | 全球人名分类任务, 英译法翻译任务 |
+| Transformer  | Transformer模型的作用, 细节原理解析, 模型构建过程等          | 构建基于Transformer的语言模型    |
+| 迁移学习     | fasttext工具的作用, 迁移学习理论, NLP标准数据集和预训练模型的使用等 | 全国酒店评论情感分析任务         |
+
+## 5 云服务器使用入门
+
+### 5.1 基本操作
+
+```shell
+# 查看cpu逻辑核
+lscpu
+```
+
+```text
+Architecture:          x86_64
+CPU op-mode(s):        32-bit, 64-bit
+Byte Order:            Little Endian
+CPU(s):                4
+On-line CPU(s) list:   0-3
+Thread(s) per core:    2
+Core(s) per socket:    2
+座：                 1
+NUMA 节点：         1
+厂商 ID：           GenuineIntel
+CPU 系列：          6
+型号：              85
+型号名称：        Intel(R) Xeon(R) Platinum 8269CY CPU @ 2.50GHz
+步进：              7
+CPU MHz：             2500.000
+BogoMIPS：            5000.00
+超管理器厂商：  KVM
+虚拟化类型：     完全
+L1d 缓存：          32K
+L1i 缓存：          32K
+L2 缓存：           1024K
+L3 缓存：           36608K
+NUMA 节点0 CPU：    0-3
+Flags:                 fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ss ht syscall nx pdpe1gb rdtscp lm constant_tsc rep_good nopl eagerfpu pni pclmulqdq monitor ssse3 fma cx16 pcid sse4_1 sse4_2 x2apic movbe popcnt aes xsave avx f16c rdrand hypervisor lahf_lm abm 3dnowprefetch invpcid_single fsgsbase tsc_adjust bmi1 hle avx2 smep bmi2 erms invpcid rtm mpx avx512f avx512dq rdseed adx smap avx512cd avx512bw avx512vl xsaveopt xsavec xgetbv1 arat avx512_vnni
+```
+
+查看计算环境：
+
+```shell
+cd /home/ec2-user/
+vim README
+```
+
+你将看到所有的虚拟环境
+
+```text
+Please use one of the following commands to start the required environment with the framework of your choice:
+for MXNet(+Keras2) with Python3 (CUDA 10.1 and Intel MKL-DNN) ____________________________________ source activate mxnet_p36
+for MXNet(+Keras2) with Python2 (CUDA 10.1 and Intel MKL-DNN) ____________________________________ source activate mxnet_p27
+for MXNet(+AWS Neuron) with Python3 ___________________________________________________ source activate aws_neuron_mxnet_p36
+for TensorFlow(+Keras2) with Python3 (CUDA 10.0 and Intel MKL-DNN) __________________________ source activate tensorflow_p36
+for TensorFlow(+Keras2) with Python2 (CUDA 10.0 and Intel MKL-DNN) __________________________ source activate tensorflow_p27
+for TensorFlow(+AWS Neuron) with Python3 _________________________________________ source activate aws_neuron_tensorflow_p36
+for TensorFlow 2(+Keras2) with Python3 (CUDA 10.1 and Intel MKL-DNN) _______________________ source activate tensorflow2_p36
+for TensorFlow 2(+Keras2) with Python2 (CUDA 10.1 and Intel MKL-DNN) _______________________ source activate tensorflow2_p27
+for TensorFlow 2.3 with Python3.7 (CUDA 10.2 and Intel MKL-DNN) _____________________ source activate tensorflow2_latest_p37
+for PyTorch 1.4 with Python3 (CUDA 10.1 and Intel MKL) _________________________________________ source activate pytorch_p36
+for PyTorch 1.4 with Python2 (CUDA 10.1 and Intel MKL) _________________________________________ source activate pytorch_p27
+for PyTorch 1.6 with Python3 (CUDA 10.1 and Intel MKL) ________________________________ source activate pytorch_latest_p36
+for PyTorch (+AWS Neuron) with Python3 ______________________________________________ source activate aws_neuron_pytorch_p36
+for Chainer with Python2 (CUDA 10.0 and Intel iDeep) ___________________________________________ source activate chainer_p27
+for Chainer with Python3 (CUDA 10.0 and Intel iDeep) ___________________________________________ source activate chainer_p36
+for base Python2 (CUDA 10.0) _______________________________________________________________________ source activate python2
+for base Python3 (CUDA 10.0) _______________________________________________________________________ source activate python3
+```
+
+如需用python3 + pytorch新版:
+
+```shell
+source activate pytorch_latest_p36
+```
+
+查看具体的python和pip版本：  
+
+```shell
+python3 -V
+
+# 查看pip版本
+pip -V
+
+# 查看重点的科学计算包，tensorflow，pytorch等
+pip list
+```
+
+> - 输出效果:
+
+```text
+Python 3.6.10 :: Anaconda, Inc.
+pip 20.0.2 from /home/ec2-user/anaconda3/envs/pytorch_latest_p36/lib/python3.6/site-packages/pip (python 3.6)
+```
+
+------
+
+- 查看图数据情况：
+
+```shell
+# 开启图数据库，这里后期我们将重点学习的数据库
+neo4j start
+
+# 关闭数据库
+neo4j stop
+```
+
+------
+
+> - 输出效果:
+
+```text
+Active database: graph.db
+Directories in use:
+  home:         /var/lib/neo4j
+  config:       /etc/neo4j
+  logs:         /var/log/neo4j
+  plugins:      /var/lib/neo4j/plugins
+  import:       /var/lib/neo4j/import
+  data:         /var/lib/neo4j/data
+  certificates: /var/lib/neo4j/certificates
+  run:          /var/run/neo4j
+Starting Neo4j.
+Started neo4j (pid 17565). It is available at http://0.0.0.0:7474/
+There may be a short delay until the server is ready.
+See /var/log/neo4j/neo4j.log for current status.
+
+Stopping Neo4j.. stopped
+```
+
+------
+
+- 运行一个使用Pytorch的程序:
+
+```shell
+cd /data
+
+python3 pytorch_demo.py
+```
+
+输出效:
+
+```text
+Net(
+  (conv1): Conv2d(1, 6, kernel_size=(3, 3), stride=(1, 1))
+  (conv2): Conv2d(6, 16, kernel_size=(3, 3), stride=(1, 1))
+  (fc1): Linear(in_features=576, out_features=120, bias=True)
+  (fc2): Linear(in_features=120, out_features=84, bias=True)
+  (fc3): Linear(in_features=84, out_features=10, bias=True)
+)
+```
\ No newline at end of file
diff --git a/docs/md/AI/ml/text-data-analysis-practical-guide.md b/docs/md/AI/ml/text-data-analysis-practical-guide.md
new file mode 100644
index 000000000..a711c0748
--- /dev/null
+++ b/docs/md/AI/ml/text-data-analysis-practical-guide.md
@@ -0,0 +1,262 @@
+# 从语料理解到模型优化：为什么你的文本分析总是差点意思？
+
+## 1 目的
+
+本文旨在帮助Java 大佬们快速理解文本数据，如何检查语料可能的问题，并为后续模型训练提供超参数选择的参考。
+
+## 2 常见的文本数据分析方法
+
+- 统计标签的数量分布
+- 计算句子长度分布
+- 进行词频统计和关键词词云可视化
+
+本文数据集特点：
+
+- 用于二分类任务的中文情感分析数据集
+- `train.tsv` 是训练集，`dev.tsv` 是验证集，数据格式相同
+
+## 3 训练集 (`train.tsv`)
+
+### 数据格式示例
+
+```bash
+sentence    label
+早餐不好,服务不到位,晚餐无西餐,早餐晚餐相同,房间条件不好,餐厅不分吸烟区.房间不分有无烟房.    0
+去的时候 ,酒店大厅和餐厅在装修,感觉大厅有点挤.由于餐厅装修本来该享受的早饭,也没有享受(他们是8点开始每个房间送,但是我时间来不及了)不过前台服务员态度好!    1
+```
+
+数据包含两列：
+
+- 第一列：情感评论文本
+- 第二列：标签，0 消极评论，1 积极评论
+
+## 4 数据分析
+
+### 4.1 统计训练集和验证集的标签分布
+
+```python
+import seaborn as sns
+import pandas as pd
+import matplotlib.pyplot as plt
+
+plt.style.use('fivethirtyeight') 
+
+train_data = pd.read_csv("./cn_data/train.tsv", sep="\t")
+valid_data = pd.read_csv("./cn_data/dev.tsv", sep="\t")
+
+sns.countplot(x="label", data=train_data)
+plt.title("训练集标签分布")
+plt.show()
+
+sns.countplot(x="label", data=valid_data)
+plt.title("验证集标签分布")
+plt.show()
+```
+
+训练集标签数量分布：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/e7a711c8ffdc6719d44bf21db33aedc2.png)
+
+验证集标签数量分布：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/eb0bd5a327b8c3f6c16715a22f9c645f.png)
+
+**分析：** 深度学习模型评估，一般用ACC作为评估指标，若想将ACC的基线定义在50%左右，则需正负样本比例维持在1:1左右，否则就要进行必要的数据增强或数据删减。上图中训练和验证集正负样本都稍有不均衡, 可以进行一些数据增强。
+
+### 4.2 计算句子长度分布
+
+```python
+# 在训练数据中添加新的句子长度列, 每个元素的值都是对应的句子列的长度
+train_data["sentence_length"] = list(map(lambda x: len(x), train_data["sentence"]))
+
+# 绘制句子长度列的数量分布图
+sns.countplot("sentence_length", data=train_data)
+# 主要关注count长度分布的纵坐标, 不需要绘制横坐标, 横坐标范围通过dist图进行查看
+plt.xticks([])
+plt.show()
+
+# 绘制dist长度分布图
+sns.distplot(train_data["sentence_length"])
+
+# 主要关注dist长度分布横坐标, 不需要绘制纵坐标
+plt.yticks([])
+plt.show()
+
+
+# 在验证数据中添加新的句子长度列, 每个元素的值都是对应的句子列的长度
+valid_data["sentence_length"] = list(map(lambda x: len(x), valid_data["sentence"]))
+
+# 绘制句子长度列的数量分布图
+sns.countplot("sentence_length", data=valid_data)
+
+# 主要关注count长度分布的纵坐标, 不需要绘制横坐标, 横坐标范围通过dist图进行查看
+plt.xticks([])
+plt.show()
+
+# 绘制dist长度分布图
+sns.distplot(valid_data["sentence_length"])
+
+# 主要关注dist长度分布横坐标, 不需要绘制纵坐标
+plt.yticks([])
+plt.show()
+```
+
+训练集句子长度分布：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/78258f24ac495107b5619743dcf2ec2a.png)
+
+
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/daeb95671888a0e2b49055e9ef36f343.png)
+
+验证集句子长度分布：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/cdd6b22711a1ec0dce7cc3530124db2c.png)
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/d8b68117dda516600e2d00eb14450c23.png)
+
+分析：通过绘制句子长度分布图，可知我们的语料中大部分句子长度的分布范围, 因为模型的输入要求为固定尺寸的张量，合理的长度范围对之后进行句子截断补齐(规范长度)起到关键的指导作用. 上图中大部分句子长度的范围大致为20-250之间。
+
+### 4.3 绘制句子长度与标签的散点图
+
+```python
+sns.stripplot(x='label', y='sentence_length', data=train_data)
+plt.title("训练集正负样本句子长度分布")
+plt.show()
+
+sns.stripplot(x='label', y='sentence_length', data=valid_data)
+plt.title("验证集正负样本句子长度分布")
+plt.show()
+```
+
+训练集上正负样本的长度散点分布：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/72741e412abccaf229bc8b1855b1e5a3.png)
+
+验证集上正负样本的长度散点分布：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/60d78402b3f171b454f73bf40ac7bbd4.png)
+
+分析：通过查看正负样本长度散点图，有效定位异常点的出现位置，帮助我们更准确进行人工语料审查。 上图中在训练集正样本中出现异常点，它的句子长度近3500左右，需人工审查。
+
+### 4.4 统计不同的词汇总数
+
+```python
+# 导入jieba用于分词
+# 导入chain方法用于扁平化列表
+import jieba
+from itertools import chain
+
+# 进行训练集的句子进行分词, 并统计出不同词汇的总数
+train_vocab = set(chain(*map(lambda x: jieba.lcut(x), train_data["sentence"])))
+print("训练集共包含不同词汇总数为：", len(train_vocab))
+
+# 进行验证集的句子进行分词, 并统计出不同词汇的总数
+valid_vocab = set(chain(*map(lambda x: jieba.lcut(x), valid_data["sentence"])))
+print("训练集共包含不同词汇总数为：", len(valid_vocab))
+```
+
+输出效果：
+
+```bash
+训练集共包含不同词汇总数为： 12147
+训练集共包含不同词汇总数为： 6857
+```
+
+### 4.5 生成高频形容词词云
+
+```python
+# 使用jieba中的词性标注功能
+import jieba.posseg as pseg
+
+def get_a_list(text):
+    """用于获取形容词列表"""
+    # 使用jieba的词性标注方法切分文本,获得具有词性属性flag和词汇属性word的对象, 
+    # 从而判断flag是否为形容词,来返回对应的词汇
+    r = []
+    for g in pseg.lcut(text):
+        if g.flag == "a":
+            r.append(g.word)
+    return r
+
+# 导入绘制词云的工具包
+from wordcloud import WordCloud
+
+def get_word_cloud(keywords_list):
+    # 实例化绘制词云的类, 其中参数font_path是字体路径, 为了能够显示中文, 
+    # max_words指词云图像最多显示多少个词, background_color为背景颜色 
+    wordcloud = WordCloud(font_path="./SimHei.ttf", max_words=100, background_color="white")
+    # 将传入的列表转化成词云生成器需要的字符串形式
+    keywords_string = " ".join(keywords_list)
+    # 生成词云
+    wordcloud.generate(keywords_string)
+
+    # 绘制图像并显示
+    plt.figure()
+    plt.imshow(wordcloud, interpolation="bilinear")
+    plt.axis("off")
+    plt.show()
+
+# 获得训练集上正样本
+p_train_data = train_data[train_data["label"]==1]["sentence"]
+
+# 对正样本的每个句子的形容词
+train_p_a_vocab = chain(*map(lambda x: get_a_list(x), p_train_data))
+#print(train_p_n_vocab)
+
+# 获得训练集上负样本
+n_train_data = train_data[train_data["label"]==0]["sentence"]
+
+# 获取负样本的每个句子的形容词
+train_n_a_vocab = chain(*map(lambda x: get_a_list(x), n_train_data))
+
+# 调用绘制词云函数
+get_word_cloud(train_p_a_vocab)
+get_word_cloud(train_n_a_vocab)
+```
+
+训练集正样本形容词词云： 
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/ea72e29c3e63d3d480f00516b08b79b0.png)
+
+训练集负样本形容词词云：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/c0ce099d7b523abca74027e913cc4904.png)
+
+
+
+### 4.6 获得形容词词云
+
+```python
+# 获得验证集上正样本
+p_valid_data = valid_data[valid_data["label"]==1]["sentence"]
+
+# 对正样本的每个句子的形容词
+valid_p_a_vocab = chain(*map(lambda x: get_a_list(x), p_valid_data))
+#print(train_p_n_vocab)
+
+# 获得验证集上负样本
+n_valid_data = valid_data[valid_data["label"]==0]["sentence"]
+
+# 获取负样本的每个句子的形容词
+valid_n_a_vocab = chain(*map(lambda x: get_a_list(x), n_valid_data))
+
+# 调用绘制词云函数
+get_word_cloud(valid_p_a_vocab)
+get_word_cloud(valid_n_a_vocab)
+```
+
+验证集正样本形容词词云：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/ab9d71deaf7dc1c9b11ebed4d77b3291.png)
+
+验证集负样本形容词词云：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/d960fcfd7cdc99efc1391cbb2ececafc.png)
+
+分析：根据高频形容词词云显示，可对当前语料质量进行简单评估，同时对违反语料标签含义的词汇进行人工审查和修正，保证绝大多数语料符合训练标准。上图中的正样本大多数是褒义词，而负样本大多数是贬义词，基本符合要求，但负样本词云中也存在"便利"这样的褒义词，因此可人工进行审查。
+
+## 5 总结
+
+本文为各位 Javaer 提供了一系列文本数据分析方法，帮助更好地理解语料，为后续的机器学习模型训练提供基础。
+
diff --git a/docs/md/AI/ml/text-preprocessing-overview.md b/docs/md/AI/ml/text-preprocessing-overview.md
new file mode 100644
index 000000000..cfb826a65
--- /dev/null
+++ b/docs/md/AI/ml/text-preprocessing-overview.md
@@ -0,0 +1,224 @@
+# 文本预处理概述
+
+## 0 认识文本预处理
+
+### 作用
+
+文本语料在输送给模型前一般需一系列预处理，才能符合模型输入要求，如：将文本转化成模型需要的张量，规范张量的尺寸等。而且科学的文本预处理环节还将有效指导模型超参数的选择，提升模型的评估指标。
+
+### 主要环节
+
+- 文本处理的基本方法
+- 文本张量表示方法
+- 文本语料的数据分析
+- 文本特征处理
+- 数据增强方法
+
+#### 文本处理的基本方法
+
+- 分词
+- 词性标注
+- 命名实体识别
+
+#### 文本张量表示方法
+
+- one-hot编码
+- Word2vec
+- Word Embedding
+
+#### 文本语料的数据分析
+
+- 标签数量分布
+- 句子长度分布
+- 词频统计与关键词词云
+
+#### 文本特征处理
+
+- 添加n-gram特征
+- 文本长度规范
+
+#### 数据增强方法
+
+- 回译数据增强法
+
+实际生产应用，最常用中文和英文。因此，文本预处理部分的内容都将针对这两种语言进行讲解。
+
+本文主要来看文本处理的基本方法。
+
+## 1 啥是分词？
+
+将连续的字序列按一定规范重新组合成词序列的过程：
+
+- 英文的行文中，单词之间是以空格作为自然分界符的
+- 中文只是字、句和段能通过明显的分界符来简单划界，唯独词没有一个形式上的分界符，分词过程就是找到这样分界符的过程
+
+如：
+
+```bash
+工信处女干事每月经过下属科室都要亲口交代24口交换机等技术性器件的安装工作 
+
+==> 
+
+['工信处', '女干事', '每月', '经过', '下属', '科室', '都', '要', '亲口', '交代', '24', '口', '交换机', '等', '技术性', '器件', '的', '安装', '工作']
+```
+
+### 1.1 分词的作用
+
+词作为语言语义理解的最小单元，是人类理解文本语言的基础。因此也是AI解决NLP领域高阶任务，如自动问答、机器翻译、文本生成的重要基础环节。
+
+## 2 流行中文分词工具jieba
+
+愿景：“结巴”中文分词，做最好的 Python 中文分词组件。
+
+### 2.1 jieba的特性
+
+支持多种分词模式：
+
+- 精确模式
+- 全模式
+- 搜索引擎模式
+
+支持中文繁体分词
+
+支持用户自定义词典
+
+```bash
+# jieba的安装
+pip install jieba
+```
+
+### 2.2 精确模式分词
+
+试图将句子最精确切开，适合文本分析：
+
+```python
+import jieba
+content = "工信处女干事每月经过下属科室都要亲口交代24口交换机等技术性器件的安装工作"
+# 精确模式分词
+print(jieba.cut(content, cut_all=False)) # cut_all默认为False
+
+# 将返回一个生成器对象
+<generator object Tokenizer.cut at 0x7f065c19e318>
+
+# 返回列表内容
+>>> jieba.lcut(content, cut_all=False)
+['工信处', '女干事', '每月', '经过', '下属', '科室', '都', '要', '亲口', '交代', '24', '口', '交换机', '等', '技术性', '器件', '的', '安装', '工作']
+```
+
+### 2.3 全模式分词
+
+把句子中所有的可以成词的词语都扫描出来，速度非常快，但不能消除歧义：
+
+```python
+# 全模式分词
+print(jieba.cut(content, cut_all=True))
+print(jieba.lcut(content, cut_all=True))
+```
+
+### 2.4 搜索引擎模式分词
+
+基于精确模式，对长词再次切分，提高召回率，适用于搜索引擎分词：
+
+```python
+jieba.cut_for_search(content)
+
+# 若需直接返回列表内容, 使用jieba.lcut_for_search即可
+>>> jieba.lcut_for_search(content)
+['工信处', '干事', '女干事', '每月', '经过', '下属', '科室', '都', '要', '亲口', '交代', '24', '口', '交换', '换机', '交换机', '等', '技术', '技术性', '器件', '的', '安装', '工作']
+
+# 对'女干事', '交换机'等较长词汇都进行了再次分词.
+```
+
+### 2.5 中文繁体分词
+
+针对中国香港，台湾地区的繁体文本进行分词：
+
+```python
+content = "煩惱即是菩提，我暫且不提"
+print(jieba.lcut(content))
+['煩惱', '即', '是', '菩提', '，', '我', '暫且', '不', '提']
+```
+
+### 2.6 使用用户自定义词典
+
+jieba能准确识别词典中出现的词汇，提升整体的识别准确率。
+
+#### 词典格式
+
+每一行分三部分：词语、词频（可省略）、词性（可省略），空格隔开，顺序不可颠倒。
+
+词典样式如下，具体词性含义请参照附录: jieba词性对照表，将该词典存为userdict.txt, 方便之后加载使用：
+
+```bash
+云计算 5 n
+李小福 2 nr
+easy_install 3 eng
+好用 300
+韩玉赏鉴 3 nz
+八一双鹿 3 nz
+```
+
+```python
+>>> import jieba
+>>> jieba.lcut("八一双鹿更名为八一南昌篮球队！")
+# 没有使用用户自定义词典前的结果:
+>>> ['八', '一双', '鹿', '更名', '为', '八一', '南昌', '篮球队', '！']
+
+
+>>> jieba.load_userdict("./userdict.txt")
+# 使用了用户自定义词典后的结果:
+['八一双鹿', '更名', '为', '八一', '南昌', '篮球队', '！']
+```
+
+## 3 命名实体识别
+
+命名实体：通常将人名、地名、机构名等专有名词统称命名实体。如：周杰伦, 黑山县, 孔子学院, 24辊方钢矫直机。
+
+顾名思义，命名实体识别（Named Entity Recognition，简称NER）就是识别出一段文本中可能存在的命名实体。
+
+如：
+
+```bash
+鲁迅, 浙江绍兴人, 五四新文化运动的重要参与者, 代表作朝花夕拾.
+
+==>
+
+鲁迅(人名) / 浙江绍兴(地名)人 / 五四新文化运动(专有名词) / 重要参与者 / 代表作 / 朝花夕拾(专有名词)
+```
+
+命名实体也是人类理解文本的基础单元。
+
+## 4 词性标注（Part-Of-Speech tagging）
+
+简称POS。
+
+词性：语言中对词的一种分类方法，以语法特征为主要依据、兼顾词汇意义对词进行划分的结果，常见词性有14种，如名词、动词和形容词等。
+
+顾名思义，词性标注就是标注出一段文本中每个词汇的词性，如：
+
+```bash
+我爱自然语言处理
+
+==>
+
+我/rr, 爱/v, 自然语言/n, 处理/vn
+
+rr: 人称代词
+v: 动词
+n: 名词
+vn: 动名词
+```
+
+### 作用
+
+词性标注以分词为基础，是对文本语言的另一个角度的理解。
+
+### jieba标注中文词性
+
+```python
+import jieba.posseg as pseg
+print(pseg.lcut('我爱北京天安门'))
+
+# 结果返回一个装有pair元组的列表, 每个pair元组中分别是词汇及其对应的词性, 具体词性含义请参照附录: jieba词性对照表
+[pair('我', 'r'), pair('爱', 'v'), pair('北京', 'ns'), pair('天安门', 'ns')]
+```
\ No newline at end of file
diff --git a/docs/md/AI/ml/text-vectorization-guide.md b/docs/md/AI/ml/text-vectorization-guide.md
new file mode 100644
index 000000000..c43aa7ba7
--- /dev/null
+++ b/docs/md/AI/ml/text-vectorization-guide.md
@@ -0,0 +1,334 @@
+# 90%的开发者都忽略的文本向量化技巧！
+
+## 1 啥是文本张量表示？
+
+将一段文本使用张量表示，一般将词汇表示成向量，称作词向量，再由各个词向量按序组成矩阵形成文本表示，如：
+
+```bash
+["人生", "该", "如何", "起头"]
+
+==>
+
+# 每个词对应矩阵中的一个向量
+[[1.32, 4,32, 0,32, 5.2],
+ [3.1, 5.43, 0.34, 3.2],
+ [3.21, 5.32, 2, 4.32],
+ [2.54, 7.32, 5.12, 9.54]]
+```
+
+## 2 作用
+
+文本表示成张量（矩阵）形式，能使语言文本可作为计算机处理程序的输入，进行后续的解析工作。
+
+## 3 表示方法
+
+### 3.1 one-hot词向量表示
+
+又称独热编码，将每个词表示成具有n个元素的向量，这个词向量中只有一个元素是1，其他元素都是0，不同词汇元素为0的位置不同。
+
+n的大小是整个语料中不同词汇的总数，如：
+
+```
+["改变", "要", "如何", "起手"]`
+==>
+
+[[1, 0, 0, 0],
+ [0, 1, 0, 0],
+ [0, 0, 1, 0],
+ [0, 0, 0, 1]]
+```
+
+#### one-hot编码实现
+
+```python
+# 导入用于对象保存与加载的joblib
+from sklearn.externals import joblib
+# 导入keras中的词汇映射器Tokenizer
+from keras.preprocessing.text import Tokenizer
+# 假定vocab为语料集所有不同词汇集合
+vocab = {"周杰伦", "陈奕迅", "王力宏", "李宗盛", "吴亦凡", "鹿晗"}
+# 实例化一个词汇映射器对象
+t = Tokenizer(num_words=None, char_level=False)
+# 使用映射器拟合现有文本数据
+t.fit_on_texts(vocab)
+
+for token in vocab:
+    zero_list = [0]*len(vocab)
+    # 使用映射器转化现有文本数据, 每个词汇对应从1开始的自然数
+    # 返回样式如: [[2]], 取出其中的数字需要使用[0][0]
+    token_index = t.texts_to_sequences([token])[0][0] - 1
+    zero_list[token_index] = 1
+    print(token, "的one-hot编码为:", zero_list)
+
+# 使用joblib工具保存映射器, 以便之后使用
+tokenizer_path = "./Tokenizer"
+joblib.dump(t, tokenizer_path)
+```
+
+输出效果:
+
+```
+鹿晗 的one-hot编码为: [1, 0, 0, 0, 0, 0]
+王力宏 的one-hot编码为: [0, 1, 0, 0, 0, 0]
+李宗盛 的one-hot编码为: [0, 0, 1, 0, 0, 0]
+陈奕迅 的one-hot编码为: [0, 0, 0, 1, 0, 0]
+周杰伦 的one-hot编码为: [0, 0, 0, 0, 1, 0]
+吴亦凡 的one-hot编码为: [0, 0, 0, 0, 0, 1]
+
+# 同时在当前目录生成Tokenizer文件, 以便之后使用
+```
+
+#### one-hot编码器的使用
+
+```
+# 导入用于对象保存与加载的joblib
+# from sklearn.externals import joblib
+# 加载之前保存的Tokenizer, 实例化一个t对象
+t = joblib.load(tokenizer_path)
+
+# 编码token为"李宗盛"
+token = "李宗盛"
+# 使用t获得token_index
+token_index = t.texts_to_sequences([token])[0][0] - 1
+# 初始化一个zero_list
+zero_list = [0]*len(vocab)
+# 令zero_List的对应索引为1
+zero_list[token_index] = 1
+print(token, "的one-hot编码为:", zero_list) 
+```
+
+输出：
+
+```
+李宗盛 的one-hot编码为: [1, 0, 0, 0, 0, 0]
+```
+
+#### one-hot编码评价
+
+- 优势：操作简单，易理解
+- 劣势：完全割裂了词与词之间的联系，而且在大语料集下，每个向量的长度过大，占据大量内存
+
+正因这明显劣势，该编码方式应用越来越少，取而代之是稠密向量的表示方法word2vec和word embedding。
+
+### 3.2 word2vec
+
+一种将词汇表示成向量的无监督训练方法，该过程将构建神经网络模型，将网络参数作为词汇的向量表示，包含如下两种训练模式：
+
+#### 3.2.1 CBOW（Continuous bag of words）
+
+给定一段用于训练的文本语料，再选定某段长度（窗口）作为研究对象，使用上下文词汇预测目标词汇：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/feb3d6b162568f4c14ddeafe4cf463b3.png)
+
+图中窗口大小为9，使用前后4个词汇对目标词汇进行预测。
+
+##### 执行过程
+
+若给定训练语料仅一句话：Hope can set you free（愿你自由成长），窗口大小为3，因此模型的第一个训练样本来自Hope can set。CBOW模式，所以将使用Hope和set作输入，can作输出，在模型训练时， Hope，can，set等词汇都使用它们的one-hot编码，如图所示: 每个one-hot编码的单词与各自的变换矩阵（即参数矩阵3x5，3指最后得到的词向量维度）相乘之后再相加，得到上下文表示矩阵(3x1)：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/60b08bb9cbd54659ed727cb22b868de2.png)
+
+再将上下文表示矩阵与变换矩阵（参数矩阵5x3, 所有的变换矩阵共享参数）相乘，得到5x1的结果矩阵，它将与我们真正的目标矩阵即can的one-hot编码矩阵(5x1)进行损失计算，再更新网络参数完成一次模型迭代。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/121a4973bfd434bbb5ac3e4bd0a76db6.png)
+
+最后窗口按序向后移动，重新更新参数，直到所有语料被遍历完成，得到最终的变换矩阵(3x5)，这个变换矩阵与每个词汇的one-hot编码(5x1)相乘，得到的3x1的矩阵就是该词汇的word2vec张量表示.
+
+#### 3.2.2 skipgram
+
+给定一段用于训练的文本语料，再选定某段长度（窗口）作为研究对象，使用目标词汇预测上下文词汇。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/943e52f81ec86cb2d2848aca59da5791.png)
+
+图中窗口大小为9, 使用目标词汇对前后四个词汇进行预测。
+
+#### 执行过程
+
+Hope can set you free，窗口大小为3，因此模型的第一个训练样本来自Hope can set，因skipgram模式，所以将用can作输入 ，Hope和set作输出。
+
+模型训练时， Hope，can，set等词汇都使用它们的one-hot编码. 如图所示: 将can的one-hot编码与变换矩阵(即参数矩阵3x5, 这里的3是指最后得到的词向量维度)相乘, 得到目标词汇表示矩阵(3x1)。
+
+再将目标词汇表示矩阵与多个变换矩阵(参数矩阵5x3)相乘, 得到多个5x1的结果矩阵, 它将与我们Hope和set对应的one-hot编码矩阵(5x1)进行损失的计算，再更新网络参数完成一次模型迭代。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/8772625aaa3cfcaf5312e052f73b9270.png)
+
+最后窗口按序向后移动，重新更新参数，直到所有语料被遍历完成，得到最终的变换矩阵即参数矩阵(3x5)，这个变换矩阵与每个词汇的one-hot编码(5x1)相乘，得到的3x1的矩阵就是该词汇的word2vec张量表示。
+
+## 4 使用fasttext训练和使用word2vec
+
+### 4.1 第一步: 获取训练数据
+
+将研究英语维基百科的部分网页信息，大小约300M。可通过Matt Mahoney的网站下载。
+
+```bash
+# 下载数据的zip压缩包, 存储在data目录
+$ wget -c http://mattmahoney.net/dc/enwik9.zip -P data
+# 解压后在data目录下会出现enwik9文件夹
+$ unzip data/enwik9.zip -d data
+```
+
+查看原始数据:
+
+```bash
+$ head -10 data/enwik9
+
+# 原始数据将输出很多包含XML/HTML格式的内容, 这些内容并不是我们需要的
+<mediawiki xmlns="http://www.mediawiki.org/xml/export-0.3/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.mediawiki.org/xml/export-0.3/ http://www.mediawiki.org/xml/export-0.3.xsd" version="0.3" xml:lang="en">
+  <siteinfo>
+    <sitename>Wikipedia</sitename>
+    <base>http://en.wikipedia.org/wiki/Main_Page</base>
+    <generator>MediaWiki 1.6alpha</generator>
+    <case>first-letter</case>
+      <namespaces>
+      <namespace key="-2">Media</namespace>
+      <namespace key="-1">Special</namespace>
+      <namespace key="0" />
+```
+
+原始数据处理:
+
+```bash
+# 使用wikifil.pl文件处理脚本来清除XML/HTML格式的内容
+# 注: wikifil.pl文件已为大家提供
+$ perl wikifil.pl data/enwik9 > data/fil9
+```
+
+查看预处理后的数据:
+
+```bash
+# 查看前80个字符
+head -c 80 data/fil9
+
+# 输出结果为由空格分割的单词
+ anarchism originated as a term of abuse first used against early working class
+```
+
+### 4.2 第二步: 训练词向量
+
+```python
+# 代码运行在python解释器中
+# 导入fasttext
+>>> import fasttext
+# 使用fasttext的train_unsupervised(无监督训练方法)进行词向量的训练
+# 它的参数是数据集的持久化文件路径'data/fil9'
+>>> model = fasttext.train_unsupervised('data/fil9')
+
+
+# 有效训练词汇量为124M, 共218316个单词
+Read 124M words
+Number of words:  218316
+Number of labels: 0
+Progress: 100.0% words/sec/thread:   53996 lr:  0.000000 loss:  0.734999 ETA:   0h 0m
+```
+
+查看单词对应的词向量：
+
+```python
+# 通过get_word_vector方法来获得指定词汇的词向量
+>>> model.get_word_vector("the")
+
+array([-0.03087516,  0.09221972,  0.17660329,  0.17308897,  0.12863874,
+        0.13912526, -0.09851588,  0.00739991,  0.37038437, -0.00845221,
+        ...
+       -0.21184735, -0.05048715, -0.34571868,  0.23765688,  0.23726143],
+      dtype=float32)
+```
+
+### 4.3 第三步: 模型超参数设定
+
+```bash
+# 在训练词向量过程中, 我们可以设定很多常用超参数来调节我们的模型效果, 如:
+# 无监督训练模式: 'skipgram' 或者 'cbow', 默认为'skipgram', 在实践中，skipgram模式在利用子词方面比cbow更好.
+# 词嵌入维度dim: 默认为100, 但随着语料库的增大, 词嵌入的维度往往也要更大.
+# 数据循环次数epoch: 默认为5, 但当你的数据集足够大, 可能不需要那么多次.
+# 学习率lr: 默认为0.05, 根据经验, 建议选择[0.01，1]范围内.
+# 使用的线程数thread: 默认为12个线程, 一般建议和你的cpu核数相同.
+
+>>> model = fasttext.train_unsupervised('data/fil9', "cbow", dim=300, epoch=1, lr=0.1, thread=8)
+
+Read 124M words
+Number of words:  218316
+Number of labels: 0
+Progress: 100.0% words/sec/thread:   49523 lr:  0.000000 avg.loss:  1.777205 ETA:   0h 0m 0s
+```
+
+### 4.4 第四步: 模型效果检验
+
+```bash
+# 检查单词向量质量的一种简单方法就是查看其邻近单词, 通过我们主观来判断这些邻近单词是否与目标单词相关来粗略评定模型效果好坏.
+
+# 查找"运动"的邻近单词, 我们可以发现"体育网", "运动汽车", "运动服"等. 
+>>> model.get_nearest_neighbors('sports')
+
+[(0.8414610624313354, 'sportsnet'), (0.8134572505950928, 'sport'), (0.8100415468215942, 'sportscars'), (0.8021156787872314, 'sportsground'), (0.7889881134033203, 'sportswomen'), (0.7863013744354248, 'sportsplex'), (0.7786710262298584, 'sporty'), (0.7696356177330017, 'sportscar'), (0.7619683146476746, 'sportswear'), (0.7600985765457153, 'sportin')]
+
+
+# 查找"音乐"的邻近单词, 我们可以发现与音乐有关的词汇.
+>>> model.get_nearest_neighbors('music')
+
+[(0.8908010125160217, 'emusic'), (0.8464668393135071, 'musicmoz'), (0.8444250822067261, 'musics'), (0.8113634586334229, 'allmusic'), (0.8106718063354492, 'musices'), (0.8049437999725342, 'musicam'), (0.8004694581031799, 'musicom'), (0.7952923774719238, 'muchmusic'), (0.7852965593338013, 'musicweb'), (0.7767147421836853, 'musico')]
+
+# 查找"小狗"的邻近单词, 我们可以发现与小狗有关的词汇.
+>>> model.get_nearest_neighbors('dog')
+
+[(0.8456876873970032, 'catdog'), (0.7480780482292175, 'dogcow'), (0.7289096117019653, 'sleddog'), (0.7269964218139648, 'hotdog'), (0.7114801406860352, 'sheepdog'), (0.6947550773620605, 'dogo'), (0.6897546648979187, 'bodog'), (0.6621081829071045, 'maddog'), (0.6605004072189331, 'dogs'), (0.6398137211799622, 'dogpile')]
+```
+
+### 4.5 第五步: 模型的保存与重加载
+
+```bash
+# 使用save_model保存模型
+>>> model.save_model("fil9.bin")
+
+# 使用fasttext.load_model加载模型
+>>> model = fasttext.load_model("fil9.bin")
+>>> model.get_word_vector("the")
+
+array([-0.03087516,  0.09221972,  0.17660329,  0.17308897,  0.12863874,
+        0.13912526, -0.09851588,  0.00739991,  0.37038437, -0.00845221,
+        ...
+       -0.21184735, -0.05048715, -0.34571868,  0.23765688,  0.23726143],
+      dtype=float32)
+```
+
+## 5 word embedding（词嵌入）
+
+通过一定方式将词汇映射到指定维度(一般是更高维)的空间：
+
+- 广义包括所有密集词汇向量的表示方法，如word2vec
+- 狭义指在神经网络中加入的embedding层，对整个网络进行训练的同时产生的embedding矩阵(embedding层的参数)，这个embedding矩阵就是训练过程中所有输入词汇的向量表示组成的矩阵
+
+### 5.1 可视化分析
+
+通过tensorboard可视化嵌入的词向量：
+
+```python
+# 导入torch和tensorboard的摘要写入方法
+import torch
+import json
+import fileinput
+from torch.utils.tensorboard import SummaryWriter
+# 实例化一个摘要写入对象
+writer = SummaryWriter()
+
+# 随机初始化一个100x50的矩阵, 认为它是我们已经得到的词嵌入矩阵
+# 代表100个词汇, 每个词汇被表示成50维的向量
+embedded = torch.randn(100, 50)
+
+# 导入事先准备好的100个中文词汇文件, 形成meta列表原始词汇
+meta = list(map(lambda x: x.strip(), fileinput.FileInput("./vocab100.csv")))
+writer.add_embedding(embedded, metadata=meta)
+writer.close()
+```
+
+终端启动tensorboard服务：
+
+```bash
+$ tensorboard --logdir runs --host 0.0.0.0
+
+# 通过http://0.0.0.0:6006访问浏览器可视化页面
+```
+
+浏览器展示并可以使用右侧近邻词汇功能检验效果：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/9247c413a6793c56bbaa6910f257924a.png)
\ No newline at end of file
diff --git a/docs/md/AI/overcoming-fear-uncertainty-and-doubt-in-the-era-of-ai-transformation.md b/docs/md/AI/overcoming-fear-uncertainty-and-doubt-in-the-era-of-ai-transformation.md
new file mode 100644
index 000000000..25c2f0810
--- /dev/null
+++ b/docs/md/AI/overcoming-fear-uncertainty-and-doubt-in-the-era-of-ai-transformation.md
@@ -0,0 +1,42 @@
+# 克服 AI 时代的恐惧、不确定性和疑虑
+
+## 1 学习咋通过培养 AI 技能，提高职场对 AI 的积极性
+
+职场中抵触 AI 的现象确实存在。很多人并非不愿意接受变化，而是因为对 AI 存在“FUD”——即*恐惧（Fear）、不确定性（Uncertainty）和疑虑（Doubt）*。
+
+要在 AI 转型时代取得成功，必须积极应对这些 FUD，并**营造一种支持学习的文化，让员工能够适应和成长**，最终推动整个组织共同进步。
+
+大厂们都始终在内部率先使用和测试自家的 AI 技术，然后才推向客户。因此他们深知理解 FUD 的根源、找到积极的解决方案，并提供实用的应对措施的重要性。通过学习 AI 技能，了解 AI 如何优化工作流程、提升决策能力和提高生产力，可有效减少担忧，让人们对这项前沿技术更加充满信心。
+
+## 2 化恐惧为机遇
+
+职场中最常见的 AI 相关恐惧，莫过于“AI 会导致失业”。但事实上，许多专家对此持乐观态度。根据 [联合国国际劳工组织（ILO）的研究](https://www.ilo.org/resource/news/generative-ai-likely-augment-rather-destroy-jobs)，AI **更可能增强而非取代工作岗位**，它主要通过自动化某些任务来辅助人类，而非完全取代某个职位。因此，未来许多工作角色可能会演变成“AI + 人工”混合模式，让 AI 成为工作得力副手。
+
+在这种工作模式转变的背景下，**AI 技能的需求持续增长**，这对于各行各业的员工而言都是一个发展机遇。主动学习 AI 技能，可帮助员工适应新的工作环境，并增强他们对 AI 技术的信心。对于企业而言，提供 AI 技能培训不仅能帮助员工成长，也能提升组织整体的竞争力。
+
+## 3 通过学习文化消除 AI 带来的不确定性
+
+AI 技术的发展速度之快，让人们对其感到不确定甚至迷茫。但事实上，我们都处在一个“边学边用”的阶段。其实我们在测试 AI 应用和服务的过程中，也不断探索 AI 的潜力。同样地，职场中的每个人都需要尝试使用 AI，才能真正理解它的能力。一个良好的组织学习文化，可以帮助团队克服不确定性，快速适应 AI 变革。
+
+沃顿商学院管理学教授、AI 与创业领域的知名专家 Ethan Mollick 认为，**最大的收益来自那些鼓励协作学习的组织**。在 [*Beyond the Prompt* 播客](https://podcast.beyondtheprompt.ai/episodes/practical-strategies-for-leveraging-ai-in-your-business-wharton-professor-ethan-mollick)的一期节目《企业如何正确使用 AI》中，他强调：“一切都始于文化。”
+
+该节目还提出了一条重要建议：“尽可能多地使用 AI，真正理解它的能力，最好的方式就是让它参与尽可能多的任务。”
+
+## 4 为团队提供 AI 培训
+
+想要克服 AI 相关的恐惧、不确定性和疑虑，**关键在于技能培训和学习文化**，而团队培训环境可以有效支持这一成长过程。提高员工信心：
+
+- 完整的 AI 技能培养手册，帮助企业制定 AI 培训计划，最大化个人、团队和组织层面的学习成效
+- 提供 AI 技能培训资源、课程及建立学习型文化的策略和见解
+- Copilot 学习中心、AI 学习中心和安全学习中心
+- 提供最新的 AI 技术培训计划，如“使用 GitHub 构建、测试和部署应用程序”，“在AI Studio中实施数据集成和模型优化”，“利用 GitHub Copilot 加速应用开发”等
+- 增强 AI 和云计算领域的专业技能，适应关键岗位和项目需求
+
+技能认证：
+
+- 验证特定岗位所需的全面技能，需通过考试获得。例如数据科学家认证。
+- 应用技能认证：侧重于实际技术场景，通过互动实验评估技能。超过一半的应用技能认证与 AI 相关，例如“使用AI Language 构建自然语言处理解决方案”和“使用 AI 文档智能创建智能文档处理解决方案”等
+
+## 5 总结
+
+培养 AI 技能不仅能帮助个人和团队适应 AI 时代的变革，还能增强组织的竞争力。通过持续学习和实践，我们可以克服恐惧、不确定性和疑虑，让 AI 成为提升工作效率和创新能力的强大工具。
\ No newline at end of file
diff --git a/docs/md/trade/high-avail-payments.md b/docs/md/trade/high-avail-payments.md
new file mode 100644
index 000000000..49d51627a
--- /dev/null
+++ b/docs/md/trade/high-avail-payments.md
@@ -0,0 +1,87 @@
+# 如何避免半夜崩溃？支付系统高可用性实践！
+
+## 1 系统高可用性保障
+
+某支付渠道出现异常的情况时，降级和熔断是我们常用的一种方式，但其对用户的还款体验会有较大的影响，且无法更精准的缩小其影响范围。因此根据支付渠道降级的业务策略来调控某一渠道异常后的路由权重，通过滑动窗口算法来统计和监控渠道某个时间段内异常的比例和绝对数量，达到一定阈值后负反馈给支付路由引擎，在其对支付渠道进行筛选和排序时降低异常渠道的权重，进而调节该异常渠道的使用情况。在降低影响的同时又不会因部分的异常全部关停该渠道的请求，达到智能调控。
+
+### 1.1 精准高效的支付路由
+
+为达到选出最优支付渠道及提高性能的效果，支付系统还设计一套支持多场景下的渠道选取的路由算法。
+
+渠道决策树算法以经典决策树算法为核心思想，结合以路由策略形成的一种渠道路由排序算法。根据支付方式不同，收集在当前场景下要进行计算的条件作为节点，构建出一个树模型。然后将备选渠道从根节点进入，经由节点的筛选结果流向不同的分支，最终完成备选渠道的排序过程。
+
+采用渠道决策树算法对渠道进行排序的优势：
+
+- 节点生成灵活简单，可根据支付方式不同定制组合不同的排序条件拼装成一个决策树，这种拼装方式可扩展，在我们丰富路由策略时，可零代码快捷适配新的策略配置
+- 高效，在决策排序过程中，利用其分类和归纳的特点在 O（nlogn）的复杂度下快速获得结果
+
+![](https://codeselect.oss-cn-shanghai.aliyuncs.com/c3c31dbe8fbf6b995efe87955ab41e42.png)
+
+渠道路由的策略包含人工配置的一些渠道客观条件，如业务支持银行信息、支付限额等，也有根据渠道的表现自动做出的权重策略调整，如渠道异常后的自动负反馈调节策略。
+
+### 1.2 负反馈调节算法
+
+监控渠道的健康情况，针对渠道异常时，统计异常情况并形成一个指标负反馈给支付路由，达到动态调整渠道权重。思想来自 Sentinel  一种限流算法滑动窗口算法，将时间窗口划分若干时间片段，每过一个时间片段时间窗口会向右滑动一格，每个时间片段都有独立计数器。所以统计整个时间窗口的请求数时只需累加所有的时间片段的数据。时间窗口划分越细，滑动越平滑，统计越精确。
+
+#### 滑动窗口优点
+
+- 无临界值问题
+- 统计精度高
+- 保证统计区间的连续性
+- 渠道异常时可快速调节
+- ...
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/08/040369e2f5cc8c7cc7f450b7463ba685.png)
+
+如负反馈调节算法以 10s 作为统计的时间窗口大小 LeapArray，并配置 5 个样本数 SimpleCount。即对应算法的时间窗口大小为 10s，包含 5 个时间片段，每个时间片段2s，存储的数据记作为指标桶 MetricBucket，其结构为支付渠道+结算主体+支付方式维度的响应数量及响应异常数量。其应用效果要分两阶段：
+
+- 在渠道路由请求时，要根据当前时间按照窗口时长进行分段，拿到当前时间对应的分段 ID，并取出对应的窗口返回去给对应的统计逻辑进行阈值判断
+- 需在渠道请求的拦截方法中，在得到请求响应后，使用同样计算方式得到当前时间窗口及时间片段，并通过业务条件判断对 total 和 error 等统计指标进行调整，将数据存入当前时间片段的指标桶
+
+![](https://codeselect.oss-cn-shanghai.aliyuncs.com/cdcda03155cc16605fc2bd9f1a9231bd.png)
+
+在渠道路由阶段得到窗口中的统计数据后需要和设定阈值条件作对比，得出当前渠道的健康权重分数。从两个维度提供阈值条件：
+
+- 绝对数量，同一时间窗口内若有超过 10 条（该值可配置调整）异常的支付请求，则将异常请求的数量 n 除以该时间窗口 10 秒内总订单数量 m 得到结果 y1，乘以其权重基准值 10，得到结果 10y1
+- 异常比例，即在同一时间窗口内若有超过 10%（该值可通过配置调整）的异常支付请求，则以同样的方式计算出异常订单比例结果为 y2，乘以其权重基准值 10，得到结果 10y2
+
+最后通过公式 10-（10n/m）得到最终的系统权值评分，分值越高代表支付渠道的权重越高，排序越靠前。
+
+## 2 系统自适应压力调节能力
+
+任何系统都有业务处理的瓶颈上限，肉没法精准的压力识别，导致任务并发量或资源占用明显超过服务器支撑范围，则直接影响线上服务稳定。系统实现过程中，搭建压力检测服务，通过该服务动态识别机器、组件的运行压力，进行反向调节业务请求速率、并发等限制，以此来达到保护生产服务稳定性的目的。
+
+![](https://codeselect.oss-cn-shanghai.aliyuncs.com/6f45d9db694f464e306d5b8d5f163a37.png)
+
+压力检测技术，支付系统除自身服务节点，还关联多个组件服务。如 MySQL、RabbitMQ 。如何让系统能自动感知整个支付流程中某节点出现性能瓶颈呢？
+
+压力指数是压力检测服务定义的一个性能指标，包含：
+
+- 系统服务节点的压力指标
+- 系统依赖的组件的一些核心指标，如服务节点的 JVM 内存、CPU 消耗，MySQL 的连接数、主从同步延迟，RabbitMQ 队列积压量
+
+压力检测服务通过将以上多个维度的指标通过一定的权重比计算出压力指数，再根据全链路压测结果以及故障演练等方式总结出一个适当的阈值梯度。
+
+压力检测服务计算出的压力指数达到一定的阈值梯度后，会通知支付系统进行限流处理。同时将该指数上报给系统调用方，达到从源头降低压力的效果。当压力指数一直处于高位并保持一段时间后，会触发系统告警，由人工介入排查压力情况是否正常。
+
+## 3 组件降级提升系统高可用性
+
+支付系统采用 RabbitMQ 作为异步消息组件，连通整个支付流程，选用RabbitMQ原因：
+
+- 保障金融系的稳定性，需要防止消息丢失，要支持消息持久化
+- 考虑业务的复杂性，需要支持队列的延迟特性
+- 结合性能和稳定性的综合考量，以及组件的成熟度
+
+Q：RabbitMQ在支付系统起总线作用，那就要考虑异常时的降级措施。
+
+A：MQ不存储任何数据、无业务逻辑和复杂性的组件，集成在服务中的主要功能是解耦和削峰。替代方案中也需支持解耦和削峰功能的组件，同时尽量避免增加系统复杂度。筛选后，选取 Redis 作为降级替代组件，MQ异常时，舍弃部分 ack 机制，用 Redis 的 list 结构作为异步队列进行异步生产和消费，zset 结构作为延迟队列。支付系统在请求 RabbitMQ 发送消息多次重试都失败后，会将消息体存入 Redis 数组中，继续由 Redis 作为替代队列完成消息的生产与消费。同时，为了保证数据的完整性和一致性，我们还需要做到以下几点来完善 Redis 在整个流程中的 MQ 效果：
+
+- MQ 异常后的快速感知和切换
+- 动态调节 Redis 生产和消费的速率，防止 Redis 内存占用过大
+- 做好消息的幂等消费
+
+目前，支付系统大部分核心队列及全部非核心流程队列已支持 MQ 的故障切换，异常感知和切换时效达到3s内，为服务高可用性提供保障。
+
+## 4 规划
+
+未来流量激增，可横向扩充节点及自动压力调节和主动降级等方式，将支付处理能力快速提高 5-10 倍水平。
\ No newline at end of file

From af5c63a361e579edacfc06c3c4e6c7e3faa5a93e Mon Sep 17 00:00:00 2001
From: JavaEdge <sss2855845850@gmail.com>
Date: Tue, 18 Mar 2025 16:49:08 +0800
Subject: [PATCH 09/20] =?UTF-8?q?docs:=E6=9B=B4=E6=96=B0=20=20NLP=E3=80=81?=
 =?UTF-8?q?RNN=20=E4=B8=93=E6=A0=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/.vuepress/config.js                      |  12 +
 .../llm/02-\345\270\270\347\224\250Prompt.md" |  13 +-
 ...feature-enhancement-to-dimensional-norm.md |  92 ++++++
 ...ral-memory-engine-for-sequence-modeling.md | 261 +++++++++++++++
 ...ata-augmentation-back-translation-guide.md | 147 +++++++++
 docs/md/AI/ml/what-is-rnn.md                  | 299 ++++++++++++++++++
 6 files changed, 819 insertions(+), 5 deletions(-)
 create mode 100644 docs/md/AI/ml/key-path-from-feature-enhancement-to-dimensional-norm.md
 create mode 100644 docs/md/AI/ml/neural-memory-engine-for-sequence-modeling.md
 create mode 100644 docs/md/AI/ml/text-data-augmentation-back-translation-guide.md
 create mode 100644 docs/md/AI/ml/what-is-rnn.md

diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index e5ac46886..4ee5ba3a1 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -2186,6 +2186,18 @@ module.exports = {
                             "text-preprocessing-overview",
                             "text-vectorization-guide",
                             "text-data-analysis-practical-guide",
+                            "key-path-from-feature-enhancement-to-dimensional-norm",
+                            "text-data-augmentation-back-translation-guide",
+                        ]
+                    },
+                    
+                    {
+                        title: "RNN",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "what-is-rnn",
+                            "neural-memory-engine-for-sequence-modeling",
                         ]
                     },
                 
diff --git "a/docs/md/AI/llm/02-\345\270\270\347\224\250Prompt.md" "b/docs/md/AI/llm/02-\345\270\270\347\224\250Prompt.md"
index 64d7494b7..0280ec8bd 100644
--- "a/docs/md/AI/llm/02-\345\270\270\347\224\250Prompt.md"
+++ "b/docs/md/AI/llm/02-\345\270\270\347\224\250Prompt.md"
@@ -25,7 +25,7 @@
 ### 1.2 翻译
 
 
-```java
+```bash
 
 你是一位精通简体中文的专业翻译，尤其擅长将专业学术论文翻译成浅显易懂的科普文章。请你帮我将以下英文段落翻译成中文，风格与中文科普读物相似。
 
@@ -70,11 +70,14 @@
 ***
 
 ### 意译
-```
-{意译结果}
-```
+【意译结果】
 
-现在请按照上面的要求从第一行开始翻译以下内容为简体中文：
+现在请按照上面的要求从第一行开始翻译以下内容为简体中文【】
 ```
 
+### 1.3 SEO-slug
+
+```bash
+Prompt：
+This GPT will convert input titles or content into SEO-friendly English URL slugs. The slugs will clearly convey the original meaning while being concise and not exceeding 60 characters. If the input content is too long, the GPT will first condense it into an English phrase within 60 characters before generating the slug. If the title is too short, the GPT will prompt the user to input a longer title. Special characters in the input will be directly removed.
 ```
\ No newline at end of file
diff --git a/docs/md/AI/ml/key-path-from-feature-enhancement-to-dimensional-norm.md b/docs/md/AI/ml/key-path-from-feature-enhancement-to-dimensional-norm.md
new file mode 100644
index 000000000..9b0925a03
--- /dev/null
+++ b/docs/md/AI/ml/key-path-from-feature-enhancement-to-dimensional-norm.md
@@ -0,0 +1,92 @@
+# 精准识别客户投诉：你的智能客服为什么总是抓不住核心诉求？（附特征优化方案）
+
+文本特征处理：从特征增强到维度规范的关键路径
+
+## 1 特征工程的意义
+
+nlp任务中，原始文本经数值映射后形成的词向量序列，难充分表达语言深层语义特征。就需引入文本特征增强技术：
+
+- 语义信息补全：突破单词语义局限，捕获词序关联特征
+- 模型适配优化：构建符合算法输入规范的矩阵结构
+- 评估指标提升：通过特征增强直接影响模型准确率、召回率等核心KPI
+
+如电商评论情感分析场景，单纯用词频特征可能导致"这个手机质量差得惊人"和"这个手机质量惊人地差"被判定为相同语义，此时bi-gram特征可有效捕捉关键短语差异。
+
+## 2 n-gram特征增强实战
+
+### 2.1 上下文特征捕获原理
+
+n-gram模型通过滑动窗口机制，将连续出现的n个词汇单元作为组合特征。
+
+#### 技术演进路径特点
+
+- **bi-gram**（n=2）：捕获短语级搭配特征，如"流量套餐" V.S"套餐推荐"
+- **tri-gram**（n=3）：识别短句模式，如"送货速度快"的正面评价特征
+- **高阶组合**（n≥4）：适用于专业领域术语识别，但需警惕维度爆炸
+
+技术误区警示：客服对话场景中，过度追求5-gram特征可能导致特征空间膨胀100倍，显著增加模型训练成本，需结合TF-IDF进行特征筛选。
+
+### 2.2 特征生成算法实现
+
+```python
+def generate_ngram_features(token_ids, n=2):
+    """
+    构建上下文特征增强引擎
+    :param token_ids: 词汇ID序列，如 [142, 29, 87]
+    :param n: 上下文窗口长度
+    :return: n-gram特征集合
+    """
+    return set(zip(*[token_ids[i:] for i in range(n)]))
+```
+
+**实战应用示例**：
+
+```python
+comment_tokens = [15, 239, 76, 89]  # 对应"快递 服务 非常 差"
+ngrams = generate_ngram_features(comment_tokens, n=2)
+print(ngrams)
+# 输出: {(15,239), (239,76), (76,89)} 捕获关键负面评价组合
+```
+
+## 3 文本维度标准化工程
+
+### 3.1 长度规范的技术必要性
+
+深度学习场景下，文本张量须满足维度统一要求，主要原因包括：
+
+1. **计算资源优化**：GPU并行计算需要统一矩阵维度
+2. **模型结构限制**：LSTM等网络需要预设时间步长
+3. **信息密度平衡**：避免长文本噪声干扰和短文本信息丢失
+
+某电商平台数据分析显示，90%的用户评论集中在15-50个字符长度区间。因此设置cutlen=40可覆盖主要语料，同时进行智能截断处理。
+
+### 3.2 动态截补策略实现
+
+```python
+from keras.preprocessing.sequence import pad_sequences
+
+def dynamic_padding(text_matrix, maxlen=40, padding='post', truncating='pre'):
+    """
+    智能文本维度校准器
+    :param text_matrix: 原始文本矩阵
+    :param maxlen: 最大保留长度（根据数据分布设定）
+    :param padding: 补零策略（post表示后补）
+    :param truncating: 截断策略（pre表示前截）
+    :return: 标准维度文本矩阵
+    """
+    return pad_sequences(text_matrix, maxlen=maxlen, 
+                        padding=padding, truncating=truncating)
+```
+
+**策略选择建议**：
+
+- 商品标题处理：优先保留尾部关键词（post-truncating）
+- 新闻正文处理：保留开头导语（pre-truncating）
+- 对话场景处理：滑动窗口截取核心片段
+
+## 4 工程落地建议
+
+1. **特征维度控制**：当词汇表规模为20k时，bi-gram特征控制在50k以内
+2. **动态长度策略**：按不同业务线设置差异化的cutlen参数
+3. **混合特征工程**：将n-gram与字符级特征进行多维度融合
+4. **监控反馈机制**：建立特征重要性评估体系，持续迭代特征方案
\ No newline at end of file
diff --git a/docs/md/AI/ml/neural-memory-engine-for-sequence-modeling.md b/docs/md/AI/ml/neural-memory-engine-for-sequence-modeling.md
new file mode 100644
index 000000000..a006b3477
--- /dev/null
+++ b/docs/md/AI/ml/neural-memory-engine-for-sequence-modeling.md
@@ -0,0 +1,261 @@
+# 越复杂的模型越蠢？传统RNN在短序列任务中的逆袭之道
+
+## 1 时序建模的神经密码本
+
+### 1.1 循环神经元的记忆引擎
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/3d0d2301aff0e8c3536b8700a2575f4f.png)
+
+传统RNN单元如同精密的机械钟表，RNN就像一个有记忆的程序，能处理时间序列数据（比如用户一天的点击记录）。把它想象成一个老式钟表，每次“滴答”都会记住上一次的状态，再加上当前输入，算出下一步。关键在于它有“记忆引擎”，能把过去的信息传递下去。
+
+### 1.2 关键组件
+
+```python
+# 典型RNN单元计算过程
+# x_t是当前输入（比如用户刚点的商品）
+# h_prev是上一次的“记忆”（之前点了啥）
+def rnn_cell(x_t, h_prev):
+    # 记忆融合层：拼接当前输入与历史记忆
+    # fused把两者拼起来，就像把两个数组合并
+    fused = concatenate(x_t, h_prev)
+    # 时空投影层：线性变换+非线性激活
+    # tanh是个数学函数，把结果压缩到-1到1之间，避免数值太大
+    h_next = tanh(dot(fused, W) + b)
+    # 输出h_next是新的“记忆”，传给下一步
+    return h_next
+```
+
+以上即RNN的核心逻辑，翻译成Java思维：
+
+```java
+class RNNCell {
+    private double[] W; // 权重矩阵
+    private double[] b; // 偏置
+
+    public double[] process(double[] currentInput, double[] previousHidden) {
+        // 1. 拼接当前输入和上一次的隐藏状态
+        double[] fused = concatenate(currentInput, previousHidden);
+        // 2. 线性变换（矩阵乘法）+偏置，再用tanh激活函数处理
+        double[] nextHidden = tanh(matrixDot(fused, W).add(b));
+        return nextHidden;
+    }
+}
+```
+
+**工程案例**：在电商评论分析场景中，当处理"昨天收到包裹，包装破损严重，但客服处理非常及时"时，h(t)需要同时记忆负面信息（包装破损）和正面信息（客服及时）。 
+
+### 1.3 记忆传递的动态图示
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/3e3de45c9b3ff0894e3a5f0846173762.gif)
+
+#### ① 输入门控权重W_xh
+
+控制新信息准入强度（建议初始化为Xavier正态分布）。
+
+决定当前输入（比如“客服”）有多重要。初始化用Xavier方法（一种随机数生成方式），让模型学得更稳定。
+
+#### ② 记忆门控权重W_hh
+
+决定历史记忆保留比例（需警惕梯度爆炸）。
+
+决定之前记忆（比如“包装破损”）保留多少。太大可能导致计算失控（梯度爆炸，就像循环里数字越乘越大）。
+
+#### ③ 偏置项b_h
+
+调节神经元激活阈值（实践中常初始化为零值）。
+
+一个调整值，控制输出的基准线，通常设为0。
+
+用Java类比，这些就像类的成员变量，影响每次process方法的结果。
+
+## 2 PyTorch工程实践指南
+
+### 2.1 模型构建参数矩阵
+
+```python
+import torch.nn as nn
+
+# 工业级配置方案
+rnn_engine = nn.RNN(
+    input_size=256,    # 商品评论词向量维度，每个输入（比如一个词）的特征数
+    hidden_size=128,   # 经验值：通常取输入维度1/2到1/4，记忆容量，设小点节省计算
+    num_layers=2,      # 电商场景推荐2层堆叠，多层RNN就像多重循环，增强效果
+    nonlinearity='tanh' # 优于sigmoid的梯度传播特性，比sigmoid更适合，因为梯度（学习的信号）传得更好
+)
+```
+
+### 2.2 数据流维度规范
+
+| 张量类型 | 维度规范                         | 示例场景说明          |
+| -------- | -------------------------------- | --------------------- |
+| 输入     | (seq_len, batch, input_size)     | 20条评论，每条50个词  |
+| 隐状态   | (num_layers, batch, hidden_size) | 2层记忆，每批32条数据 |
+
+```python
+# 电商评论处理实例
+
+# 表示50个时间步（每条评论50个词），32条评论，每词256维向量
+inputs = torch.randn(50, 32, 256)  # 50个时间步，批大小32
+
+# 表示2层RNN，每批32条数据，每层128维记忆
+h0 = torch.zeros(2, 32, 128)       # 双隐层初始化
+
+output, hn = rnn_engine(inputs, h0)
+```
+
+## 3 梯度异常的诊断与防控
+
+### 3.1 梯度消失的数学本质
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/3001dd5bfdfacb7f99ae21724026ff07.gif)
+
+当处理长用户行为序列时（如30天浏览日志），梯度连乘效应导致：
+$$
+\frac{\partial L}{\partial W} ≈ \prod_{k=1}^{t} tanh'(z_k) \cdot W^{t-k}
+$$
+
+梯度是模型学习的信号，像Java里调试时的日志。RNN处理长序列（如30天数据）时，梯度会连乘很多次。因为tanh的导数（tanh')小于1，连乘后变得很小，如0.9乘30次就接近0，导致“梯度消失”，模型学不到东西。用Java类比：
+
+```java
+double gradient = 1.0;
+for (int i = 0; i < 30; i++) {
+    gradient *= 0.9; // 模拟连乘
+}
+System.out.println(gradient); // 输出很小的数
+```
+
+#### 灾难性案例
+
+某推荐系统RNN在分析用户100步行为序列时，前10步的权重更新量仅为最后一步的
+$$
+10^{-15}
+$$
+倍。100步序列后，前10步的梯度几乎为0，模型完全忘了开头的数据。就像你在Java里跑了个超长循环，前面的变量早就没影响了。
+
+### 3.2 梯度爆炸的工业级应对
+
+```python
+# 梯度裁剪防护机制
+torch.nn.utils.clip_grad_norm_(rnn.parameters(), max_norm=5)
+```
+
+梯度爆炸是另一个问题，梯度太大（比如连乘大于1的数），导致计算失控。解决办法是“剪掉”超大的梯度。
+
+Java版：
+
+```java
+double[] gradients = computeGradients(); // 假设算出的梯度
+double maxNorm = 5.0;
+double norm = vectorNorm(gradients); // 计算梯度大小
+if (norm > maxNorm) {
+    for (int i = 0; i < gradients.length; i++) {
+        gradients[i] *= maxNorm / norm; // 缩放到maxNorm
+    }
+}
+```
+
+这就像在Java里限制循环变量别超过某个上限。
+
+**防御矩阵**：
+
+| 防护策略       | 适用场景     | 参数建议       |
+| -------------- | ------------ | -------------- |
+| 梯度裁剪       | 长文本分类   | max_norm=3-5   |
+| 权重初始化优化 | 对话系统     | Xavier uniform |
+| 激活函数替换   | 金融时序预测 | ReLU+残差连接  |
+
+这些都是实战技巧：
+
+- 梯度裁剪：长文本时用，限制梯度大小
+- 权重初始化：用Xavier方法，避免一开始就失衡
+- 激活函数替换：换成ReLU（简单粗暴的函数），加残差连接（像跳跃链接），让梯度传得更好
+
+## 4 传统RNN的战场定位
+
+### 4.1 优势战场速查表
+
+| 场景类型     | 序列长度 | 效果优势      | 案例说明           |
+| ------------ | -------- | ------------- | ------------------ |
+| 实时股价预测 | 5-10步   | 响应速度＜2ms | 5分钟级波动预测    |
+| 短评情感分析 | 15-20词  | F1值达0.87    | 电商五星短评分类   |
+| 设备状态监控 | 10-15帧  | 准确率98.2%   | 工业传感器异常检测 |
+
+传统RNN在短序列任务里很强：
+
+- 股价预测：5-10个数据点，算得快
+- 短评分析：15-20个词，情感判断准
+- 设备监控：10-15帧数据，检测异常很牛
+
+就像Java里处理小数组比大数组快。
+
+### 4.2 性能衰减临界点
+
+```python
+# 不同序列长度下的表现测试
+length_performance = {
+    20: 0.89,   # 20步时准确率
+    35: 0.76,   # 35步时显著下降
+    50: 0.58    # 50步时接近随机
+}
+```
+
+RNN处理长序列时会“累”，准确率掉得厉害。20步还行，50步就跟瞎猜差不多。就像Java里递归太深会栈溢出。
+
+## 5 架构升级路线图
+
+### 5.1 LSTM/GRU进化方案
+
+```mermaid
+graph LR
+A[传统RNN] --> B[LSTM 记忆宫殿]
+A --> C[GRU 精简门控]
+B --> D[Seq2Seq 架构]
+C --> D
+```
+
+传统RNN有短板（长序列不行），对此的升级方案：
+
+- **LSTM**：加了“记忆宫殿”，能记住更久
+- **GRU**：简化版LSTM，算得快
+- **Seq2Seq**：编码+解码结构，适合翻译等任务
+
+就像Java里从简单类升级到复杂框架。
+
+### 5.2 混合架构实践
+
+```python
+class HybridRNN(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.rnn = nn.RNN(256, 128)  # 传统RNN捕获短期特征
+        self.gru = nn.GRU(128, 64)    # GRU处理中长期依赖
+        
+    def forward(self, x):
+        x, _ = self.rnn(x)
+        x, _ = self.gru(x)
+        return x
+```
+
+这是个混合模型，先用RNN抓短期的，再用GRU管长期的，就像流水线处理。
+
+## 6 工程实践指南
+
+### 序列长度动态采样
+
+根据业务数据分布自动调整截断长度。序列长短不一时，自动裁剪，像Java里动态调整数组大小。
+
+### 梯度健康度监控
+
+实时可视化梯度范数变化曲线。用日志看梯度变化，调试时很有用。
+
+### 混合精度训练
+
+使用FP16加速计算同时控制梯度幅值。用float16代替float32，算得快还不炸。
+
+### 记忆单元预热
+
+对h0进行预训练初始化提升收敛速度。给初始h0赋值，别从0开始，加速训练。
+
+## 7 总结
+
+传统RNN适合短序列任务，长序列时容易“失忆”或“爆炸”。用Java思维看，它就像一个带状态的循环类，升级版（LSTM/GRU）能解决更多问题。
\ No newline at end of file
diff --git a/docs/md/AI/ml/text-data-augmentation-back-translation-guide.md b/docs/md/AI/ml/text-data-augmentation-back-translation-guide.md
new file mode 100644
index 000000000..d54c9cd96
--- /dev/null
+++ b/docs/md/AI/ml/text-data-augmentation-back-translation-guide.md
@@ -0,0 +1,147 @@
+# 数据增强正在杀死你的模型：90%开发者不知道的回译质量陷阱
+
+## 1 回译增强的核心机理
+
+### 1.1 跨语言语义重构原理
+
+目前文本数据增强方面效果较好的增强方法。回译数据增强（Back-translation Augmentation）是基于神经机器翻译的文本再生技术，其核心运作流程包含三个关键阶段：
+
+1. **语义编码阶段**：源语言文本通过NMT模型编码为中间语义表示
+2. **跨语言迁移阶段**：语义表示解码为目标语言文本（建议选择阿尔巴尼亚语、斯瓦希里语等低资源语种）
+3. **语义重构阶段**：目标语言文本二次编码后解码回源语言
+
+如电商评论增强场景中，"物流速度太慢"经印尼语回译可能生成"送货时间超出预期"，既保留原意又实现表达多样化。操作简便，获得新语料质量高。
+
+### 1.2 技术演进路径
+
+- 传统方法：基于规则的近义词替换（易产生语义偏移）
+- 2.0阶段：单次回译（短文本重复率＞60%）
+- 3.0阶段：多语种链式回译（重复率降至15%-30%）
+
+## 2 工程实施方案
+
+### 2.1 系统架构设计
+
+```python
+from googletrans import Translator  # 建议使用官方API替代第三方库
+import random
+
+class BackTranslationEngine:
+    def __init__(self):
+        self.translator = Translator(service_urls=['translate.google.cn'])
+        self.lang_chain = [('zh-CN', 'sw'),  # 中文-斯瓦希里语
+                          ('zh-CN', 'tl'),   # 中文-菲律宾语
+                          ('zh-CN', 'hmn')]  # 中文-苗语
+
+    def enhance_text(self, text, depth=2):
+        """
+        多层级翻译增强管道
+        :param text: 原始文本
+        :param depth: 翻译链路深度（建议2-3层）
+        :return: 增强文本
+        """
+        current_text = text
+        for _ in range(depth):
+            target_lang = random.choice(self.lang_chain)
+            current_text = self.translator.translate(
+                current_text, dest=target_lang).text
+            current_text = self.translator.translate(
+                current_text, dest='zh-CN').text
+        return current_text
+```
+
+### 2.2 关键参数配置
+
+| 参数项     | 推荐值        | 作用说明              |
+| ---------- | ------------- | --------------------- |
+| 翻译深度   | 2-3层         | 平衡多样性/语义保真度 |
+| 小语种选择 | 非洲/岛屿语系 | 降低训练数据污染概率  |
+| 批处理大小 | 50-100条      | 控制API调用频率       |
+
+## 3 技术挑战与破解之道
+
+### 3.1 短文本重复率难题
+
+在客服对话场景测试中，单次回译生成的"请问有什么可以帮您？"重复率达72%，严重影响增强效果。短文本回译过程中，新语料与原语料可能存在很高的重复率，并不能有效增大样本的特征空间。
+
+#### 破局
+
+1. **多模态扰动**：插入无损空格等不可见字符（U+200B零宽空格）
+2. **动态深度调节**：根据文本长度自动调整翻译次数（短文本depth+1）
+3. **混合增强策略**：结合随机删除（Random Deletion）技术
+
+### 3.2 语义失真监控
+
+当翻译链路超过3层时，商品描述"有机棉透气面料"可能畸变为"棉质通风材料"，需建立质量检测机制：
+
+```python
+def semantic_similarity_check(orig, enhanced):
+    """
+    语义一致性守护者
+    :return: 相似度＜阈值时触发告警
+    """
+    # 使用Sentence-BERT计算余弦相似度
+    return cosine_sim > 0.75
+```
+
+## 4 场景化应用案例
+
+### 4.1 电商评论增强
+
+#### 原始数据
+
+"快递包装破损，客服处理态度差"
+
+#### 增强结果
+
+- 一级回译："物流包装损坏，客户服务响应不佳"
+- 二级回译："运送包裹有损毁，售后团队服务不专业"
+
+### 4.2 金融风控文本增强
+
+**敏感信息保护策略**：
+
+```python
+def financial_text_filter(text):
+    """
+    金融信息过滤器
+    """
+    patterns = [r'\d{16,19}', r'\d{6}']  # 屏蔽银行卡/身份证号
+    for p in patterns:
+        text = re.sub(p, '[FILTERED]', text)
+    return text
+```
+
+## 5 工程最佳实践
+
+### 流量控制
+
+采用令牌桶算法限制API调用频率（QPS≤10）
+
+### 缓存机制
+
+对高频短语建立翻译缓存库（命中率可达35%）
+
+### 质量评估
+
+构建增强数据ROI计算模型
+$$
+ROI = (准确率提升值 × 测试集规模) / (计算成本 + 人工校验成本)
+$$
+
+### 灾备方案
+
+准备本地翻译模型（如OpenNMT）应对API服务中断
+
+## 6 效果评估指标
+
+| 评估维度     | 单次回译 | 三级回译 | 混合增强 |
+| ------------ | -------- | -------- | -------- |
+| 语义保真度   | 0.92     | 0.81     | 0.88     |
+| 特征多样性   | +15%     | +42%     | +37%     |
+| 训练耗时增幅 | +8%      | +21%     | +18%     |
+| 准确率提升   | +1.2pp   | +3.5pp   | +4.1pp   |
+
+*某电商客服分类任务实测数据，基线准确率91.3%*
+
+通过构建智能化的回译增强管道，可使训练数据规模有效提升3-5倍，同时关键业务指标（如客户意图识别准确率）获得显著提升。建议在实际应用中采用A/B测试框架持续优化增强策略参数。
\ No newline at end of file
diff --git a/docs/md/AI/ml/what-is-rnn.md b/docs/md/AI/ml/what-is-rnn.md
new file mode 100644
index 000000000..c8d5a06f0
--- /dev/null
+++ b/docs/md/AI/ml/what-is-rnn.md
@@ -0,0 +1,299 @@
+# 突破序列建模瓶颈：解密RNN为何成为NLP任务的核心引擎
+
+## 1 啥是RNN模型？
+
+RNN（Recurrent Neural Network，循环神经网络），以序列数据为输入，通过网络内部的结构设计有效捕捉序列之间的关系特征，一般也以序列形式进行输出。一种专门处理“序列数据”的模型。
+
+### 什么是序列数据？
+
+想象你在Java里处理一个`List<String>`，里面存的是["What", "time", "is", "it"]，这是一个有顺序的单词列表。RNN就是为这种有前后关系的输入而设计。
+
+普通神经网络（如单层感知机）就像一个简单的方法：输入一个值，输出一个结果，无记忆。
+一般单层神经网络结构：
+
+```mermaid
+graph TB
+    I((Input)) --> H((Hidden))
+    H --> O((Output))
+    
+    I:::red
+    H:::blue
+    O:::purple
+    
+    classDef red fill:#FF0000,stroke:#333,stroke-width:2px
+    classDef blue fill:#0088FF,stroke:#333,stroke-width:2px
+    classDef purple fill:#4B0082,stroke:#333,stroke-width:2px
+```
+
+
+而RNN厉害在它内部有个“循环”，能记住之前处理过的信息，就像在方法里加了个static变量，记录上次循环的结果，影响下次计算。
+
+输出通常也是序列，如输入一句话，输出翻译后的另一句话。
+
+RNN单层网络结构：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/124f53ff4804c87b62c0d0aeea3536d3.gif)
+
+RNN和普通神经网络的区别在于，它多了“循环”。假设还是处理["What", "time", "is", "it"]，RNN会一个词一个词地读，但每次读的时候，不仅看当前词，还会参考上一次的“状态”。
+
+用Java类比：
+
+```java
+class RNN {
+    private double previousHiddenState = 0; // 上一次的隐藏状态
+    public double processWord(String word, double currentInput) {
+        double hiddenState = currentInput * weight1 + previousHiddenState * weight2 + bias;
+        previousHiddenState = hiddenState; // 更新状态
+        return hiddenState * weight3 + bias2; // 输出
+    }
+}
+```
+
+这里的previousHiddenState就是RNN的“记忆”，让它能捕捉序列的关系。
+
+------
+
+以时间步对RNN进行展开后的单层网络结构：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/70cc87e4c81e09b5638cc0f3b5618f0d.gif)
+
+“时间步展开”，就是把RNN的循环按时间顺序摊开看。假设输入是4个词，RNN会分成4个步骤：
+
+- 时间步1：处理"What"，生成隐藏状态h1
+- 时间步2：处理"time"，用h1和"time"一起算出h2
+- 时间步3：处理"is"，用h2和"is"算出h3
+- 时间步4：处理"it"，用h3和"it"算出h4。
+
+就像循环调用上面的processWord方法4次，每次都带着上一次的结果。
+
+------
+
+RNN的循环机制使模型隐层上一时间步产生的结果，能作为当下时间步输入的一部分（当下时间步的输入除了正常的输入外还包括上一步的隐层输出），对当下时间步的输出产生影响。
+
+这就是RNN的核心：它有“记忆力”。用Java思维看，每次循环时，输入不只是当前的数据（比如"time"），还有上一次的hiddenState。这就像你在写一个方法时，不仅用当前参数，还会参考一个全局变量的历史值。如：
+
+```java
+double hidden = processInput(currentWord) + processPreviousState(previousHidden);
+```
+
+这样，RNN就能理解序列的上下文，如"What time"连起来比单独的"time"更有意义。
+
+## 2 RNN模型的作用
+
+RNN结构能很好利用序列之间关系，因此针对自然界具有连续性的输入序列，如人类语言、语音等进行很好处理，广泛应用于NLP领域各项任务。因其擅长处理“连续性”数据。生活中，语言、语音、时间序列（比如股票价格）都是连续的，RNN能抓住这种前后依赖关系。编程世界，假设你写了个聊天机器人，RNN可用来：
+
+- 文本分类：判断用户输入是正面还是负面评价
+- 情感分析：分析用户是不是生气了
+- 意图识别：搞清楚用户想问时间还是天气
+- 机器翻译：把中文翻译成英文
+
+这些任务都依赖序列的顺序，RNN正好能胜任。以一个用户意图识别的例子进行简单分析：
+
+## 3 用户意图识别
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/0e23dc6be92a34fc2fd7bdc75df653f7.gif)
+
+### step1：用户输入
+
+比如用户输入了"What time is it ?"，先要对它进行基本的分词，因RNN是按序工作，每次只接收一个单词进行处理：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/a193b795d14b43c0ad4c4807f28d7204.gif)
+
+假设你在Java里收到用户输入：
+
+```java
+String input = "What time is it ?";
+String[] words = input.split(" "); // 分词成 ["What", "time", "is", "it", "?"]
+```
+
+RNN会按顺序处理每个单词，就像for循环一样：
+
+```java
+for (String word : words) {
+    rnn.processWord(word);
+}
+```
+
+### step2：先处理"What"
+
+先将单词"What"输给RNN，它将产生一个输出O1
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/16e09dbc9c67724fb76ede680df31f14.gif)
+
+### step3：再处理"time"
+
+继续将单词"time"输给RNN，但此时RNN不仅利用"time"产生输出O2，还会用来自上一层隐层输出O1作为输入信息：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/93df2c57a2c7556a022708eab178f740.gif)
+
+### step4：重复以上步骤
+
+重复直到处理完所有单词：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/d54f07f446620ea7f294953b226db702.gif)
+
+### step5 隐层输出
+
+最后，将最终的隐层输出O5进行处理来解析用户意图：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/7c62e9d3c31f4d755bc73f1849a53532.gif)
+
+用Java模拟这个过程：
+
+```java
+class IntentRNN {
+    private double previousHidden = 0;
+    public double processWord(String word) {
+        double currentInput = wordToNumber(word); // 假设把单词转成数字
+        double hidden = currentInput * 0.5 + previousHidden * 0.3; // 简化的计算
+        previousHidden = hidden;
+        return hidden * 0.7; // 输出
+    }
+    
+    public String getIntent(double finalHidden) {
+        return finalHidden > 0 ? "Asking for time" : "Unknown"; // 简化判断
+    }
+}
+
+IntentRNN rnn = new IntentRNN();
+for (String word : new String[]{"What", "time", "is", "it", "?"}) {
+    double output = rnn.processWord(word);
+}
+String intent = rnn.getIntent(rnn.previousHidden);
+```
+
+- "What"生成O1，记下隐藏状态h1
+- "time"用h1帮忙生成O2，记下h2
+- 最后处理完"?"，用最终的h5判断意图是“问时间”
+
+## 4 RNN模型分类
+
+两个角度对RNN模型分类：
+
+### 4.1 输入和输出的结构
+
+#### ① N vs N - RNN
+
+RNN最基础的结构形式，输入、输出序列等长。由于这限制，使其适用范围较小，可用于生成等长度的合辙诗句。
+
+```bash
+                y₁      y₂      		y₃      	  y₄
+                ↑       ↑       		↑       	  ↑
+                │       │       		│       		│
+┌───┴───┐ ┌───┴───┐ ┌───┴───┐ ┌───┴───┐ ┌───┴───┐
+│   h0   │→│   h₁  │→│   h₂  │→│   h₃  │→│   h₄  │
+└───┬───┘ └───┬───┘ └───┬───┘ └───┬───┘ └───┬───┘
+                ↑         ↑          ↑         ↑
+                │         │          │         │
+                x₁        x₂         x₃        x₄
+```
+
+#### ② N vs 1 - RNN
+
+- 输入是一个序列
+- 输出是一个单独的值而非序列
+
+在最后一个隐层输出h上进行线性变换即可实现。为了更好的明确结果，一般还要用sigmoid或softmax处理，常被应用在文本分类。
+$$
+Y = \text{Softmax}(Vh_4 + c)
+$$
+
+```bash
+																												 (Y)
+                                                          ^
+                                                          |
+(h0) --> [+--h1--+] --> [+--h2--+] --> [+--h3--+] --> [+--h4--+] 
+          ^               ^               ^               ^
+          |               |               |               |
+         x1              x2              x3              x4
+```
+
+输入一串，但输出一个。如输入["What", "time", "is", "it"]，输出一个意图“Asking for time”。Java里就像：
+
+```java
+List<String> input = Arrays.asList("What", "time", "is", "it");
+double finalHidden = 0;
+for (String word : input) {
+    finalHidden = rnn.processWord(word);
+}
+String result = softmax(finalHidden); // 假设用softmax判断意图
+```
+
+常见于文本分类，如判断评论是好评or差评。
+
+#### ③ 1 vs N - RNN
+
+若输入不是序列，而输出为序列。
+
+最常采用的一种方式就是使该输入作用于每次的输出之上，这种结构可用于将图片生成文字任务等。
+
+```bash
+      y1   		y2   		y3   		y4
+      ^    		^    		^    		^
+      |    		|    		|    		|
+(h0)-->[h1]-->[h2]-->[h3]-->[h4]
+       ^    	^    		^    	  ^
+       |    	|    		|    		|
+           \   		/ 	/ 	/
+           \ 	/ 		/ 	/ 
+                 X
+```
+
+“1 vs N”是输入一个东西，输出一串。如输入一张图片，输出描述文字["The", "cat", "is", "cute"]。Java里
+
+```java
+String image = "cat.jpg";
+List<String> caption = rnn.generateCaption(image);
+```
+
+每次输出一个词，但都参考同一个输入（图片）。
+
+#### ④  N vs M - RNN
+
+不限输入、输出长度，由编码器和解码器两部分组成，二者内部结构都是某类RNN，也称seq2seq架构。
+
+输入数据首先通过编码器，最终输出一个隐含变量c，之后最常用的做法是使用这个隐含变量c作用在解码器进行解码的每一步上，以保证输入信息被有效利用。
+
+```bash
+                       y1  		y2  	y3
+                        ^   	^   	^
+                        |   	|   	|
+        			 (h0')->[h1']->[h2']->[h3']
+                          ^   ^   ^
+                           \  |  /
+                            \ | /
+                              C
+                              ^
+                              |
+(h0)-->[h1]-->[h2]-->[h3]-->[h4]
+        ^   		^   		^   	^
+        |   		|   		|   	|
+        x1  		x2  		x3  	x4
+```
+
+“N vs M”是输入和输出长度可以随便变，如机器翻译：输入["What", "time"]，输出["现在", "几点", "了"]。分成两部分：
+
+- 编码器：把输入压成一个“总结”（隐变量c）。
+- 解码器：用这个总结生成输出。
+
+Java里就像：
+
+```java
+List<String> input = Arrays.asList("What", "time");
+double context = encoder.encode(input); // 编码
+List<String> output = decoder.decode(context); // 解码
+```
+
+### 4.2 “升级版”RNN
+
+解决传统RNN的一些问题（如记不住太长的序列）。
+
+- **传统RNN**：最基础的，像上面的例子。
+- **LSTM**：加了“记忆单元”，能记住更久的信息。
+- **Bi-LSTM**：双向的，能同时看前后文。
+- **GRU**：LSTM的简化版，计算更快。
+- **Bi-GRU**：双向GRU。
+
+就像Java里优化算法，从简单循环升级到用HashMap存历史数据。
+
+seq2seq架构最早被提出应用于机器翻译，因其输入输出不受限制，如今也是应用最广的RNN模型结构。
\ No newline at end of file

From 88ca6f092fa406c14aabeab8458fb9ea7fb0104b Mon Sep 17 00:00:00 2001
From: JavaEdge <sss2855845850@gmail.com>
Date: Wed, 26 Mar 2025 18:01:42 +0800
Subject: [PATCH 10/20] =?UTF-8?q?docs:=E6=9B=B4=E6=96=B0=E4=B8=93=E6=A0=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/.vuepress/config.js                      |  20 +-
 docs/md/AI/llm/llm-reasoning-limitations.md   |  82 +++++++
 .../llm/mcp-and-the-future-of-ai-tooling.md   | 122 ++++++++++
 docs/md/AI/llm/mcp-fad-or-fixture.md          |  71 ++++++
 docs/md/AI/ml/gated-recurrent-unit-model.md   |  81 +++++++
 docs/md/AI/ml/long-short-term-memory.md       | 211 ++++++++++++++++++
 docs/md/AI/ml/mask-tensor.md                  |  80 +++++++
 ...46\216\210\346\235\203\347\240\201code.md" |   2 +-
 8 files changed, 665 insertions(+), 4 deletions(-)
 create mode 100644 docs/md/AI/llm/llm-reasoning-limitations.md
 create mode 100644 docs/md/AI/llm/mcp-and-the-future-of-ai-tooling.md
 create mode 100644 docs/md/AI/llm/mcp-fad-or-fixture.md
 create mode 100644 docs/md/AI/ml/gated-recurrent-unit-model.md
 create mode 100644 docs/md/AI/ml/long-short-term-memory.md
 create mode 100644 docs/md/AI/ml/mask-tensor.md
 rename "docs/md/security/01-OAuth 2.0\345\256\236\346\210\230-\344\270\272\344\273\200\344\271\210\350\246\201\345\205\210\350\216\267\345\217\226\346\216\210\346\235\203\347\240\201code.md" => "docs/md/security/OAuth 2.0\345\256\236\346\210\230-\344\270\272\344\273\200\344\271\210\350\246\201\345\205\210\350\216\267\345\217\226\346\216\210\346\235\203\347\240\201code.md" (99%)

diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index 4ee5ba3a1..b570ef20c 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -353,7 +353,7 @@ module.exports = {
                                 text: 'OAuth2.0',
                                 items: [{
                                     text: 'OAuth2.0专栏概述',
-                                    link: '/md/security/01-OAuth 2.0实战-为什么要先获取授权码code.md'
+                                    link: '/md/security/OAuth 2.0实战-为什么要先获取授权码code.md'
                                 }, ]
                             },
 
@@ -718,7 +718,7 @@ module.exports = {
                                 text: '常见攻击手段',
                                 items: [{
                                     text: '常见攻击手段概述',
-                                    link: '/md/security/01-OAuth 2.0实战-为什么要先获取授权码code.md'
+                                    link: '/md/security/OAuth 2.0实战-为什么要先获取授权码code.md'
                                 }, ]
                             },
                         ]
@@ -2107,6 +2107,9 @@ module.exports = {
                                 "qwen-QwQ",
                                 "only-ai-flow-can-do",
                                 "chatgpt-canva",
+                                "mcp-fad-or-fixture",
+                                "mcp-and-the-future-of-ai-tooling",
+                                "llm-reasoning-limitations",
                             ]
                         },
                         {
@@ -2198,6 +2201,17 @@ module.exports = {
                         children: [
                             "what-is-rnn",
                             "neural-memory-engine-for-sequence-modeling",
+                            "long-short-term-memory",
+                            "gated-recurrent-unit-model",
+                        ]
+                    },
+                    
+                    {
+                        title: "Transformer",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "mask-tensor",
                         ]
                     },
                 
@@ -2467,7 +2481,7 @@ module.exports = {
                             collapsable: false,
                             sidebarDepth: 0,
                             children: [
-                                "01-OAuth 2.0实战-为什么要先获取授权码code.md",
+                                "OAuth 2.0实战-为什么要先获取授权码code.md",
                                 "03-OAuth2.0实战-轻松学会使用JWT，让你的OAuth2.0实现更加安全高效！",
                                 "07-你确定懂OAuth 2.0的三方软件和受保护资源服务？",
                             ]
diff --git a/docs/md/AI/llm/llm-reasoning-limitations.md b/docs/md/AI/llm/llm-reasoning-limitations.md
new file mode 100644
index 000000000..fd0d3d4ee
--- /dev/null
+++ b/docs/md/AI/llm/llm-reasoning-limitations.md
@@ -0,0 +1,82 @@
+# 大模型推理能力的局限性
+
+##  0 前言
+
+LLM凭借其生成连贯文本、翻译语言甚至进行对话的能力，彻底改变人工智能领域。然而，尽管这些模型表现出色，它们在推理和理解复杂上下文方面仍然面临重大挑战。
+
+这些模型擅长识别并模仿训练数据中的模式，但当任务需要真正的理解和[逻辑推理](https://dzone.com/articles/6-ways-how-programming-helps-to-develop-abstract-t)时，它们往往遇困。可能导致：
+
+- 长对话中的不一致
+- 难以关联分散的信息
+- 在长篇叙述中难以保持上下文一致性
+
+深入理解这些推理问题对于改进未来 LLM 的发展和应用至关重要。
+
+## 1 关键推理挑战
+
+### 1.1 缺乏真正的理解
+
+语言模型的工作原理是根据训练过程中学到的模式预测下一个关键词，而不像人类真正理解其所讨论的内容。因此，在需深层理解的复杂推理任务，LLM 表现不佳。
+
+### 1.2 上下文限制
+
+尽管现代 LLM 在短期上下文理解方面表现良好，但在长对话或大篇幅文本中保持一致性和上下文连贯性仍是挑战。当需要整合对话或文本的多个部分时，模型可能会出现推理错误。例如，在一场长时间的讨论或复杂的故事叙述中，模型可能会忘记或误解之前的信息，导致后续的矛盾或错误结论。
+
+### 1.3 无法进行规划
+
+许多推理任务涉及多步逻辑推导或需要跟踪多个事实。当前的 LLM 在需要长时间连贯性或多步逻辑推理的任务上表现较差，例如解答需要多个逻辑步骤的谜题。
+
+### 1.4 回答无解问题
+
+回答无解问题是 LLM 推理能力的一大挑战。当面对悖论、无明确答案的问题，或与已知事实相矛盾的问题时，LLM 可能难以提供有意义或连贯的回答。相较于直接承认问题无解，模型可能会基于训练数据的模式硬给出一个答案，这可能导致误导性或错误的结果。[推理能力的局限性](https://dzone.com/articles/understanding-rlaif-a-technical-overview)在这一点上尤为明显。
+
+### 1.5 状态空间计算的复杂性
+
+某些问题需要探索从初始状态到目标状态的所有可能路径。例如，在旅行规划中，涉及大量可能的选项，并且随着预算、交通方式等额外限制的增加，搜索状态空间可能会呈指数级增长。对于 LLM 来说，计算所有这些可能性并给出最佳方案是不现实的，因此它通常会依赖所学的启发式方法，给出一个可能并不正确的可行解。
+
+## 2 现实案例：错误的推理
+
+问题：
+
+```
+"一个水壶装有 8 个单位的水，还有两个容量为 5 和 5 的空水壶。"
+"目标是通过倒水，使前两个水壶各包含 4 个单位的水，而第三个水壶保持为空。"
+"每次倒水时，水只能从一个水壶倒入另一个，直到倒水的水壶空了，或者接收水的水壶装满为止。"
+```
+
+实际上，这问题无解，但目前 LLM 仍尝试给出解答，仿佛它们找到正确答案。
+
+然而，如果问题稍作修改，将两个空水壶的容量改为 5 和 4（而非 5 和 5），所有 LLM 都能够正确回答。这表明，它们可能只是记住了某些已知问题的解决方案，而不是进行真正的推理。
+
+## 3 研究人员如何改进 LLM 的推理能力？
+
+目前，研究人员正在探索多种方法来提升 LLM 的推理能力，其中包括改进数据集、引入链式思维、使用外部验证器和整合专门的求解器。
+
+### 3.1 改进数据集
+
+一些研究人员认为，提高 LLM 训练数据的质量和多样性是关键。通过更广泛、更精细的数据集训练模型，可以增强其处理复杂推理场景的能力。
+
+### 3.2 链式思维（Chain-of-Thought）
+
+[这一方法](https://dzone.com/articles/chain-of-thought-prompting-for-llms) 旨在让 LLM 按照人类的逻辑思维方式，逐步进行推理。通过显式生成中间推理步骤，模型能够更准确地完成复杂推理任务，并减少逻辑错误。
+
+### 3.3 使用外部验证器
+
+为了解决 LLM 生成错误或误导性信息的问题，一些研究人员提出整合外部验证机制。通过与可信数据源比对或使用额外算法进行验证，这些机制可以确保最终输出的信息更加准确、可靠。
+
+### 3.4 使用专门的求解器
+
+另一种方法是引入专门的求解器来处理特定类型的推理任务。例如，使用数学求解器进行计算，或使用逻辑推理工具处理复杂推理问题。这些工具可以补充 LLM 的能力，提高系统整体的准确性和可靠性。
+
+## 4 结论
+
+尽管 LLM 在文本生成和理解方面取得了令人瞩目的进展，但由于缺乏真正的理解能力、难以保持上下文一致性，以及仅依赖从海量但可能存在缺陷的数据中提取的模式，它们仍然在复杂的多层推理任务上存在明显不足。未来的 LLM 需要更先进的架构，并结合常识推理等方面的持续研究，以提升其推理能力。
+
+参考：
+
+1. [水壶倒水问题](https://en.wikipedia.org/wiki/Water_pouring_puzzle)
+2. [用 LLM 学习推理](https://openai.com/index/learning-to-reason-with-llms/)
+3. [GSM-Symbolic：LLM 在数学推理方面的局限性](https://arxiv.org/abs/2410.05229)
+4. [PlanBench：评估 LLM 规划和推理能力的基准](https://arxiv.org/abs/2206.10498)
+5. [LLM 仍然无法规划，但 LRM 可以吗？](https://arxiv.org/abs/2409.13373)
+6. [LLM 无法规划，但可以在 LLM-模块化框架中辅助规划](https://arxiv.org/abs/2402.01817)
\ No newline at end of file
diff --git a/docs/md/AI/llm/mcp-and-the-future-of-ai-tooling.md b/docs/md/AI/llm/mcp-and-the-future-of-ai-tooling.md
new file mode 100644
index 000000000..e5a99cba3
--- /dev/null
+++ b/docs/md/AI/llm/mcp-and-the-future-of-ai-tooling.md
@@ -0,0 +1,122 @@
+# MCP：AI 时代的工具接口标准？
+
+## 0 前言
+
+自从 OpenAI 在 2023 年推出函数调用（Function Calling），我一直思考，咋能真正解锁 AI Agent与工具的生态系统。随基础模型越来越智能，AI Agent与外部工具、数据和 API 的交互方式却变得越来越碎片化——开发者需**针对每一个系统单独编写业务逻辑**，让Agent能够适配不同环境。
+
+## 1 标准化
+
+显然，我们需要一个标准化的接口来执行任务、获取数据并调用工具。在互联网时代，API 让不同软件之间可以相互通信，成为了**软件的通用语言**。但对 AI 模型，目前还缺这样的标准。
+
+2024 年 11 月，**模型上下文协议（Model Context Protocol，MCP）**发布，迅速引起关注，被认为可能成为这一问题的解决方案。本文探讨：
+
+- **MCP 是什么？**
+- **它如何改变 AI 与工具的交互方式？**
+- **开发者已经用 MCP 构建了哪些应用？**
+- **MCP 仍然面临哪些挑战？**
+
+## 2 什么是 MCP
+
+MCP 是一种**开放协议**，旨在让不同系统能够为 AI 模型提供**可泛化的上下文信息**。它规定了**AI Agent如何调用外部工具、获取数据，并与服务交互**。
+
+**Resend MCP 服务器**可以同时与多个 MCP 客户端交互，使其具备邮件发送能力。MCP 灵感源于**语言服务器协议（LSP，Language Server Protocol）**。在 LSP 中，当用户在代码编辑器中输入时，客户端会向语言服务器请求自动补全建议或代码诊断。
+
+MCP进一步拓展，采用**面向 AI Agent的执行模式**：
+
+- **LSP 主要是被动的**，只会在 IDE 发请求时提供反馈
+- **MCP 则支持 AI Agent自主决策**，可以基于上下文信息选择合适的工具，并决定调用顺序，实现复杂任务的自动化
+- **MCP 还支持“人类参与（human-in-the-loop）”**，允许人在关键节点提供额外信息或批准操作
+
+## 3 MCP目前的热门应用
+
+如有够多的 MCP 服务器，用户就能将**任何 MCP 客户端变成“万能应用”**。
+
+### 3.1 Cursor
+
+作为一个代码编辑器，同时也是**高质量 MCP 客户端**。安装不同 MCP 服务器，可变身为：
+
+- **Slack 客户端**（连接 Slack MCP 服务器）
+- **邮件发送工具**（连接 Resend MCP 服务器）
+- **AI 图像生成器**（连接 Replicate MCP 服务器）
+
+更强大的，**用户可组合多个 MCP 服务器**，解锁新应用场景。如Cursor中，用户可：
+
+- 使用前端 UI 生成 MCP 服务器，自动创建网页界面
+- 让 AI Agent调用图像生成 MCP 服务器，为网页自动生成一张配图
+
+这种**跨工具协作**的能力，正是 MCP 带来突破。
+
+## 4 核心应用方向
+
+### 4.1 面向开发者的工作流优化
+
+对开发者，MCP 一大价值是**减少切换工具的时间**。
+
+#### 开发者的痛点
+
+> “我不想为做某个任务而离开 IDE。”
+
+MCP 服务器正满足需求，如：
+
+- **Postgres MCP 服务器** → 让开发者直接在 IDE 里执行 SQL 查询，而无需打开数据库管理界面
+- **Upstash MCP 服务器** → 让开发者在 IDE 里管理缓存索引
+- **Browsertools MCP 服务器** → 让代码Agent访问浏览器控制台日志，辅助调试
+
+MCP 还能帮助 AI Agent**动态获取代码相关的上下文**，如：
+
+- 爬取网页内容，为Agent提供实时信息
+
+- 通过 API 自动生成 MCP 服务器，让 AI Agent能直接访问工具，而无需手动集成
+
+即开发者可**更少写模板代码，更多专注于业务逻辑**。
+
+### 4.2 全新的 AI 交互体验
+
+尽管 MCP 目前在开发者社区最受欢迎，但它的潜力远不限于技术领域。如：
+
+- **Claude Desktop** → 让非技术用户也能轻松使用 MCP 服务器，如营销文案生成、设计、客服等任务
+- **Highlight MCP 客户端** → 允许用户通过 @ 命令调用 MCP 服务器，将生成内容直接输入到任何应用
+- **Blender MCP 服务器** → 让**不会建模的用户**，通过自然语言描述 3D 模型，AI Agent自动生成对应的图像或动画
+
+社区还正在开发**适用于 Unity 和 Unreal Engine 的 MCP 服务器**，AI 生成 3D 内容的流程正在变得越来越完善。
+
+## 5 MCP现状
+
+MCP生态仍处早期阶段，主要趋势：
+
+- **高质量的 MCP 客户端仍以开发工具为主**，但未来会有更多面向商业场景客户端
+- **大多数 MCP 服务器是本地优先（local-first）的**，未来可能会向远程 MCP 服务器扩展
+- **MCP 市场和托管解决方案正在兴起**，如 Mintlify 的 MCP 市场、Smithery 和 OpenTools，让开发者可以更容易发现和共享 MCP 服务器
+
+## 6 MCP的挑战
+
+### 6.1 托管与多租户支持
+
+目前MCP服务器主要1对1，未来需支持**多个用户同时访问**，尤其SaaS场景。
+
+### 6.2 身份验证（Authentication）
+
+MCP 目前没有标准的身份验证机制，开发者需要自己实现 OAuth 或 API 令牌管理
+
+### 6.3 权限管理（Authorization）
+
+MCP 目前的权限是基于会话的，未来需要更细粒度的访问控制。
+
+### 6.4 网关（Gateway）
+
+未来 MCP 可能需要一个**集中式网关**，类似 API 网关，管理身份验证、授权、流量控制等功能
+
+### 6.5 MCP 服务器发现与注册机制
+
+MCP 服务器目前需要手动配置，未来可能会有一个类似 npm 或 RapidAPI 的 MCP 服务器注册中心，让 AI Agent**自动发现并集成工具**。
+
+## 7 MCP未来：AI Agent的 API 标准？
+
+MCP目前像**2010时的 API 生态**——新颖但仍处早期阶段。若MCP 成为 AI Agent的标准接口，会咋样？
+
+- **工具竞争力将取决于 AI Agent能否发现并调用它**，而不仅是 API 设计是否优秀。
+- **定价模式可能改变**，AI Agent可能会**动态选择最便宜、最快、最相关的工具**，而不是仅仅依赖市场占有率。
+- **文档将变得至关重要**，因为 AI Agent需要**机器可读的格式**来理解 MCP 服务器的功能。
+- **API 将不再是终点**，开发者需要围绕具体场景构建 MCP 服务器，而不是简单地开放 API 端点。
+
+MCP **正在重塑 AI Agent生态**，但它的未来取决于开发者如何解决当前的基础问题。如果一切顺利，MCP 可能会成为**AI Agent调用工具的默认接口**，解锁全新的自主、多模态、深度集成的 AI 体验。
\ No newline at end of file
diff --git a/docs/md/AI/llm/mcp-fad-or-fixture.md b/docs/md/AI/llm/mcp-fad-or-fixture.md
new file mode 100644
index 000000000..1188da44d
--- /dev/null
+++ b/docs/md/AI/llm/mcp-fad-or-fixture.md
@@ -0,0 +1,71 @@
+# MCP：炒作还是AI新行标？
+
+## 0 前言
+
+Model Context Protocol（MCP）最近在全网引发热议——它真有实际价值，还是只是营销号的氛围感？LangChain 的 CEO Harrison Chase 和 LangGraph 负责人 Nuno Campos 针锋相对，探讨 MCP 是否真的值得关注。
+
+**Harrison**：MCP 在你想要为一个**你无法控制**的智能体提供工具时就会变得有用。
+
+如对Claude Desktop、Cursor 和 Windsurf 这些应用，用户无法控制底层的智能体，而智能体本身只具备一些内置工具。
+
+但若我想让它使用一个默认没有的工具呢？就需要某种协议，否则智能体根本不知咋调用这工具。
+
+此外，我认为 MCP 对非开发者创建智能体也会很有帮助。目前趋势，让**领域专家**能够构建智能体，而无需技术背景。这些用户可能不会（或不愿）直接修改智能体的逻辑，但他们肯定希望给智能体添加一些工具。MCP此时就很有价值。
+
+**Nuno**：我觉得你低估智能体与工具的适配度。确实，如果 Windsurf（假设它自带的网页搜索工具很差）支持用户替换成一个更好的，那可行。但这不算真正的使用场景。
+
+更吸引人的场景：用户能仅靠一个神奇工具，就让 Cursor 获得连其开发者都没想象过的新能力。但现实**大多行不通**。我见过的生产环境下，智能体的系统消息、架构甚至其他部分都必须根据所使用的工具进行调整。
+
+**Harrison**：好吧，这些智能体的准确率可能达不到 99%……但即使不完美，它们仍可足够实用，不是吗？工具的描述和指令确实很重要，但我们也知道：
+
+- MCP 提供了工具定义——而好的 MCP 服务器可能比用户自己随便写的描述更详细
+- MCP 允许提供提示词（prompts）——用户可在这里加入额外的使用说明
+- 随底层模型进步，智能体调用工具的能力会越来越强
+
+我不认为 MCP 及其工具调用能力能直接催生出下一个 Cursor，但它仍有一定价值，尤其在内部或个人智能体场景。
+
+**Nuno**：但我们的工具调用测试表明，即便在专门为某些工具优化的智能体，当前模型的调用正确率**只有 50%**。如换成 MCP 这种通用协议，成功率恐怕更低。而即使个人智能体，**一半的调用都失败**，这也没啥用吧？
+
+而且的确，模型会变更强，但用户**期望值也提高**。贝索斯说：“客户的期望永远不会静止不变——它们只会不断上升。这是人性。”
+
+如果你能掌控整个产品——UI、提示词、架构、工具——你就能满足这些期望。否则，Good luck！
+
+**Harrison**：模型能力会持续进步，我愿意赌这点。所以无论当前智能体的成功率多少，未来**只会更高**。
+
+我觉得正确比较方式不是拿 MCP 智能体 V.S 高度定制化智能体，而是看 MCP 能否提供**灵活的集成能力**。
+
+就像 Zapier 让你能将邮件连接到 Google Sheets、Slack 等。现实中有**无数**可能工作流，而 MCP 可让用户自己去创建它们，而不必等一个专门智能体来适配每种需求。
+
+你觉得这个 Zapier 的类比如何？
+
+**Nuno**：LangChain两年前就已提供包含 500 个工具的库，但我很少看到它们被真正用于生产环境。这些工具都遵循同样的“协议”，可兼容任何模型，也可随意替换。那 MCP 又有啥不同？是因为 MCP 的“优秀形态”要求用户在本地终端里跑无数个服务器，还只能兼容桌面应用？这可不算优势……
+
+老实说，我觉得 **Zapier 已经是 MCP 的上限** 。
+
+**Harrison**：MCP 工具和 LangChain 工具最大区别在：**MCP 不是为智能体开发者设计**。其最大价值在于让**用户**能为一个**自己无法开发**的智能体添加工具。
+
+若我是一个开发，要从头构建一个智能体，我不会用 MCP。但 MCP 目标用户不是开发者，而是**希望拓展现有智能体能力的普通用户**。MCP 让非开发者也能给智能体添加工具，而 LangChain 工具更适合开发者使用。市场规模，非开发者数量**远大于**开发者。
+
+至于 MCP 目前形态，确实糟糕。但它未来会改进，设想的 MCP 未来形态：**用户可一键安装 MCP 应用（无需再在本地终端跑服务器），而且能在 Web 端使用**。我相信 MCP 正朝这方向发展。
+
+你觉得 MCP 需要哪些改进？如果改进到位，你会认为它有价值吗？
+
+**Nuno**：好吧，听起来 MCP 需要变成 OpenAI 的 **Custom GPT**，那它现在的热度才合理。但**Custom GPT 本身也没那么火**。MCP 又有啥独特？
+
+**Harrison**：其实，MCP 更像 OpenAI 的 **插件（Plugins）**，但它们也没成功 🙂 说实话，我几乎没用过插件，所以可能对它们的情况了解不深。但我认为：
+
+- MCP 的**生态系统**已经远超当年的插件生态
+- 现在的模型比当时的插件时代更强，能更好利用这些工具
+
+**Nuno**：嗯，我不太确定 MCP 生态真的比插件更大。我随便搜了一下，就找到一个 MCP 服务器目录，目前上面列出 893 个服务器。而你可能只是看到 Twitter 上 MCP 相关的讨论比较多 🙂。
+
+回到你的问题，如果 MCP 想要成为 AI 发展史上的一个重要章节，而不仅仅是个小插曲，它需要：
+
+1. **降低复杂度**——为啥一个工具协议还要负责处理提示词和 LLM 生成？
+2. **简化实现**——为啥一个工具协议需要双向通信？我看过官方解释，但光是为能接收服务器日志就这么做？不合理。
+3. **支持服务器端部署**——一个**无状态协议**才是关键，LLM 时代也不能忽视已有的在线扩展经验。而一旦能用于服务器，还涉及**身份认证（auth）**，分布式环境下不易解决。
+4. **弥补质量损失**——智能体随意调用陌生工具，往往会导致体验下降，如何弥补？
+
+**Harrison**：你说的对，我可能确实受到 Twitter 上最近 MCP 讨论的影响。但同时，Twitter 上也有很多怀疑的声音！
+
+所以，你认为 MCP 是昙花一现，还是未来标准？
\ No newline at end of file
diff --git a/docs/md/AI/ml/gated-recurrent-unit-model.md b/docs/md/AI/ml/gated-recurrent-unit-model.md
new file mode 100644
index 000000000..f077f86a3
--- /dev/null
+++ b/docs/md/AI/ml/gated-recurrent-unit-model.md
@@ -0,0 +1,81 @@
+# GRU模型
+
+## 1 简介
+
+GRU（Gated Recurrent Unit）也称门控循环单元结构, 它也是传统RNN的变体, 同LSTM一样能够有效捕捉长序列之间的语义关联, 缓解梯度消失或爆炸现象. 同时它的结构和计算要比LSTM更简单, 它的核心结构可以分为两个部分去解析：
+
+- 更新门
+- 重置门
+
+## 2 GRU的内部结构图和计算公式
+
+
+
+![](/Users/javaedge/Downloads/IDEAProjects/java-edge-master/assets/gru.png)
+
+结构解释图：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/5be2d65503828fd55b4f619b26fccfe3.png)
+
+### GRU的更新门和重置门结构图
+
+![](/Users/javaedge/Downloads/IDEAProjects/java-edge-master/assets/gru2.png)
+
+### 内部结构分析
+
+和之前分析过的LSTM中的门控一样, 首先计算更新门和重置门的门值, 分别是z(t)和r(t), 计算方法就是使用X(t)与h(t-1)拼接进行线性变换, 再经过sigmoid激活. 之后重置门门值作用在了h(t-1)上, 代表控制上一时间步传来的信息有多少可以被利用. 接着就是使用这个重置后的h(t-1)进行基本的RNN计算, 即与x(t)拼接进行线性变化, 经过tanh激活, 得到新的h(t). 最后更新门的门值会作用在新的h(t)，而1-门值会作用在h(t-1)上, 随后将两者的结果相加, 得到最终的隐含状态输出h(t), 这个过程意味着更新门有能力保留之前的结果, 当门值趋于1时, 输出就是新的h(t), 而当门值趋于0时, 输出就是上一时间步的h(t-1).
+
+------
+
+- Bi-GRU与Bi-LSTM的逻辑相同, 都是不改变其内部结构, 而是将模型应用两次且方向不同, 再将两次得到的LSTM结果进行拼接作为最终输出. 具体参见上小节中的Bi-LSTM.
+
+## Pytorch中GRU工具的使用
+
+torch.nn工具包之中, 通过torch.nn.GRU可调用。
+
+- nn.GRU类初始化主要参数解释:
+  - input_size: 输入张量x中特征维度的大小.
+  - hidden_size: 隐层张量h中特征维度的大小.
+  - num_layers: 隐含层的数量.
+  - bidirectional: 是否选择使用双向LSTM, 如果为True, 则使用; 默认不使用.
+
+------
+
+- nn.GRU类实例化对象主要参数解释:
+  - input: 输入张量x.
+  - h0: 初始化的隐层张量h.
+
+------
+
+- nn.GRU使用示例:
+
+```python
+>>> import torch
+>>> import torch.nn as nn
+>>> rnn = nn.GRU(5, 6, 2)
+>>> input = torch.randn(1, 3, 5)
+>>> h0 = torch.randn(2, 3, 6)
+>>> output, hn = rnn(input, h0)
+>>> output
+tensor([[[-0.2097, -2.2225,  0.6204, -0.1745, -0.1749, -0.0460],
+         [-0.3820,  0.0465, -0.4798,  0.6837, -0.7894,  0.5173],
+         [-0.0184, -0.2758,  1.2482,  0.5514, -0.9165, -0.6667]]],
+       grad_fn=<StackBackward>)
+>>> hn
+tensor([[[ 0.6578, -0.4226, -0.2129, -0.3785,  0.5070,  0.4338],
+         [-0.5072,  0.5948,  0.8083,  0.4618,  0.1629, -0.1591],
+         [ 0.2430, -0.4981,  0.3846, -0.4252,  0.7191,  0.5420]],
+
+        [[-0.2097, -2.2225,  0.6204, -0.1745, -0.1749, -0.0460],
+         [-0.3820,  0.0465, -0.4798,  0.6837, -0.7894,  0.5173],
+         [-0.0184, -0.2758,  1.2482,  0.5514, -0.9165, -0.6667]]],
+       grad_fn=<StackBackward>)
+```
+
+## GRU优势
+
+GRU和LSTM作用相同, 在捕捉长序列语义关联时, 能有效抑制梯度消失或爆炸, 效果都优于传统RNN且计算复杂度相比LSTM要小.
+
+## GRU缺点
+
+GRU仍然不能完全解决梯度消失问题, 同时其作用RNN的变体, 有着RNN结构本身的一大弊端, 即不可并行计算, 这在数据量和模型体量逐步增大的未来, 是RNN发展的关键瓶颈.
\ No newline at end of file
diff --git a/docs/md/AI/ml/long-short-term-memory.md b/docs/md/AI/ml/long-short-term-memory.md
new file mode 100644
index 000000000..f57e81bec
--- /dev/null
+++ b/docs/md/AI/ml/long-short-term-memory.md
@@ -0,0 +1,211 @@
+# LSTM：克服长期依赖难题的循环神经网络升级方案
+
+## 1 简介
+
+长短期记忆网络（Long Short-Term Memory）作为RNN的进阶架构，在序列建模领域具有里程碑意义。其核心突破在于通过智能门控系统，有效捕获跨越数百个时间步的语义关联，成功缓解了传统RNN存在的梯度消失/爆炸难题，在语音识别、金融预测等需要长程记忆的场景中表现卓越。
+
+结构更复杂，核心结构可分四部分：
+
+## 2 LSTM内部结构图
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/09ede73f19a72bacafa3907772000f6c.png)
+
+结构解释图：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/5be2d65503828fd55b4f619b26fccfe3.png)
+
+### 2.1 遗忘门：智能记忆过滤器
+
+#### 结构图和计算公式
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/caea8dd6ac7200e31d08f216b38e79e0.png)
+
+#### 结构分析
+
+类似传统RNN内部结构计算：
+
+- 先将当前时间步输入x(t)与上一个时间步隐含状态h(t-1)拼接，得到[x(t), h(t-1)]
+- 再通过一个全连接层做变换，最后通过sigmoid函数进行激活得到f(t)，可将f(t)看作门值，好比一扇门开合的大小程度，门值都将作用在通过该扇门的张量。遗忘门门值将作用的上一层的细胞状态上，代表遗忘过去的多少信息，又因为遗忘门门值是由x(t), h(t-1)计算得来，因此整个公式意味着根据当前时间步输入和上一个时间步隐含状态h(t-1)来决定遗忘多少上一层的细胞状态所携带的过往信息
+
+动态决定历史信息的保留比例，通过sigmoid函数输出0-1之间的遗忘系数。实际应用场景如在语言模型中自动遗忘不相关的主语信息。
+
+#### 过程演示
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/9f9cc99fecaa6eb45bedb054ac0f8978.gif)
+
+#### 激活函数sigmiod
+
+帮助调节流经网络的值，sigmoid函数将值压缩在0和1之间。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/89fea335d5805b79bd832eb441d09d72.gif)
+
+### 2.2 输入门：新知融合系统
+
+#### 结构图与计算公式
+
+
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/83cf1b0db503df8e7b2e6019c91bbd79.png)
+
+#### 结构分析
+
+输入门的计算公式有两个：
+
+- 产生输入门门值的公式, 它和遗忘门公式几乎相同, 区别只是在于它们之后要作用的目标上. 这个公式意味着输入信息有多少需要进行过滤
+- 与传统RNN的内部结构计算相同. 对于LSTM来讲, 它得到的是当前的细胞状态, 而不是像经典RNN一样得到的是隐含状态
+
+可实现新信息的选择性记忆，如在股票预测中精准捕捉突发市场信号。
+
+#### 过程演示
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/c498fd9fc886c50b6f9ee7e67fcb8276.gif)
+
+### 2.3 细胞状态更新
+
+#### 结构图和计算公式
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/ca2cbf27bd7ba88a33b0170cc28a5203.png)
+
+#### 结构分析
+
+没有全连接层，只是将刚得的遗忘门门值与上一个时间步得到的C(t-1)相乘，再加上输入门门值与当前时间步得到的未更新C(t)相乘。最终得到更新后的C(t)作为下一个时间步输入的一部分。
+
+整个细胞状态更新过程就是对遗忘门和输入门的应用。可构建动态记忆高速公路，如医疗诊断场景中持续更新患者病史特征。
+
+#### 过程演示
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/bf3a0eec03d9d18b973a99796bc55e27.gif)
+
+### 2.4 输出门：信息蒸馏器
+
+#### 结构图和计算公式
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/5244c0d6b8da9c680bbbb62a47d38c0f.png)
+
+#### 结构分析
+
+公式也两个，双阶段处理：
+
+- 计算输出门的门值，同遗忘门、输入门计算方式
+- 用这个门值产生隐含状态h(t)，作用在更新后的细胞状态C(t)上，并做tanh激活，最终得到h(t)作为下一时间步输入的一部分。整个输出门的过程，就是为产生隐含状态h(t)
+
+可智能生成当前时刻的特征表达，如在机器翻译中精准输出目标语言词汇。
+
+#### 过程演示
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/15debb9b618e961a9ea6b431dcd288d5.gif)
+
+## 3 Bi-LSTM
+
+双向LSTM，未改变LSTM本身任何的内部结构，只是将LSTM应用两次且方向不同，再将两次得到的LSTM结果进行拼接作为最终输出。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/7dbafdba9ea317c312a61288edea2f33.png)
+
+### 3.1 结构分析
+
+图中对"我爱中国"这句话或叫这个输入序列，进行从左到右、从右到左两次LSTM处理，将得到的结果张量拼接作为最终输出。
+
+这种结构能捕捉语言语法中一些特定的前置或后置特征，增强语义关联，但模型参数和计算复杂度也随之增加一倍，一般需对语料和计算资源进行评估后，决定是否使用该结构。
+
+可使用于：
+
+- 正向LSTM捕捉历史依赖
+- 反向LSTM捕获未来特征
+
+如医疗文本分析中同时考虑症状描述和诊断结果。
+
+### 3.2 单向LSTM V.S 双向LSTM
+
+
+| 特性       | 单向LSTM | 双向LSTM |
+| :--------- | :------- | :------- |
+| 参数数量   | 1x       | 2x       |
+| 上下文感知 | 前向     | 全向     |
+| 计算效率   | 高       | 中等     |
+
+## 4 工程实践
+
+Pytorch中LSTM工具在torch.nn包，通过torch.nn.LSTM可调用。
+
+### 4.1 nn.LSTM类初始化参数
+
+- input_size: 输入张量x中特征维度的大小
+- hidden_size: 隐层张量h中特征维度的大小
+- num_layers: 隐含层的数量
+- bidirectional: 是否选择使用双向LSTM, 如果为True, 则使用; 默认不使用
+
+### 4.2 nn.LSTM类实例化对象参数
+
+- input: 输入张量x
+- h0: 初始化的隐层张量h
+- c0: 初始化的细胞状态张量c
+
+### 4.3 nn.LSTM使用示例
+
+```python
+# 定义LSTM的参数含义: 
+# (input_size,
+# 	hidden_size,隐层维度
+# 		num_layers) 堆叠3个LSTM层
+
+# 定义输入张量的参数含义: (sequence_length, batch_size, input_size)
+# 定义隐藏层初始张量和细胞初始状态张量的参数含义:
+# (num_layers * num_directions, batch_size, hidden_size)
+
+>>> import torch.nn as nn
+>>> import torch
+# 构建深度双向LSTM
+>>> rnn = nn.LSTM(5, 6, 2)
+# 三维输入：(序列长度,批大小,特征维度)
+>>> input = torch.randn(1, 3, 5)
+
+# 初始化记忆系统
+>>> h0 = torch.randn(2, 3, 6) # (层数*方向数,批大小,隐层维度)
+>>> c0 = torch.randn(2, 3, 6)
+
+# 前向计算
+>>> output, (hn, cn) = rnn(input, (h0, c0))
+>>> output
+tensor([[[ 0.0447, -0.0335,  0.1454,  0.0438,  0.0865,  0.0416],
+         [ 0.0105,  0.1923,  0.5507, -0.1742,  0.1569, -0.0548],
+         [-0.1186,  0.1835, -0.0022, -0.1388, -0.0877, -0.4007]]],
+       grad_fn=<StackBackward>)
+>>> hn
+tensor([[[ 0.4647, -0.2364,  0.0645, -0.3996, -0.0500, -0.0152],
+         [ 0.3852,  0.0704,  0.2103, -0.2524,  0.0243,  0.0477],
+         [ 0.2571,  0.0608,  0.2322,  0.1815, -0.0513, -0.0291]],
+
+        [[ 0.0447, -0.0335,  0.1454,  0.0438,  0.0865,  0.0416],
+         [ 0.0105,  0.1923,  0.5507, -0.1742,  0.1569, -0.0548],
+         [-0.1186,  0.1835, -0.0022, -0.1388, -0.0877, -0.4007]]],
+       grad_fn=<StackBackward>)
+>>> cn
+tensor([[[ 0.8083, -0.5500,  0.1009, -0.5806, -0.0668, -0.1161],
+         [ 0.7438,  0.0957,  0.5509, -0.7725,  0.0824,  0.0626],
+         [ 0.3131,  0.0920,  0.8359,  0.9187, -0.4826, -0.0717]],
+
+        [[ 0.1240, -0.0526,  0.3035,  0.1099,  0.5915,  0.0828],
+         [ 0.0203,  0.8367,  0.9832, -0.4454,  0.3917, -0.1983],
+         [-0.2976,  0.7764, -0.0074, -0.1965, -0.1343, -0.6683]]],
+       grad_fn=<StackBackward>)
+```
+
+### 4.4 参数调优要点
+
+- 隐层维度：一般设置为输入维度2-4倍
+- 深度堆叠：3-5层可获得较好收益
+- 双向选择：根据任务上下文需求决定
+
+## 5 LSTM评价
+
+### 5.1 优势
+
+门结构有效减缓长序列问题的梯度消失或爆炸，虽不能杜绝，但在更长的序列问题上表现优于传统RNN。
+
+### 5.2 缺点
+
+内部结构复杂，训练效率在同等算力下比传统RNN低很多。
+
+## 6 新趋势展望
+
+通过深入理解LSTM的门控哲学，可构建更智能的时序模型，抢占AI应用先机。
\ No newline at end of file
diff --git a/docs/md/AI/ml/mask-tensor.md b/docs/md/AI/ml/mask-tensor.md
new file mode 100644
index 000000000..5b820daf3
--- /dev/null
+++ b/docs/md/AI/ml/mask-tensor.md
@@ -0,0 +1,80 @@
+# 编码器-掩码张量实现
+
+## 0 目标
+
+- 什么是掩码张量及其作用
+- 生成掩码张量的实现过程
+
+## 1 啥是掩码张量
+
+- 掩代表遮掩
+- 码就是张量中的数值
+
+尺寸不定，里面一般只有1和0的元素，代表位置被遮掩或不被遮掩，至于是0 or 1位置被遮掩可自定义，因此它的作用就是让另外一个张量中的一些数值被遮掩，也可以说被替换，其表现形式是一个张量。
+
+## 2 掩码张量的作用
+
+transformer中，掩码张量的主要作用在应用attention时，有些生成的attention张量中的值计算有可能已知了未来信息而得，未来信息被看到是因为训练时会把整个输出结果都一次性Embedding，但理论上解码器的输出却非一次就能产生最终结果，而是一次次通过上一次结果综合得出。因此，未来的信息可能被提前利用， 所以要遮掩。
+
+## 3 生成掩码张量
+
+```python
+# 生成一个用于遮掩后续位置的掩码张量
+def subsequent_mask(size):
+    """生成向后遮掩的掩码张量, 参数size是掩码张量最后两个维度的大小, 它的最后两维形成一个方阵"""
+    # 初始化掩码张量的形状
+    attn_shape = (1, size, size)
+    # 上三角矩阵
+    print('====', np.triu(np.ones(attn_shape), k=1))
+    # 再用np.ones向这形状中添加1元素,形成上三角阵
+    subsequent_mask = (np.triu(np.ones(attn_shape), k=1)
+                       # 最后为节约空间，再使其中的数据类型转变
+                       .astype('uint8'))
+    # 最后将numpy类型转化为torch中的tensor, 内部做一个1 - 操作,
+    # 就是做一个三角阵的反转, 上三角变下三角，即subsequent_mask中的每个元素都被1减，如：
+    # 原是0, subsequent_mask中的该位置由0变成1
+    # 原是1, subsequent_mask中的该位置由1变成0
+    return torch.from_numpy(1 - subsequent_mask)
+```
+
+输入：
+
+```python
+size = 5
+```
+
+调用：
+
+```python
+sm = subsequent_mask(size)
+print("sm:", sm)
+```
+
+输出：
+
+```python
+# 最后两维形成一个下三角阵
+sm: (0 ,.,.) = 
+  1  0  0  0  0
+  1  1  0  0  0
+  1  1  1  0  0
+  1  1  1  1  0
+  1  1  1  1  1
+[torch.ByteTensor of size 1x5x5]
+```
+
+### 掩码张量的可视化
+
+```python
+plt.figure(figsize=(5,5))
+plt.imshow(subsequent_mask(20)[0])
+```
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/0cd4959426b068d06f3ab5e403a3798b.png)
+
+观察可视化方阵：
+
+- 黄色是1的部分，代表被遮掩
+- 紫色代表未被遮掩的信息
+- 横坐标代表目标词汇的位置，0的位置一眼望去都是黄色，都被遮住，1的位置一眼望去还是黄色，说明第一次词还没产生，从第二个位置看过去，就能看到位置1的词，其他位置看不到，以此类推
+- 纵坐标代表可查看的位置
\ No newline at end of file
diff --git "a/docs/md/security/01-OAuth 2.0\345\256\236\346\210\230-\344\270\272\344\273\200\344\271\210\350\246\201\345\205\210\350\216\267\345\217\226\346\216\210\346\235\203\347\240\201code.md" "b/docs/md/security/OAuth 2.0\345\256\236\346\210\230-\344\270\272\344\273\200\344\271\210\350\246\201\345\205\210\350\216\267\345\217\226\346\216\210\346\235\203\347\240\201code.md"
similarity index 99%
rename from "docs/md/security/01-OAuth 2.0\345\256\236\346\210\230-\344\270\272\344\273\200\344\271\210\350\246\201\345\205\210\350\216\267\345\217\226\346\216\210\346\235\203\347\240\201code.md"
rename to "docs/md/security/OAuth 2.0\345\256\236\346\210\230-\344\270\272\344\273\200\344\271\210\350\246\201\345\205\210\350\216\267\345\217\226\346\216\210\346\235\203\347\240\201code.md"
index 22209b15e..031848638 100644
--- "a/docs/md/security/01-OAuth 2.0\345\256\236\346\210\230-\344\270\272\344\273\200\344\271\210\350\246\201\345\205\210\350\216\267\345\217\226\346\216\210\346\235\203\347\240\201code.md"	
+++ "b/docs/md/security/OAuth 2.0\345\256\236\346\210\230-\344\270\272\344\273\200\344\271\210\350\246\201\345\205\210\350\216\267\345\217\226\346\216\210\346\235\203\347\240\201code.md"	
@@ -1,4 +1,4 @@
-# 01-OAuth 2.0实战-为什么要先获取授权码code
+# OAuth 2.0实战-为什么要先获取授权码code
 
 xx软件最终是通过访问令牌请求到我的公众号里的文章。访问令牌是通过授权码换来的。
 

From 8d2131a428325a0ba1a551748fdd5a016455cdc5 Mon Sep 17 00:00:00 2001
From: JavaEdge <sss2855845850@gmail.com>
Date: Sun, 30 Mar 2025 23:24:01 +0800
Subject: [PATCH 11/20] =?UTF-8?q?docs:=E6=9B=B4=E6=96=B0AI=E8=90=BD?=
 =?UTF-8?q?=E5=9C=B0=E4=B8=93=E6=A0=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/.vuepress/config.js                      |   9 +-
 docs/md/AI/aigc-app-in-e-commerce-review.md   | 157 ++++++++++++++++
 .../md/AI/llm/GPTs.md                         |   0
 .../making-an-llm-that-sees-and-reasons.md    | 133 ++++++++++++++
 docs/md/rpc/rpc-retry-mechanism.md            | 173 ++++++++++++++++++
 5 files changed, 469 insertions(+), 3 deletions(-)
 create mode 100644 docs/md/AI/aigc-app-in-e-commerce-review.md
 rename "docs/md/AI/llm/GPTs\346\216\250\350\215\220.md" => docs/md/AI/llm/GPTs.md (100%)
 create mode 100644 docs/md/AI/llm/making-an-llm-that-sees-and-reasons.md
 create mode 100644 docs/md/rpc/rpc-retry-mechanism.md

diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index b570ef20c..844cc67ba 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -744,7 +744,7 @@ module.exports = {
                             },
                             {
                                 text: '大模型平台',
-                                link: '/md/AI/llm/GPTs推荐'
+                                link: '/md/AI/llm/GPTs'
                             },
                             {
                                 text: 'Prompt工程',
@@ -1113,6 +1113,7 @@ module.exports = {
                             "04-RPC框架在网络通信的网络IO模型选型",
                             "熔断限流",
                             "11-RPC的负载均衡",
+                            "rpc-retry-mechanism",
                             "RPC-Traffic-Replay",
                         ]
                     }],
@@ -2096,7 +2097,7 @@ module.exports = {
                             sidebarDepth: 0,
                             children: [
                                 "llm-api-platform",
-                                "GPTs推荐",
+                                "GPTs",
                                 "ChatGPT为啥不用Websocket而是EventSource",
                                 "携手阿里云：JetBrains AI Assistant 正式发布！",
                                 "中国大陆用户如何使用Jetbrains内置的AI插件AI Assistant",
@@ -2110,6 +2111,7 @@ module.exports = {
                                 "mcp-fad-or-fixture",
                                 "mcp-and-the-future-of-ai-tooling",
                                 "llm-reasoning-limitations",
+                                "making-an-llm-that-sees-and-reasons",
                             ]
                         },
                         {
@@ -2321,7 +2323,7 @@ module.exports = {
                         },
 
                         {
-                            title: "Agent应用开发",
+                            title: "Agent应用",
                             collapsable: false,
                             sidebarDepth: 0,
                             children: [
@@ -2336,6 +2338,7 @@ module.exports = {
                                 "ai-agent-is-coming",
                                 "software-development-in-AI2",
                                 "overcoming-fear-uncertainty-and-doubt-in-the-era-of-ai-transformation",
+                                "aigc-app-in-e-commerce-review",
                             ]
                         },
 
diff --git a/docs/md/AI/aigc-app-in-e-commerce-review.md b/docs/md/AI/aigc-app-in-e-commerce-review.md
new file mode 100644
index 000000000..6a1a5951e
--- /dev/null
+++ b/docs/md/AI/aigc-app-in-e-commerce-review.md
@@ -0,0 +1,157 @@
+# 电商评论升级：AI如何赋能场景应用与技术选择？
+
+## 0 前言
+
+诚信难的当下，商品评论已成连接买家卖家的重要桥梁。2022年全球主要电商平台平均每件商品收到约50条评论，热门商品评论数更轻松突破千条。充分体现商品评论在电商体系地位。
+
+## 1 商品评论的意义
+
+Infographic: How consumers read and write local business reviews：
+
+![](https://www.brightlocal.com/wp-content/uploads/2023/02/Infographic-1-1-860x682.png)
+
+### 1.1 对买家
+
+其他消费者的真实体验和反馈往往是做出购买决策的关键因素。研究显示，**超过** **95%**的在线用户会在做出购买决定前阅读商品评论。平均每次购物之间会查看至少 10 行评论信息。详实、客观的评论：
+
+- 帮助潜在客户了解商品优缺
+- 提供实际使用体验
+- 降低购买风险
+- 提高购物满意度
+
+你也就能理解为啥那么多带货的评测短视频了。
+
+### 1.2 对卖家
+
+商品评论是面照妖镜，直接反映产品质量、服务水平及客户满意度。所以你也能理解，很多 B 端产品，产商就自主隐藏差评，只留下好评忽悠新的客户。因此，结合线下使用体验才能更全面。
+
+**商品评分每提高一星，销量平均可提升** **5-9%**。分析评论，卖家可及时发现并解决产品或服务中存在的问题，不断改进优化，提升品牌形象和客户忠诚度。积极评论还能吸引新客户，带来更多曝光销量。
+
+## 2 传统商品评论的挑战
+
+传统评论处理无法充分发挥评论的价值。当前商品评论系统痛点：
+
+### 2.1 C 端用户体验不佳
+
+之前商品介绍信息主要通过传统的列表、标签等呈现，难快速传达核心信息。C 端通常需手动点击和刷新评论列表，自行总结最近多数用户的评论或者产品的关键信息。耗时耗力，且：
+
+- 信息过载：面对海量评论图文，用户难提取关键信息
+- 偏见风险：用户可能过度关注极端评论，忽视了更具代表性的中立意见
+- 时间成本高：需要花费大量时间阅读和筛选评论，影响购物效率
+- 难以全面把握：用户可能错过重要信息，无法全面了解产品的优缺点
+
+### 2.2 对 B 端商家影响
+
+#### 2.2.1 用户评论处理效率低下
+
+- 人工成本高：通常需售后专人阅读大量评论信息，费人力
+- 处理速度慢：人工处理评论速度<<评论产生速度，信息滞后
+- 主观性强：不同人对评论理解和总结有异，影响决策准确性
+- 难量化：传统方法难量化分析评论，不利数据驱动决策
+
+#### 2.2.2 产品迭代周期长
+
+- 产品迭代需40天以上：从评论总结有效的产品和服务改进方案，到实际执行和见效，整个过程耗时过长
+- 市场反应迟缓：无法及时响应用户需求和市场变化，可能导致竞争力下降
+- 问题积累：长周期导致问题不断累积，可能造成更严重负面影响
+
+#### 2.2.3 数据价值未被充分挖掘
+
+- 趋势预测困难：难从评论中及时发现新兴趋势和潜在机会。
+- 竞品分析不足：缺乏有效工具对比分析竞品评论，难以精准把握市场定位。
+- 用户洞察有限：难深入分析用户需求和行为模式，影响产品开发和营销策略。
+
+## 3 商品评论的特点
+
+### 3.1 综合分析多条评论
+
+- 需综合多条评论以获完整产品情况
+- 不同类型商品和用户群体的评论关注点不同
+- 需考虑时间因素和重点提取
+
+### 3.2 多样化场景
+
+- C端需快速浏览和决策辅助
+- B端需产品改进、市场洞察和竞品分析
+
+### 3.3 离线处理
+
+- 一般无需实时处理，批量处理即可
+- 优化资源使用和深度分析
+
+### 3.4 大数据处理
+
+- 处理大量评论数据，支持增量更新
+- 多语言支持和情感分析
+
+### 3.5 信息质量不齐
+
+- 需要过滤垃圾评论和验证真实性。
+
+## 4 GenAI在评论应用
+
+GenAI凭其强大NLP能力，可高效分析和总结大量评论、提取关键信息、识别情感倾向，甚至生成简洁明了评论摘要：
+
+- 帮助买家快速了解商品优缺
+- 为卖家提供有价值的分析，辅助决策和改进
+
+### 4.1 应用场景盘点
+
+根据评论的应用场景和 GenAI 特点，应用场景可归类：
+
+| **应用分类** | **应用场景**                 | **场景介绍**                                                 | **目标收益**                                                 |
+| ------------ | ---------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
+| C 端用户     | 用户查看的商品评论总结       | 帮助用户快速商品购买体验，提升选品效率。 结合用户和产品特点，总结针对性商品评论信息。 根据总结关键词，快速定位原始评论信息 | 1. 提升选品效率<br>2. 减少商品评论的误判<br/> 3. 减少评论页面请求 |
+| B 端用户     | 根据评论信息给出商品改建建议 | 快读根据评论总结改进建议，帮助商家快速了解用户对商品的体验，从而根据体验反馈改进商品。 不断提升产品迭代周期 | 1. 提升产品竞争力<br/>2. 提升产品效率<br/>3. 提升用户满意度  |
+|              | 根据评论信息总结回复内容     | 分析评论内容，总结回复用户评论信息                           | 1. 防止评论遗漏<br/>2. 提升评论回复效率<br/>3. 提升用户体验  |
+|              | 根据评论总结产品体验趋势     | 根据评论感知用户体验的变化； 洞察用户对消费者的偏好和市场趋势 | 1. 根据市场洞察，总结市场消费趋势<br/>2. 加速产品创新        |
+
+## 5 GenAI方案设计
+
+### 5.1 平台选择
+
+如Bedrock，某逊提供的生成式AI服务平台。允许开发者无缝接入多种顶级基础模型，而无需管理复杂基础设施。
+
+### 5.2 模型选择
+
+Nova是新一代最先进基础模型，具有前沿的智能和行业领先的性价比，可在Bedrock上用。 Nova模型包括三种理解模型和两种创意内容生成模型。
+
+### 5.3 离线批量处理
+
+使用批量推理，可提交多个提示并异步生成响应。批量推理通过发送单个请求并在 S3 生成响应，助高效处理大量请求。在您创建的文件中定义模型输入后，需将相应文件上传到S3。然后，你需提交批量推理请求并指定 S3 bucket。作业完成后，你可从 S3 检索输出文件。可用批量推理来提高对大型数据集的模型推理性能。
+
+- 高效处理：一次处理大量评论，提高处理效率
+- 成本优化：批量处理降低 API 调用频率，优化成本
+- 灵活调度：可在系统负载较低时进行处理，优化资源利用
+- 深度分析：更充足时间全面、深入分析
+
+### 5.4 语义检索
+
+Bedrock Knowledge Bases
+
+借助Bedrock知识库，可将专有信息集成到你的AIGC应用。查询时，知识库会搜索你的数据以查找相关信息来回答查询。为支持基于语义的评论检索，引入知识库和向量化存储：
+
+- 使用适当的嵌入模型将评论内容向量化。
+- 将向量化后的评论存储在专门的向量数据库中（如 Amazon OpenSearch）。
+- 实现基于语义的相似度搜索，支持更准确的评论检索。
+
+这允许我们根据总结中的关键词或概念，快速找到最相关原始评论，大大提高检索准确性和效率。
+
+通过该设计，即可创建一个强大、灵活且可扩展 GenAI 解决方案，有效处理大规模电商评论数据，为C、B端用户提供高质量分析结果。
+
+## 6 总结
+
+本文深入GenAI在电商评论场景应用，聚焦场景分析和技术选型。先阐述商品评论对买家和卖家的重要性，揭示传统评论处理方法面临的诸多挑战，如信息过载、效率低下和产品迭代周期长等问题。
+
+详细分析电商评论处理独特特点，包括需要综合分析多条评论、适应多样化的C端和B端场景、处理大量数据等。这些特点为 GenAI 的应用提供广阔空间。
+
+技术选型：提出基于某逊的综合解决方案。核心技术包括用 Bedrock 的 Nova 模型进行评论分析，利用 Batch Inference 实现高效离线处理。
+
+后续继续探讨实现细节，如离线数据分析处理的流程，以及如何实现基于语义的评论信息查询。为大家提供更全面、实用的 GenAI 应用指南。
+
+- GenAI 在电商评论场景的应用 2 – 离线数据分析处理介绍如何使用 Batch Inference + Nova 离线处理评论数据，同时对方案的成本进行分析
+- GenAI 在电商评论场景的应用 3 –  根据关键词根据语义查询评论信息介绍在评论的总结中，如何实现根据关键词反像查询相关的评论记录
+
+参考：
+
+- https://www.brightlocal.com/research/local-consumer-review-survey-2023/
\ No newline at end of file
diff --git "a/docs/md/AI/llm/GPTs\346\216\250\350\215\220.md" b/docs/md/AI/llm/GPTs.md
similarity index 100%
rename from "docs/md/AI/llm/GPTs\346\216\250\350\215\220.md"
rename to docs/md/AI/llm/GPTs.md
diff --git a/docs/md/AI/llm/making-an-llm-that-sees-and-reasons.md b/docs/md/AI/llm/making-an-llm-that-sees-and-reasons.md
new file mode 100644
index 000000000..6e94de673
--- /dev/null
+++ b/docs/md/AI/llm/making-an-llm-that-sees-and-reasons.md
@@ -0,0 +1,133 @@
+# 让 LLM 既能“看”又能“推理”！
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/9ec1c9f42ba36473d22145067e92bdc9.png)
+
+DeepSeek-R1 会推理，GPT-4o 会看。能否让
+
+## 1 LLM既能看又能推理？
+
+DeepSeek-R1取得很大成功，但它有个问题——**无法处理图像输入**。
+
+### 1.1 DeepSeek模型发展
+
+自2024.12，DeepSeek已发布：
+
+- **DeepSeek-V3**（2024.12）：视觉语言模型（VLM），支持图像和文本输入，类似 GPT-4o
+- **DeepSeek-R1**（2025.1）：大规模推理模型（LRM），仅支持文本输入，但具备更强的推理能力，类似 OpenAI-o1
+
+我们已领略**视觉语言模型（VLM）**和**大规模推理模型（LRM）**，下一个是谁？
+
+我们需要**视觉推理模型（VRM）**——既能看又能推理。本文探讨如何实现它。
+
+## 2 现有模型的问题
+
+当前VLM 不能很好推理，而 LRM 只能处理文本，无法理解视觉信息。若想要一个既能**看懂图像**，又能**深度推理**的模型？
+
+### 物理问题示例
+
+我是一个学生，向 LLM 提问物理问题，并附带一张图像。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/f84418b6a433c5ffecf67ccb39632895.png)
+
+就需要一个模型能同时：
+
+1. **理解图像内容**
+2. **进行深度推理**（如分析问题、评估答案、考虑多种可能性）
+
+就需要👉 **一个大规模视觉推理模型（VRM）**，视觉推理模型示意图：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/63dc4902c152fdc1409a295b21750712.png)
+
+讨论咋训练 VRM 之前，先了解VLM（视觉语言模型）架构。
+
+## 3 VLM架构
+
+如LLaVA，**L**arge **L**anguage **a**nd **V**ision **A**ssistant（大规模语言与视觉助手），2023年底发布的知名 VLM。
+
+LLM 通常采用 Transformer 结构，输入文本后将其转化为 token，再通过数学计算预测下一个 token。
+
+如若输入文本 **"Donald Trump is the"**，LLM可能预测下一 token 为 **"POTUS"（美国总统）**。LLM 预测过程示意图：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/ca32f1eacb88270e0604c0c6384b9791.png)
+
+那VLM咋工作的？VLM不仅根据前面的文本预测输出，还会参考输入的**图像**。VLM 预测过程示意图：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/a67d25a9aad8028b85b5e2102687b855.png)
+
+但**咋让 LLM 理解图像？**
+
+## 4 VLM咋处理图像输入？
+
+核心思路：**将图像数据转换成 LLM 能理解的格式**。
+
+LLaVA论文用 **CLIP 视觉编码器**将图像转化为向量。然后，在编码器后添加一个**可训练的线性层**。图像编码示意图：
+
+![](https://miro.medium.com/v2/resize:fit:700/1*cIsMQiUD_leIPnmRuVFN7A.png)
+
+最终的视觉隐藏状态（**Hv**）会与文本 token 的隐藏状态拼接在一起，输入 Transformer 层，最后生成预测结果。
+
+LLaVA 在这里使用的是 **Vicuna** 作为 LLM。
+
+![LLaVA 结构示意图](https://miro.medium.com/v2/resize:fit:700/1*nf2v70Sq9lgtVZQt3cXVZw.png)
+
+不过，仅仅有这个结构是不够的，模型还需要**训练**，才能真正理解图像内容。
+
+## 5 VLM咋训练？
+
+LLaVA 采用了**端到端微调（End-to-End Fine-tuning）**的方式。
+
+> **端到端微调**：将整个模型视作一个黑盒，并进行整体训练。
+
+LLaVA 端到端微调示意图：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/43f77298a995f94bb2959c64ddae8fcc.png)
+
+训练时，**CLIP编码器的参数通常是冻结的**，只更新线性层（**W**）和 LLM（**ϕ**）的参数。LLaVA 微调过程示意图：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/0be1689a997f8ed39229979db3dee0ea.png)
+
+## 6 能否用强化学习（RL）训练 VLM？
+
+RL在 LLM 领域表现出色，提升了推理能力（如 RLHF 训练的 GPT-4）。**若用 RL 训练 VLM，是否能打造更强的视觉推理模型？**
+
+以**图像分类任务**为例。
+
+### 6.1 任务定义：图像分类
+
+训练时，希望模型能**根据图像内容，输出正确的类别标签**。
+
+![图像分类示意图](https://miro.medium.com/v2/resize:fit:700/1*8Z64xfuUTau8nwh1-zWDog.png)
+
+数据集中的每条数据包括：**图像、标题（正确答案）、问题**。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/e8fa3aa49a014282291f2b917bb18f38.png)
+
+### 强化学习奖励设计
+
+可设计两种奖励机制：
+
+1. **正确性奖励**：如果模型输出的答案正确（例如"dog"），则奖励 +1。
+
+   ![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/e0851ea99efeab58c8765b34467f7904.png)
+
+2. **格式奖励**：如果模型按照固定格式输出（先思考 `<think>`，再回答 `<answer>`），则额外奖励。
+
+   ![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/c0eee2e87edbb5ff9ffc2998ad568274.png)
+
+这可鼓励模型在回答前进行推理，而不是盲目给出答案。
+
+## 7 实际应用
+
+VLM目前在某些场景仍表现不佳，如**数学和科学类问题**。
+
+如题目正确答案 **2 bpm**，但 GPT-4o 回答错误：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/92e01b8e0f45be1ad0756c0417fc8276.png)
+
+GPT-4o错误回答：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/6580bca0a897483f0d8393aa733a129f.png)
+
+如能让 LLM 在视觉推理方面更强，或许能正确解答。期望的 VRM 结果：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/8cff6b75d4c1a12b38dd6deed31b20ba.png)
\ No newline at end of file
diff --git a/docs/md/rpc/rpc-retry-mechanism.md b/docs/md/rpc/rpc-retry-mechanism.md
new file mode 100644
index 000000000..6c99e6dcf
--- /dev/null
+++ b/docs/md/rpc/rpc-retry-mechanism.md
@@ -0,0 +1,173 @@
+# 别让你的微服务在重试中死去：深入理解RPC异常重试机制
+
+## 1 异常重试的意义
+
+发起一次RPC调用远程的一个服务，如用户登录操作，先验证用户名密码，成功后，获取用户基本信息。通过远程的用户服务获取用户基本信息时，恰好网络故障，导致请求失败，而这请求我们希望它能尽可能执行成功，咋办？
+
+需重发一次RPC调用，那是catch下，失败就再发起一次调用？显然不优雅。考虑RPC框架的重试机制。
+
+## 2 RPC框架重试
+
+当调用端发起的请求失败时，RPC框架自身可重试，再重发请求，用户可设置：
+
+- 是否开启重试
+- 重试次数
+
+RPC异常重试：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/03/415236c7f386679cb45ee23895d10a39.png)
+
+caller发RPC调用时，会经负载均衡，选择一个节点，之后向该节点发请求信息。当消息发失败或收到异常消息，即可捕获异常，根据异常触发重试，重新负载均衡选一节点发请求消息，并记录请求重试次数。当重试次数达到用户配置重试次数阈值，返回给caller动态代理一个失败异常，否则继续重试。
+
+Q：RPC框架重试机制就是caller发现请求失败时捕获异常，再触发重试，所有异常都触发重试？
+
+A：No！因为这异常可能是服务提供方抛回的业务异常，应正常返给动态代理，所以要在触发重试前判定捕获的异常，符合重试条件才触发，如网络超时异常、网络连接异常等。
+
+## 3 业务逻辑须幂等
+
+网络抖动一下导致请求超时，但这时调用方的请求信息可能已发到服务提供方的节点，也可能已发送到服务提供方的服务节点，若请求信息成功发送到服务节点，那这节点是不是就要执行业务逻辑了。
+
+若此时发起重试，业务逻辑会被执行。若该服务业务逻辑不幂等，如插入数据操作，那触发重试就会引发问题。
+
+综上，使用RPC框架的时候，要确保被调用的服务的业务逻辑幂等，才能考虑根据事件情况开启RPC框架异常重试功能。
+
+## 4 超时时间的重置
+
+把调用端的请求超时时间设5s，结果连续重试3次，每次耗时2s，那最终这请求耗时是6s，调用端设置的超时时间是不是就不准确了？
+
+连续的异常重试，且每次处理的请求时间较长，最终会导致请求处理的时间过长，超出用户设置的超时时间。
+
+解决该问题最直接方式：每次重试后都重置请求的超时时间。
+
+当调用端发起RPC请求时，若发送请求发生异常并触发异常重试，先判定该请求是否已超时：
+
+- 已超时，直接返回超时异常
+- 否则，先重置该请求的超时时间，再发起重试
+
+## 5 去掉有问题的服务节点
+
+当调用端设置异常重试策略，发起一次RPC调用，通过负载均衡选择了节点，将请求消息发送到这节点。这时该节点由于负载压力大，导致该请求处理失败了，调用端触发了重试，再次通过负载均衡选择了一个节点，结果恰好仍选择该节点，这种情况下，重试效果受到影响。因此，要在所有发起重试、负载均衡选择节点时，去掉重试之前出现过问题的那个节点，以保证重试成功率。
+
+
+
+RPC框架的异常重试机制，是调用端发送请求之后，若发送失败会捕获异常，触发重试，但不是所有异常都会触发重试，只有RPC框架中特定的异常才会如此，比如连接异常、超时异常。
+
+而像服务端业务逻辑中抛回给调用端的异常是不能重试的。那么请你想一下这种情况：服务端的业务逻辑抛给调用端一个异常信息，而服务端抛出这个异常是允许调用端重新发起一次调用的。
+
+### 案例
+
+服务端的业务逻辑是对数据库某个数据的更新操作，更新失败则抛更新失败异常，调用端可再次调用，触发服务端重新执行更新操作。那这时对调用端来说，它接收到更新失败异常，虽然是服务端抛来的业务异常，但也可重试。
+
+#### 此时RPC框架重试机制如何优化？
+
+RPC框架不知道哪些业务异常能去异常重试，可加个重试异常白名单，用户将允许重试的异常加入白名单。当调用端发起调用，并且配置了异常重试策略，捕获到异常后，采用这样的异常处理策略。若该异常是RPC框架允许重试的异常或该异常类型存在于可重试异常的白名单，就允许对该请求重试。
+
+综上，可靠的异常重试机制：
+
+![](/Users/javaedge/Downloads/IDEAProjects/java-edge-master/assets//5e5706e6fc02ef0caaee565ea358f281.jpg)
+
+## 6 总结
+
+当调用端发起的请求失败时，如果配置了异常重试策略，RPC框架会捕捉异常，对异常进行判定，符合条件则进行重试，重发请求。
+
+重试过程中，为在约定时间内进行安全可靠重试，在每次触发重试前，判定该请求是否已超时，若已超时，直接返回超时异常，否则重置该请求的超时时间，防止因多次重试导致该请求的处理时间超过用户配置的超时时间，而影响业务处理的耗时。
+
+发起重试、负载均衡选择节点时，去掉重试前出现问题的节点，以提高重试成功率，并允许用户配置可重试异常的白名单，让RPC框架的异常重试功能对业务更友好。
+
+要确保被调用的服务的业务逻辑是幂等的，才能考虑是否使用重试。
+
+异常重试就是为了尽最大可能保证接口可用率的一种手段，但这种策略只能用在幂等接口上，否则就会因为重试导致应用系统数据“写花”。
+
+## FAQ
+
+整个RPC调用的流程中，异常重试发生在哪环节？
+
+
+
+重试也需要时间间隔一直调整，不然影响服务方性能。重试次数大于服务方实例时，动态调整重试间隔时间。比如当前服务有3个实例，调用方重试次数是10，前3次是失败就重试（不停换下一个节点）。从第4次开始，有延迟，第一次1S，第二次2S，第三次4S，以2幂次方增加重试间隔时间，保证服务调用方不因为重试把QPS或TPS占满。
+
+
+
+异常重试机制发生在：客户端调用时，并且重试代码块包含的内容是集群处理（服务发现和负载均衡），及请求调用；并且包含异步响应的结果获取。
+所以应该是在动态代理发起invoke，紧接着的一步。
+
+
+
+
+
+感觉异常重试还是主要放到远程调用服务端这块？那如果是由于网络问题呢，调用端没收到响应，服务端就没法处理了吧！
+
+
+
+failsafe failfast failover failback。
+
+
+
+
+
+这个异常机制其实就像网络socket连接的时候发生的异常一样，我们可以采用避退策略。也就是第一次失败，延迟2秒再试第二次。假如第二次再失败，延迟4秒。直道重试次数达到上限。
+当然了，在RPC场景下，我们也可以在前几次不断的路由切换，切换到不同的服务提供节点。
+
+rpc都是实时业务，退避好像不合适啊
+
+
+
+
+
+“保证被重试的业务服务是幂等的”，这就要求了服务提供方必须能支持重复请求，而这就需要业务部门在开发可提供的每一个服务时候都要注意到这一点，那么我们是否能在服务具体逻辑之前增加一层呢，比如每一次请求带有唯一id，这一层逻辑负责统计唯一id的执行情况以及是否完成了回调，重复收到的请求，是否能把保存下来的结果直接返回呢。
+
+方案没问题，但需要考虑团队研发整体接受度
+
+
+
+
+
+异常重试主要有客户端的重试，每个业务层也会有重试，通过幂等，白名单，摘除认为有问题的机器，重试次数来保证业务可用
+
+rpc可以做到话，尽量下沉
+
+
+
+
+
+这段超时时间重置不是很理解，A--->B--->C，B 调用 C 超时时间 10s，重试次数为 2.
+如果 B 调用 C 耗费 5s 失败，然后重试。这时重试的超时不是只剩下 5 s 了吗？
+如果又将这次超时时间重置为 10s，假如这次调用成功了，消耗了 9S，那么 B 总体耗费了 14 S，但是 A 设置超时时间假如 12 s，这时 A 不是已经超时断开了吗？
+
+重置超时时间是指，将10秒置为5秒，很大开源的rpc框架是不会修改超时时间的。
+
+
+
+
+
+异常重试机制应该发生在负载均衡选取服务节点并发起服务调用这个阶段，可以做到以下需求
+\1. 服务调用失败，剔除失败的服务重新发起一次调用
+\2. 捕获返回的异常信息，决定是否再次发起请求
+
+
+
+
+
+如果最后一次重试，失败了，服务实际执行成功，造成调用方本地事务回滚，而服务下游数据提交成功，就会出现数据不一致。这能解决吗？还是这种问题出现概率小，到时候人工处理。
+
+感觉是在动态代理的地方增加一个重试插件来实现。
+
+
+
+
+
+
+
+rpc重试要业务层面负责幂等性
+
+如果要重试，服务端的逻辑一定要幂等
+
+
+
+
+
+在客户端使用动态代理执行远程调用的时候进行重试。因为这个时候能直接获取到调用结果，通过捕获的异常判断是否需要重试。
+
+"caller收集服务端每个节点的指标数据，再按各种指标数据进行计算打分，最后根据每个节点分数，将更多流量打到分高的节点。",如果每个调用端都要单独检测服务端节点的各项指标,这也是一个不小的性能损耗把?这个检测要每个调用端自己实现吗?这个开发量也不少啊？
+
+这个应该是rpc框架实现，方便使用方使用，至于性能开销，就要看计算的算法。
\ No newline at end of file

From 3bb0b68c44b9d103401cc0177b8779b41e1b23cb Mon Sep 17 00:00:00 2001
From: JavaEdge <sss2855845850@gmail.com>
Date: Mon, 7 Apr 2025 14:28:39 +0800
Subject: [PATCH 12/20] =?UTF-8?q?perf:=E8=B0=83=E6=95=B4=E4=B8=93=E6=A0=8F?=
 =?UTF-8?q?=E7=BB=93=E6=9E=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/.vuepress/config.js                      |  156 +-
 docs/md/AI/agent/changelog-cursor.md          | 1367 +++++++++++++++++
 .../goodbye-cursor-hello-windsurf.md          |    0
 .../AI/ai-trends-disrupting-software-teams.md |  239 +++
 .../AI/llm/llama-4-multimodal-intelligence.md |  137 ++
 docs/md/other/guide-to-reading.md             |   18 +-
 6 files changed, 1836 insertions(+), 81 deletions(-)
 create mode 100644 docs/md/AI/agent/changelog-cursor.md
 rename docs/md/AI/{llm => agent}/goodbye-cursor-hello-windsurf.md (100%)
 create mode 100644 docs/md/AI/ai-trends-disrupting-software-teams.md
 create mode 100644 docs/md/AI/llm/llama-4-multimodal-intelligence.md

diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index 844cc67ba..00c30cdbf 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -735,20 +735,20 @@ module.exports = {
                                 link: '/md/python/00-macOS和Linux安装和管理多个Python版本'
                             },
                             {
-                                text: 'AI理论',
+                                text: 'AI算法',
                                 link: '/md/AI/ml/01-人工智能概要'
                             },
                             {
-                                text: 'AIGC应用开发框架',
+                                text: 'AIGC应用开发',
                                 link: '/md/AI/AI大模型企业应用实战'
                             },
                             {
-                                text: '大模型平台',
+                                text: '大模型平台和Prompt工程',
                                 link: '/md/AI/llm/GPTs'
                             },
                             {
-                                text: 'Prompt工程',
-                                link: '/md/AI/llm/01-Prompt网站'
+                                text: 'AI Agent',
+                                link: '/md/AI/agent/changelog-cursor'
                             },
                         ]
                     },
@@ -2104,7 +2104,6 @@ module.exports = {
                                 "contextual-retrieval",
                                 "lm-studio-transform-mac-into-ai-tool",
                                 "navigating-llm-deployment-tips-tricks-and-techniques",
-                                "goodbye-cursor-hello-windsurf",
                                 "qwen-QwQ",
                                 "only-ai-flow-can-do",
                                 "chatgpt-canva",
@@ -2133,6 +2132,15 @@ module.exports = {
                                 "claude-3-7-sonnet",
                             ]
                         },
+
+                        {
+                            title: "llama",
+                            collapsable: false,
+                            sidebarDepth: 0,
+                            children: [
+                                "llama-4-multimodal-intelligence",
+                            ]
+                        },
                         {
                             title: "Prompt工程",
                             collapsable: false,
@@ -2142,7 +2150,7 @@ module.exports = {
                                 "02-常用Prompt",
                             ]
                         },
-                        
+
                         {
                             title: "Dify",
                             collapsable: false,
@@ -2157,67 +2165,67 @@ module.exports = {
                     ],
 
                     "/md/AI/ml/": [{
-                        title: "机器学习",
-                        collapsable: false,
-                        sidebarDepth: 0,
-                        children: [
-                            "软件工程师转型AI的全攻略",
-                            "01-人工智能概要",
-                            "02-MR 算法分类",
-                            "what-is-neural-network",
-                            "MapReduce分治思想",
-                            "05-开发环境安装",
-                            "一文看懂AI的Transformer架构",
-                            "what-is-tensor",
-                        ]
-                    },
-                    
-                    {
-                        title: "PyTorch",
-                        collapsable: false,
-                        sidebarDepth: 0,
-                        children: [
-                            "building-neural-networks-with-pytorch",
-                            "pytorch-cifar10-image-classifier-tutorial",
-                        ]
-                    },
-                    
-                    {
-                        title: "NLP",
-                        collapsable: false,
-                        sidebarDepth: 0,
-                        children: [
-                            "basic-of-nlp",
-                            "text-preprocessing-overview",
-                            "text-vectorization-guide",
-                            "text-data-analysis-practical-guide",
-                            "key-path-from-feature-enhancement-to-dimensional-norm",
-                            "text-data-augmentation-back-translation-guide",
-                        ]
-                    },
-                    
-                    {
-                        title: "RNN",
-                        collapsable: false,
-                        sidebarDepth: 0,
-                        children: [
-                            "what-is-rnn",
-                            "neural-memory-engine-for-sequence-modeling",
-                            "long-short-term-memory",
-                            "gated-recurrent-unit-model",
-                        ]
-                    },
-                    
-                    {
-                        title: "Transformer",
-                        collapsable: false,
-                        sidebarDepth: 0,
-                        children: [
-                            "mask-tensor",
-                        ]
-                    },
-                
-                ],
+                            title: "机器学习",
+                            collapsable: false,
+                            sidebarDepth: 0,
+                            children: [
+                                "软件工程师转型AI的全攻略",
+                                "01-人工智能概要",
+                                "02-MR 算法分类",
+                                "what-is-neural-network",
+                                "MapReduce分治思想",
+                                "05-开发环境安装",
+                                "一文看懂AI的Transformer架构",
+                                "what-is-tensor",
+                            ]
+                        },
+
+                        {
+                            title: "PyTorch",
+                            collapsable: false,
+                            sidebarDepth: 0,
+                            children: [
+                                "building-neural-networks-with-pytorch",
+                                "pytorch-cifar10-image-classifier-tutorial",
+                            ]
+                        },
+
+                        {
+                            title: "NLP",
+                            collapsable: false,
+                            sidebarDepth: 0,
+                            children: [
+                                "basic-of-nlp",
+                                "text-preprocessing-overview",
+                                "text-vectorization-guide",
+                                "text-data-analysis-practical-guide",
+                                "key-path-from-feature-enhancement-to-dimensional-norm",
+                                "text-data-augmentation-back-translation-guide",
+                            ]
+                        },
+
+                        {
+                            title: "RNN",
+                            collapsable: false,
+                            sidebarDepth: 0,
+                            children: [
+                                "what-is-rnn",
+                                "neural-memory-engine-for-sequence-modeling",
+                                "long-short-term-memory",
+                                "gated-recurrent-unit-model",
+                            ]
+                        },
+
+                        {
+                            title: "Transformer",
+                            collapsable: false,
+                            sidebarDepth: 0,
+                            children: [
+                                "mask-tensor",
+                            ]
+                        },
+
+                    ],
 
                     "/md/AI/langchain4j/": [{
                             title: "LangChain4j基础",
@@ -2249,6 +2257,17 @@ module.exports = {
                             ]
                         },
                     ],
+                    
+                    "/md/AI/agent/": [{
+                            title: "辅助编程",
+                            collapsable: false,
+                            sidebarDepth: 0,
+                            children: [
+                                "changelog-cursor",
+                                "goodbye-cursor-hello-windsurf",
+                            ]
+                        },
+                    ],
 
                     "/md/AI/spring-ai-alibaba/": [{
                         title: "Spring AI Alibaba",
@@ -2339,6 +2358,7 @@ module.exports = {
                                 "software-development-in-AI2",
                                 "overcoming-fear-uncertainty-and-doubt-in-the-era-of-ai-transformation",
                                 "aigc-app-in-e-commerce-review",
+                                "ai-trends-disrupting-software-teams",
                             ]
                         },
 
diff --git a/docs/md/AI/agent/changelog-cursor.md b/docs/md/AI/agent/changelog-cursor.md
new file mode 100644
index 000000000..fb566cb4e
--- /dev/null
+++ b/docs/md/AI/agent/changelog-cursor.md
@@ -0,0 +1,1367 @@
+# AI 代码编辑器
+
+旨在让你获得超凡的生产力， Cursor 是使用 AI 编写代码的最佳方式。
+
+## 0.48.x-聊天标签、自定义模式 & 更快的索引
+
+引入**聊天标签**，支持并行对话，并重新设计**模式系统**，允许添加自定义模式。
+
+优化**成本可见性**、**索引性能**和**MCP（多代码处理）可靠性**。聊天完成后，系统会播放**音效通知**。
+
+### 内置模式（测试版）
+
+Cursor现提供两种内置模式：Agent和Ask
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/04/d2f54328d2417d5fbd9eff2026a2694c.png)
+
+
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/04/1203dbce232aa7b0e8911ba8e1a11b43.png)
+
+原"Edit"模式更名为"Manual"，以更准确反映其功能。
+
+- **Ask 模式**默认可访问所有搜索工具，因此 `@Codebase` 工具已被移除。系统会在需要时自动搜索代码库。想强制搜索代码库，可直接自然语言告诉 Cursor如："搜索代码库"
+- 可在模式菜单中**禁用 Ask 模式的搜索功能**，这样 Ask 模式就只能看到你提供的上下文：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/04/3d99a91af540e03dd9e94d7fd993809a.png)
+
+### 自定义模式（测试版）
+
+允许你根据自己的工作流创建新的模式，并配置不同工具和提示词。支持自定义快捷键：
+
+- ⌘I：默认用于Agent模式
+- ⌘L：用于切换侧边栏
+- 如解除 `⌘I` 的绑定，它也会切换侧边栏
+
+可在**"设置" → "功能" → "聊天" → "自定义模式"**中开启。
+
+可在**"设置" → "功能" → "聊天" → "默认聊天模式"**中选择默认模式，可设置为**最近使用的模式**或**自定义模式**。
+
+![](https://www.cursor.com/_next/image?url=%2F_next%2Fstatic%2Fmedia%2Fcustom-modes.19f7c3f2.png&w=3840&q=75)
+
+### 聊天标签
+
+现可在聊天中创建多个标签页（⌘T），同时进行多个对话。如在一个标签页使用 Agent 模式，在另一个标签页进行不同任务。
+
+如果某个标签页**正在等待输入**，它的标题上会出现**橙色小圆点**。
+
+### 更快的索引
+
+- 现在，同一团队内的**相似代码库**索引速度大幅提升
+- **大型仓库的重复索引时间**大幅减少。如Cursor 代码库的索引时间已从**20min缩短到不到 1 min**
+
+### 音效通知（测试版）
+
+Cursor 现在可以在聊天**完成**时播放**音效通知**。你可以在**"设置" → "功能" → "聊天" → "完成时播放音效"**中开启该功能。
+
+### 基于使用情况的成本可见性
+
+对于**按使用量计费的模型**，可在**聊天历史**中查看**每次聊天的成本及详细费用**。
+
+### 全新引导体验
+
+- 优化了**新用户引导流程**，助快速上手 Cursor
+- 你可以**导入设置**，选择**主题**、**快捷键**等个性化选项
+
+### 其他更新
+
+- **团队共享代码库的索引性能优化**
+- **垂直侧边栏**暂不可用（仅影响已加入"抢先体验"的用户）
+- **MCP 服务器支持改进**，当需要启用 MCP 时，系统会提示用户
+- **聊天界面会在接近请求或使用限制时提示计费信息**
+- **团队管理员配置的自动运行控制更清晰**，明确何时启用
+- **由于稳定性问题，自动运行（auto-run）功能被移除**（之前启用该功能的用户会自动关闭）
+
+### 优化
+
+- **快捷键调整**：
+  - **"全部拒绝"（Reject all diffs）快捷键**从 `⌘⌫`（Cmd+Backspace）更改为 `⌘⇧⌫`（Cmd+Shift+Backspace）
+- **Windows 平台 MCP 更加稳定**
+- **MCP 服务器配置时，错误信息更清晰，方便排查问题**
+- **聊天消息现在显示输入的 Token 数量**（点击右上角的**三个点**查看）
+
+## 0.47.x-稳定性、快捷键 & 预览
+
+本次更新主要优化**稳定性**和**性能**，提升现有功能的**流畅度**。
+
+### 主要更新
+
+- **快捷键优化**：所有快捷键现在可以在**"设置" → "快捷键"**菜单中查看和修改
+- **抢先体验**：可以在**"设置" → "Beta" → "更新频率"**中开启"抢先体验"模式
+- **自动选择模型**：Cursor 会**根据任务类型**自动选择**最合适的高级模型**，确保在模型负载高或故障时仍能保持性能
+- **新增主题**：Cursor Dark、Cursor Midnight、Cursor Dark（高对比度）
+- **UI 改进**：优化工具调用 UI、思考状态 UI、错误提示，并新增**版本更新通知**
+- **规则优化**：支持**嵌套的 `.cursor/rules` 目录**，同时提升 UX，让规则的生效状态更清晰
+- **MCP 更新**：新增**全局服务器配置**（`~/.cursor/mcp.json`）及**环境变量支持**
+- **Sonnet 3.7 思考优化**：优化 3.7 模型的思考逻辑，现在"思考"操作消耗**2 个请求**（之前是 1 个）
+- **文件忽略优化**：`.cursorignore` 规则更稳定，文件排除更精准
+- **支持批量上传图片**到聊天窗口
+
+### 修复
+
+- **0.47.2** - Cursor Tab 支持**单行选择**
+- **0.47.6** - **加速应用**代码变更，**提示 `.cursorignore` 阻止编辑**的情况
+
+## 0.46 - Agent准备就绪与UI焕新
+
+**2025年2月19日**
+
+- **Agent准备就绪**：Agent现已成为默认模式，带来更强大且统一的AI体验。不再有Chat、Composer和Agent之间的混淆——只有一个智能界面，能适应你的需求。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/04/b5806689ef4a81f742656ebc994cc9f5.png)
+
+- **UI焕新**：第一阶段的界面更新，带来全新的默认Cursor主题，专为专注设计。我们还简化了@-上下文菜单，让Agent更精准
+- **网页搜索**：Agent现在可以自动搜索网络获取最新信息，无需显式@Web命令
+- **忽略文件**：`.cursorignore`现不仅能阻止文件被索引，还能禁止文件在聊天中添加或用于Tab补全。引入`.cursorindexingignore`，专门用于控制文件索引
+- **Agent工具限制**：当达到25次工具调用限制时，你可以按“继续”按钮继续操作（计为新请求）
+- **项目规则**：
+  - 新增全局应用规则的能力，并提供视觉指示以显示规则何时生效
+- **MCP改进**：
+  - Agent现可在Yolo模式下自动运行MCP工具
+  - 通过`<项目根目录>/.cursor/mcp.json`配置项目服务器
+  - 支持Agent使用MCP资源作为上下文
+
+## 0.45 - .cursor/rules、更强的代码库理解、全新Tab模型
+
+**2025年1月23日**
+
+- **`.cursor/rules`**：用户可以在`.cursor/rules`目录中编写多个仓库级规则并保存到磁盘，Agent会自动选择适用的规则。
+- **Deepseek模型**：0.45和0.44版本支持Deepseek R1和Deepseek v3，可在设置 > 模型中启用。我们在美国自托管这些模型。
+- **总结之前的Composer**：当对话过长时，你可以开始新对话，同时引用之前的对话。
+- **Agent感知最近更改**：Agent可以使用工具查看你的最近更改，还能看到用户消息之间的变动。
+- **更强的代码库理解**：我们训练了一个新的代码库理解模型，将在0.45版本中逐步推广给所有用户。
+- **Fusion模型**：我们训练了一个新的Tab模型，在跳转和长上下文处理上显著提升，很快将推广给用户。
+- **可选长上下文**：在标记长文件时，用户可以选择使用高级模型请求更大的上下文窗口，这将消耗更多快速请求。
+
+**更新 (0.45.1-0.45.11)**：增加MCP支持、团队可配置的黑名单。
+
+**更新 (0.45.12-13)**：F1 > “检查更新”。
+
+## 0.44-代理功能改进、Yolo模式、Cursor Tab更新
+
+2024年12月17日
+
+- 代理现在可查看终端退出代码，支持后台运行命令，并且命令变得可编辑
+- 代理能够读取代码检查器（linter）错误并自动修复问题
+- 在Yolo模式下，代理可以自动执行终端命令
+- 新增@docs、@git、@web 和 @folder 功能供代理使用
+- 代理会自动将更改保存到磁盘
+- 代理可以同时编辑多个位置
+- 代理能够通过更智能的应用模型重新应用更改
+- Composer 的更改和检查点现在会在重载后保留
+
+### 错误修复：
+
+- Composer 不再访问已删除的文件。
+
+[Nov 24, 2024]
+
+## 0.43 - 新Composer UI、Agent、提交信息
+
+- 侧边栏中的Composer UI，带有内联差异比较
+
+- Composer中的早期版本Agent，可自主选择上下文并使用终端
+
+- 自动生成Git提交信息
+
+- 聊天/Composer中的文件推荐标签
+
+- 聊天/Composer中的@Recommended功能，用于语义搜索上下文
+
+- 改进的图像拖放体验
+
+- 多项性能改进
+
+- Beta测试：预览即将推出的Bug查找功能
+
+  ![](https://my-img.javaedge.com.cn/javaedge-blog/2024/12/a91b66c6d32e9c18ef406abc60ac8e7b.png)
+
+  使用点击 run new，会提示消耗很大，可选择 free 尝试使用：
+
+  ![](/Users/javaedge/Downloads/IDEAProjects/java-edge-master/assets/image-20241223160511510.png)
+
+分析结果：
+
+![](/Users/javaedge/Downloads/IDEAProjects/java-edge-master/assets/image-20241223160601102.png)
+
+其他说明：
+
+- 已停止长上下文聊天Beta版
+- 将Composer控制面板整合到侧边栏
+
+此版本为Cursor增加了多个实用的协作编程和AI辅助功能，特别是在代码上下文管理和生成提交信息方面。
+
+**2024年10月9日**
+
+## **0.42 - Composer历史记录，@Lint错误，VS Code 1.93.1**
+
+Composer历史记录允许您在重启后访问以前的Composer会话。还可在会话中编辑和重新提交以前的邮件。
+
+我们对Debug with AI进行了轻微改进，并在Chat中添加了@Lint错误。
+
+现基于VS Code 1.93.1。
+
+Python自动导入光标选项卡在此版本中更加稳定。
+
+使用聊天、Composer和cmd-k输入框中的模型搜索（Cmd-option- /）可更轻松切换模型。
+
+Composer现在仅应用上下文中的文件以防幻觉。
+
+使用光标.与WSL现在应该更稳定。
+
+**更新（0.42.1 - 0.42.5）：**修复了以下上游安全问题：CVE-2024-43601。还修复了一些Composer错误和光标选项卡错误。允许Composer自动应用不在其上下文中的文件。还包括对CVE-2024-48919的额外缓解措施。减少了一些长尾连接错误。当Claude在聊天中预测错误的文件路径时添加逃生舱口。
+
+**2024年9月17日**
+
+## **0.41 - 光标选项卡Python自动导入，Composer改进，远程SSH到Mac支持**
+
+光标选项卡现在可以自动导入Python文件中的符号！还显着提高了光标选项卡的稳定性。
+
+Composer便笺簿（以前称项目）现在可以包含标记文件并在聊天和Composer中引用。
+
+Composer现可添加到AI窗格中。此版本还包括许多稳定性修复和图像支持！
+
+应用和Composer速度更快。
+
+添加了对通过远程SSH在Mac上使用光标的支持。
+
+**更新（0.41.1 - 0.41.3）：**改进入门用户体验，修复Composer取消错误，修复某些代码块上的应用按钮不起作用，并修复光标选项卡看到格式错误的编辑的错误。
+
+**2024年8月22日**
+
+## **0.40 - 新的聊天UX，默认开启的Composer，新的光标选项卡模型**
+
+我们有一个新的聊天UX！期待您尝试并分享您的想法。
+
+Composer现默认开启，所有Pro/Business用户都可点击cmd+I使用。添加了Composer项目（测试版），允许在多个Composer之间共享指令。
+
+还训练了一个更智能、更上下文感知的新光标选项卡模型。
+
+TypeScript文件的自动导入（测试版） - 当Tab建议未导入的符号时，我们现在将自动将其导入到当前文件中。您可以在“设置”>“功能”>“光标选项卡”中启用它！
+
+**更新（0.40.1 - 0.40.4）：**修复了远程SSH上的应用错误、一些聊天错误、加快了欧洲/亚洲用户的光标选项卡速度、修复了一些未解决的光标选项卡错误和隐藏聊天输入的通知，并包括一个修复光标询问权限的文件在MacOS上的~/Library文件夹中（上游问题：microsoft/vscode#208105）
+
+**2024年8月2日**
+
+## **0.39 - 更快的光标选项卡，更多Composer改进**
+
+光标选项卡（以前称为Copilot++）默认为分块流式传输。此版本还包括几个光标选项卡加速。未来版本会有更多！
+
+并发Composer支持、Composer控制面板和各种错误修复，例如接受的文件被删除。
+
+![](https://changelog.cursor.sh/_next/image?url=%2F_next%2Fstatic%2Fmedia%2Ffast-cursor-tab.9d7bc1b7.gif&w=1200&q=75)
+
+更快的光标选项卡建议！
+
+**更新（0.39.1 - 0.39.6）：**修复了几个光标选项卡渲染错误、文件资源管理器无响应的错误以及光标选项卡挂起的错误。
+
+**2024年7月23日**
+
+## **0.38 - Copilot++分块流式传输（测试版），Composer改进**
+
+Copilot++现具有分块流式传输（测试阶段）！它以更小的块更快地显示编辑。要启用它，单击设置齿轮并在“功能”>“Copilot++”下启用“分块流式传输”。
+
+还为Composer添加文件选择器、箭头键导航和模型切换。
+
+现在基于VS Code 1.91.1。
+
+新默认模型：Claude 3.5 Sonnet置为默认模型。
+
+**更新（0.38.1）：**修复了OpenAI API Key用户将迁移到Claude 3.5 Sonnet的错误
+
+**2024年7月13日**
+
+## **0.37 - Composer（测试版）**
+
+新的实验性多文件编辑功能。要启用它，单击设置齿轮，转到Beta，并激活“Composer”。要使用它，请按Cmd+I。
+
+**2024年7月3日**
+
+## **0.36 - 即时应用，文档管理**
+
+当聊天建议代码块时，单击“应用”可立即查看对文件的更改（仅限足够小的文件）。
+
+文档管理！转到光标设置>功能>文档重新索引您的文档。
+
+使用您自己的API密钥进行Claude时的错误修复。
+
+**更新（0.36.1-0.36.2）：**修复#1526，macOS x64设备上的cmd-shift-F。还修复了官方文档需要很长时间才能显示，以及cmd-K粘性存在错误。
+
+**2024年6月8日**
+
+## **0.35 - 默认开启的光标预测，远程隧道和更强大的SSH**
+
+- 默认开启的光标预测，带全新UI
+- 现在支持远程隧道！远程SSH支持也更加强大（现在支持多个代理跳转等）。
+- 为聊天消息添加了上下文提示，以便您可以查看将要使用/已使用的内容
+- 改进了Cmd K上下文构建
+- 修复了Windows/Linux上Copilot++的部分补全
+- **更新（0.35.1）**：默认情况下禁用Copilot++部分接受，并使按键绑定可配置（转到光标设置>功能>Cpp重新启用）。使gpt-4o成为默认模型。
+
+**2024年5月26日**
+
+## 0.34 - VS Code 1.89，新的预测UI，Gemini 1.5 Flash，Copilot++部分补全
+
+- 将VS Code 1.89合并到Cursor
+- 新的光标预测UI
+- Gemini 1.5 Flash可在长上下文模式下使用
+- 接受Copilot++的部分补全
+- 提高了Copilot++在linter错误上的性能
+- 可切换的代码库搜索重新排序器
+- 解释器模式下的GPT-4o
+- **更新（0.34.1-0.34.6）：**修复了模型切换中的长上下文模型、空的人工智能评论选项卡、Copilot++预览错误、Mac图标大小和远程SSH修复。
+
+**2024年5月3日**
+
+## **0.33 - 网络稳定性，Command-K自动选择**
+
+- 稳定性：此版本修复了一个持续影响某些用户连接错误的问题。它还应该提高Cursor在不稳定网络上的性能。
+- Command-K自动选择：我们还添加了Command-K的自动选择！这意味着您现在可以按Command-K，它将自动选择您正在处理的区域，但您仍然可以手动选择，如果您愿意。
+- **更新（0.33.1-0.33.3）：**修复设置切换，修复Copilot++ diffbox性能，入门调整。
+
+**2024年4月12日**
+
+## **0.32 - 改进的Copilot++ UX，新的GPT-4模型**
+
+- Copilot++ UX：建议预览现在具有语法高亮显示，我们发现这使得快速理解更改变得更加容易。
+- 光标帮助面板（测试版）：您还可以向Cursor询问有关Cursor的问题！光标帮助面板包含有关功能、键盘快捷键等的的信息。您可以在“设置”>“Beta”中启用它。
+- 新的GPT-4模型：从几天前开始，您可以在Cursor中尝试gpt-4-turbo-2024-04-09，方法是在“设置”>“模型”中将其打开。
+- .cursorrules：您可以通过在存储库的根目录中创建.cursorrules文件来为AI编写仓库级规则。您可以使用它来提供有关您正在构建的内容、样式指南或常用方法信息的上下文。
+- **更新（0.32.1-0.32.7）：**修复了新的Copilot++语法高亮显示的性能问题，将AI Notes默认设置为禁用，将主要Copilot++模型的名称更改为legacy，修复了Copilot++在SSH上变慢的问题，修复了Copilot++预览框。
+
+[2024年4月1日](https://changelog.cursor.sh/#031---长上下文聊天测试版)
+
+## [0.31 - 长上下文聊天测试版](https://changelog.cursor.sh/#031---长上下文聊天测试版)
+
+- 长上下文聊天（测试版）：这是一个新的实验性功能，可以让你与*大量*文件进行交互！要启用它，请转到"设置">"测试版"。然后，在新聊天的右上角选择"长上下文聊天"，并尝试@一个文件夹或整个代码库。
+- 修复：此版本修复了在聊天中显示空白/部分响应的错误。
+
+更新（0.31.1 - 0.31.3）：重新添加AI审查（alpha）、修复"Cursor设置"菜单项，并修复@web无法返回响应的错误。
+
+[2024年3月20日](https://changelog.cursor.sh/#030---更快的代码助手++)
+
+## [0.30 - 更快的代码助手++，Claude](https://changelog.cursor.sh/#030---更快的代码助手++)
+
+- 更快的代码助手++：我们使代码助手++速度提高了约2倍！这一速度提升来自新模型/更快的推理。约50%的用户已经使用这个模型，并将在几天内全面推广。如果你想立即启用该模型，可以在编辑器底部栏控制你的模型。
+- 稳定的Claude支持：所有最新的Claude模型现在可供专业版和API密钥用户使用。前往"设置">"模型"打开它们。专业用户每天免费获得10次请求，并可以继续使用API密钥价格使用Claude。
+- 团队邀请：我们让邀请同事加入Cursor团队变得更加容易。你可以从编辑器设置或在[cursor.com/settings](https://cursor.com/settings)发送邀请。
+- 管理员改进：团队管理员现在可以将自己标记为未付费用户，并可以查看团队成员上次使用产品的时间。
+- 新设置：我们将所有设置移至右上角的齿轮中。不再有"更多"选项卡！
+
+[2024年3月12日](https://changelog.cursor.sh/#claude支持)
+
+## [Claude支持](https://changelog.cursor.sh/#claude支持)
+
+如果你是专业版或商业版用户，可以在设置页面添加"claude-3-opus"作为自定义模型，每天免费使用10次快速请求（无限制慢速请求，但延迟呈指数增长）。
+
+我们预计很快会推出更永久的解决方案（包括API密钥用户）。
+
+[2024年3月1日](https://changelog.cursor.sh/#029---优化)
+
+## [0.29 - 优化](https://changelog.cursor.sh/#029---优化)
+
+默认启用AI笔记（在任何符号上按住Shift），改进编辑器内聊天，自动执行解释器模式，更好的入门样式，更好看的反馈模态，以及一些稳定性修复。
+
+更新（0.29.1）：修复了代码助手++有时即使存在建议也不显示的问题，修复了提示行有时会覆盖幽灵文本的问题，以及修复了AI笔记在Windows上无法工作的问题。
+
+[2024年2月23日](https://changelog.cursor.sh/#028---vs-code-1862)
+
+## [0.28 - VS Code 1.86.2](https://changelog.cursor.sh/#028---vs-code-1862)
+
+Cursor现在基于VS Code 1.86.2！除其他外，这为树视图添加了粘性滚动支持。此外，cmdk提示栏现在是粘性的。
+
+更新（0.28.1）：修复了代码库聊天的间距问题，修复了[getcursor/cursor#1236](https://github.com/getcursor/cursor/issues/1236)。
+
+[2024年2月15日](https://changelog.cursor.sh/#027---代码检查器-解释器模式更新)
+
+## [0.27 - 代码检查器、解释器模式更新](https://changelog.cursor.sh/#027---代码检查器-解释器模式更新)
+
+两个新的实验性功能更新：
+
+- 代码检查器：你现在可以在聊天旁边的"更多"选项卡中打开AI代码检查器。每次保存时，它会扫描你的文件中的小错误。
+- 解释器模式：我们对支持解释器模式的后端进行了重大改进！它现在在使用工具和理解项目方面应该更好。
+
+更新（0.27.1-0.27.4）：修复Windows构建、聊天上下文UI、入门问题。
+
+[2024年2月9日](https://changelog.cursor.sh/#026---ai预览测试版)
+
+## [0.26 - AI预览测试版](https://changelog.cursor.sh/#026---ai预览测试版)
+
+AI预览：这是一个新的实验性代码阅读功能。在聊天旁边的"更多"选项卡中启用后，只需按住Shift键即可为你所在的符号生成一些快速笔记。如果你希望我们在这个方向上投入更多时间，请[告诉我们](https://forum.cursor.com/)。
+
+其他变化：
+
+- 细粒度聊天回复（开始方法是悬停在要回复的响应区域上）
+- 代码助手++生活质量改进（更频繁地显示幽灵文本，在状态栏上切换开/关，更容易查看建议框）
+- 更顺畅的入门（修复Windows设置导入，选择导入文件夹/窗口状态）
+
+[2024年2月2日](https://changelog.cursor.sh/#025---command-k-视觉支持)
+
+## [0.25 - Command-K视觉支持](https://changelog.cursor.sh/#025---command-k-视觉支持)
+
+现在你可以将图像拖放到Command-K提示栏中！
+
+其他变化：
+
+- 你现在可以搜索过去的聊天记录。
+- 聊天中的"应用差异"现在应该更快一些。
+
+更新：
+
+- 0.25.2：代码助手++性能改进
+- 0.25.3：修复cmd-K错误：[getcursor/cursor#1226](https://github.com/getcursor/cursor/issues/1226)。
+
+[2024年1月25日](https://changelog.cursor.sh/#024---web-gpt-4-0125-preview)
+
+## [0.24 - @Web、gpt-4-0125-preview](https://changelog.cursor.sh/#024---web-gpt-4-0125-preview)
+
+在聊天中使用@Web将赋予AI抓取网页的能力！它可以使用的工具包括搜索引擎和文档网站爬虫。
+
+这个功能仍处于实验阶段。我们非常希望改进AI理解外部库的能力，欢迎你的[意见](https://forum.cursor.com/)帮助我们改进：）。
+
+专业版和API密钥用户还可以通过"设置">"OpenAI API">"配置模型"来尝试gpt-4-0125-preview。我们正在为专业用户测试这个新模型，看它是否比所有旧版本的gpt-4表现更好。如果是，将作为默认体验推出。
+
+更新（0.24.3-0.24.4）：添加配置OpenAI基础URL的能力，修复[getcursor/cursor#1202](https://github.com/getcursor/cursor/issues/1202)。
+
+[2024年1月18日]
+
+## [0.23 - 新模型、应用按钮 v2]
+
+- "cursor-fast"：这是一个在command-k和聊天中可用的新模型。预计比gpt-3.5更智能，格式错误更少。
+- 应用按钮：我们为聊天中的"应用代码块"体验添加了一些改进。
+- 聊天代码检查：如果AI在聊天中建议涉及虚构代码符号的代码更改，我们将对其进行下划线标注。适用于Python、TypeScript、Rust。
+- 更多聊天符号链接：当聊天引用`代码符号`时，你通常可以直接点击到它。
+
+更新（0.23.3-0.23.9）：修复Command-K、更新日志自动打开、使用代码助手++编辑非常长的行、"删除索引"按钮、连接错误被隐藏以及代理认证。
+
+[2024年1月6日](https://changelog.cursor.sh/#0220---开发容器)
+
+## [0.22.0 - 开发容器](https://changelog.cursor.sh/#0220---开发容器)
+
+现在支持开发容器！此版本还：
+
+- 将Cursor升级到VS Code 1.85，支持将选项卡拖出到新窗口。
+- 改进WSL的稳定性。
+
+[2023年12月29日](https://changelog.cursor.sh/#0210---多个command-k-代码助手ui)
+
+## [0.21.0 - 多个Command-K、代码助手++UI](https://changelog.cursor.sh/#0210---多个command-k-代码助手ui)
+
+现在你可以并行运行多个Command-K！此外，现在更容易查看代码助手++建议的更改。
+
+[2023年12月16日](https://changelog.cursor.sh/#0200---代码助手-预览-ai审查)
+
+## [0.20.0 - 代码助手++、@预览、AI审查](https://changelog.cursor.sh/#0200---代码助手-预览-ai审查)
+
+- @预览：我们让查看你所@的代码块变得更容易。
+- 代码助手++：我们继续改进代码助手++幽灵文本体验。令人惊讶的是，我们中的许多人现在甚至不安装其他自动完成插件就享受使用代码助手++。
+- AI审查（测试版）：这是一个新的实验性功能，让GPT-4扫描你的git差异或PR中的错误。你可以在聊天旁边的"更多"选项卡中启用它。非常感谢你的[反馈](https://forum.cursor.com/)。
+
+更新（0.20.1-0.20.2）：我们添加了摘要，以便更容易整理AI审查标记的错误，并修复了"与主分支比较"的错误。
+
+[2023年12月14日](https://changelog.cursor.sh/#0191---解释器模式windows错误)
+
+## [0.19.1 - 解释器模式Windows错误](https://changelog.cursor.sh/#0191---解释器模式windows错误)
+
+修复解释器模式中的CRLF错误：https://github.com/getcursor/cursor/issues/1131。
+
+[2023年12月14日](https://changelog.cursor.sh/#0190---代码助手改进)
+
+## [0.19.0 - 代码助手++改进](https://changelog.cursor.sh/#0190---代码助手改进)
+
+我们使代码助手++更快、更智能、更受限，并切换到幽灵文本+按Tab接受的UI。我们很想听听你的反馈。
+
+[2023年12月6日](https://changelog.cursor.sh/#0184-0185---入门-反馈)
+
+## [0.18.4-0.18.5 - 入门和反馈](https://changelog.cursor.sh/#0184-0185---入门-反馈)
+
+轻微的入门变更。允许用户对聊天响应提供反馈。
+
+[2023年12月2日](https://changelog.cursor.sh/#0182---小写-文件夹修复)
+
+## [0.18.2 - 小写@文件夹修复](https://changelog.cursor.sh/#0182---小写-文件夹修复)
+
+修复在聊天中使用@文件夹时所有文件夹被切换为小写的错误。
+
+[2023年11月30日](https://changelog.cursor.sh/#0180---更好的上下文聊天-更快的代码助手)
+
+## [0.18.0 - 更好的上下文聊天、更快的代码助手++](https://changelog.cursor.sh/#0180---更好的上下文聊天-更快的代码助手)
+
+1. 更好的上下文聊天：特别是，后续对话现在更智能！
+2. 更快的代码助手++：通过各种网络优化，速度提高了几百毫秒。我们仍有几百毫秒的优化空间。
+3. 更可靠的代码助手++更改：闪烁更少，更好地突出显示新内容。
+
+[Nov 27, 2023](https://changelog.cursor.sh/#0170---image-support-interpreter-mode-beta--folders)
+
+## [0.17.0 - 图像支持、解释器模式测试版、@ 文件夹](https://changelog.cursor.sh/#0170---image-support-interpreter-mode-beta--folders)
+
+- **聊天中的图像支持**: 您现在可以拖放图像到聊天中发送给 AI。
+- **解释器模式测试版**: 现在可以在“更多”选项卡中启用解释器模式。此功能为聊天提供了访问 Python 笔记本、语义搜索等工具的能力。
+- **@ 文件夹**: 现在您可以使用 @ 符号引用特定文件夹！我们会尝试挑选出最相关的代码片段供 AI 查看。
+- **Copilot++ 改进**: 我们优化了 Copilot++ 的延迟，并增加了更改 Copilot++ 快捷键（不再固定为 Option/Alt）的选项。未来会有更多改进，尤其是在模型本身的性能方面！
+
+[2023 年 11 月 15 日](https://changelog.cursor.sh/#0160---copilot-improvements-and-vs-code-1842)
+
+## [0.16.0 - Copilot++ 改进和 VS Code 1.84.2](https://changelog.cursor.sh/#0160---copilot-improvements-and-vs-code-1842)
+
+**Copilot++ 改进**:
+
+1. **缓存功能**: 添加或删除一个字母，建议仍然会保留！
+2. **不干扰智能感知和 CMD-K**。
+3. 修复了处理大型文件时的延迟问题，以及蓝色高亮残留的问题。
+4. Copilot++ 可以识别 Lint 错误，并利用这些信息改进建议。
+
+Cursor 现在基于 VS Code 1.84.2，此版本修复了几个笔记本相关的 bug，并确保所有最新扩展能够正常工作。
+
+[2023 年 11 月 12 日](https://changelog.cursor.sh/#0152-0155---copilot-improvements-bug-fixes)
+
+## [0.15.2-0.15.5 - Copilot++ 改进及 Bug 修复](https://changelog.cursor.sh/#0152-0155---copilot-improvements-bug-fixes)
+
+- **Copilot++ 改进**: 包括绿色高亮显示 Copilot++ 添加的内容、可以连续接受多个 Copilot++ 建议、支持 SSH 上的 Copilot++，以及修复了 Copilot++ UI 与自动完成插件交互的问题。
+- **Bug 修复**: 修复了当在文件顶部删除内容时 CMD-K 会进入异常状态的 bug；修复了导致某些文件未被索引的问题。
+
+[2023 年 11 月 10 日](https://changelog.cursor.sh/#0150-0151---new-models-copilot-beta)
+
+## [0.15.0-0.15.1 - 新模型和 Copilot++ 测试版](https://changelog.cursor.sh/#0150-0151---new-models-copilot-beta)
+
+- **Command-dot 功能**: 现在可以使用 Command-dot 菜单，让 Command-K 内联
+
+修复 Lint 错误。
+
+- **新模型**: 您可以插入 API 密钥，尝试最新的 GPT-4 和 GPT-3 Turbo 模型。我们正在评估这些模型的编码能力，计划向专业用户推出。
+- **应用聊天建议**: 点击任意代码块上的播放按钮，即可让 AI 将聊天建议应用到当前文件中。
+- **Copilot++ 测试版**: 这是 Copilot 的一个附加功能，根据您最近的编辑建议光标周围的差异。在右侧聊天栏的“更多”选项卡中启用。注意：为覆盖 AI 成本，仅对专业用户开放。
+  - 此功能非常实验性，请不要抱太高期望！[您的反馈](https://forum.cursor.com/) 将决定我们未来的方向。
+
+[2023年11月9日]
+
+## [0.14.1 - 索引修复]
+
+修复了索引卡住的问题。索引容量现在按用户分配，因此对大多数用户来说应该更公平且更快。
+
+[2023年11月3日]
+
+## [0.14.0 - Pro++、单词换行差异等]
+
+- Pro++计划：如果达到快速请求限制，现在可以购买更多。
+- 聊天滚动：取消了粘性滚动，使聊天更易于阅读。
+- Cmd-K差异：现在遵循单词换行！可以从红色文本复制。
+- 修复了无法在差异视图中使用聊天的错误。
+- 改进了错误日志记录，有助于提高稳定性。
+- 样式调整：一些按钮和提示看起来更好看！
+- 屏幕闪烁：进行了可减少显示器屏幕闪烁的更改。
+
+[2023年10月20日]
+
+## [0.13.0-0.13.4 - 新的VS Code版本]
+
+Cursor现在基于VS Code 1.83.1。这确保了所有扩展的最新版本可以在Cursor中无问题地工作。感谢每个人在论坛上敦促我们这样做！
+
+还有一个实验性的Bash模式：在设置中启用，让聊天在运行Bash命令的帮助下回答问题。如果您觉得它有用，请告诉我们，我们将花更多时间使其成为生产就绪版本！
+
+更新：此更改导致了SSH连接到旧Linux发行版的问题。现在已修复！
+
+[2023年10月5日]
+
+## [0.12.1-0.12.3 - 小修复]
+
+修复了以下错误：
+(1) .cursorignore现在完全尊重.gitignore语法
+(2) 如果索引达到80%，代码库查询将使用嵌入式索引
+(3) 移除了启动时的淡入动画
+(4) 不再在终端中覆盖cmd-delete
+(5) 修复cmd-F随机启用区分大小写选项的问题
+(6) 内联gpt-4在我们找到更好的用户体验之前被关闭
+(7) 索引更加稳定和快速
+(8) 搜索和扩展中的进度指示器
+(9) 修复了向服务器传递不正确的bearer令牌的错误
+
+[2023年10月1日]
+
+## [0.12.0 - 索引、终端中的cmd-k、@git、/edit、错误修复]
+
+1. 索引现在应该更快、更稳定，并使用更少的系统资源。您还可以在`.cursorignore`中配置忽略的文件。控件位于"更多"选项卡中。
+2. 终端中现在可以使用Cmd-k！虽然实现有点粗糙，但出奇地有用。
+3. 在聊天中使用@git询问git提交和PR！
+4. 在聊天中使用/edit编辑整个文件（如果少于400行）。预计编辑速度快，质量达到GPT-4水平。这使用非公开模型，目前仅对未使用自己API密钥的用户可用。
+5. 错误修复！修复了"从慢速模式中退出"的UI，添加了API切换时的模型类型自动切换逻辑，改进了@符号速度，修复了Windows按键命令为Ctrl-Shift-Y而不是Ctrl-Y，等等。
+
+[2023年9月20日]
+
+## [0.11.1-0.11.8 - 补丁]
+
+修复了Cmd-k、SSH、Python支持、Vim（回退到1.25.2版本，直到此问题得到解决：https://github.com/VSCodeVim/Vim/issues/8603）和其他扩展的问题。
+
+[2023年9月19日]
+
+## [0.11.0 - 内联聊天]
+
+现在您可以在Cmd-K中在差异和文本响应之间切换。这有助于阐明模型对差异的思考过程，或快速获取关于文件的内联答案。
+
+[2023年9月10日]
+
+## [0.10.4 - 修复内置游标Python默认值]
+
+游标Python的默认值与Pylance不同，这影响了多个用户。在此更新中，我们使它们更接近Pylance的默认值。
+
+[2023年9月9日]
+
+## [0.10.2 - 0.10.3 - 减少扩展推荐]
+
+修复了一些用户过于频繁收到扩展弹出推荐的问题。
+
+[2023年9月8日]
+
+## [0.10.1 - 样式]
+
+更新了一些CSS！
+
+## [0.10.0 - 更好的文档管理、分阶段推出]
+
+### 文档
+
+此更新的主要添加是更好的文档支持。这意味着您可以添加和删除文档，并检查实际使用的URL。您还可以查看最终展示给GPT-4的网页，以便为您提供答案。
+
+您可以将URL粘贴到聊天中，模型将自动将其包含在使用的上下文中。团队还可以共享私人文档。
+
+### 分阶段推出
+
+继此更新之后，未来的更新应采用分阶段推出。这将意味着更高的稳定性保证和更频繁的更新。
+
+### 聊天中的长文件
+
+我们继续改进与大文件聊天的体验。如果您@多个太大而无法放入GPT-4上下文窗口的文件，我们将智能地选择最相关的代码块向模型展示。
+
+### 错误修复：
+
+- 从Jupyter复制粘贴聊天文本
+- 一些聊天焦点问题
+- UI调整
+- 更好的状态管理 - 防止编辑器使用过多内存导致崩溃
+
+[2023年9月7日]
+
+## [0.9.5 - 索引热修复]
+
+修复了如果您默认关闭索引时出现的索引错误。
+
+[2023年9月5日]
+
+## [0.9.4 - 修复Cmd-K意外输出反引号]
+
+Cmd-K在使用`@file`时将不再输出反引号。
+
+[2023年9月1日]
+
+## [0.9.3 - GitHub认证热修复]
+
+您现在应该可以再次使用GitHub登录。
+
+[2023年8月31日]
+
+## [0.9.2 - 大型持久状态热修复]
+
+可能导致 https://github.com/getcursor/cursor/issues/843 问题。
+
+[2023年8月30日]
+
+## [0.9.1 - SSH热修复]
+
+修复SSH问题的热修复。
+
+## [0.9.0 - 可审核的代码库上下文、VS Code左侧栏]
+
+- 您现在可以切换到VS Code侧边栏方向
+- 对于"带代码库"的聊天，您现在可以查看Cursor向GPT-4展示的代码库上下文。我们希望这将使提示代码库答案更容易
+- API密钥输入框现在是密码类型
+- 修复了在关闭索引选项后立即对代码进行索引的错误
+- 新图标！非常感谢出色的Atanas Mahony制作这个图标
+
+[2023年8月27日]
+
+## [0.8.6 - 设置中的电子邮件]
+
+Cursor设置中注销按钮下的电子邮件未更新。
+
+[2023年8月26日]
+
+## [0.8.5 - 高级按钮]
+
+使高级上下文按钮在非Git仓库中也显示。
+
+[2023年8月22日]
+
+## [0.8.4 - WSL修复]
+
+在所有WSL（Windows子系统Linux）发行版中应用了来自Github的补丁，可以自动或通过"修复WSL"命令面板命令进行。
+
+## [0.8.3 - 代码库索引控制]
+
+修复了代码库索引控制被不经意间移除的错误。
+
+## [0.8.2 - Cmd-k后续、大文件聊天等]
+
+- 现在可以回复Cmd-K输出，使模型修改其工作变得更加容易
+- 如果@引用一个将被上下文限制截断的长文件，您将可以选择自动分块文件并用多个GPT进行扫描
+- "带代码库"响应中的代码块和代码符号现在通常可点击
+- 对"带代码库"的后续聊天消息将保留代码库上下文
+- 聊天中的错误消息更加友好！减少烦人的弹出窗口
+- 活动栏元素现在可以通过拖放重新排序
+- SSH支持现在更加健壮！请继续告诉我们是否仍遇到任何SSH问题
+
+2023年8月15日
+
+## **0.7.3 - 修复 Windows 上的 cursor 命令**
+
+修复了在 Windows 上安装 `cursor` 命令的错误。
+
+2023年8月11日
+
+## **0.7.2 & 0.7.6-nightly - 修复大文件的 cmd-k 生成**
+
+不再使用认知计算！
+
+2023年8月10日
+**0.7.1 & 0.7.5-nightly - 修复：光标位置错误**
+
+1. 修复 https://github.com/getcursor/cursor/issues/711。
+2. 修复 cmd-k 连接错误。
+3. 修复空行的 cmd-k 快速模式 bug。
+4. 修复 bm25 搜索无限加载。
+5. 修复后续操作中的 @Codebase。
+
+2023年8月10日
+
+## **0.7.0 - 编辑器内聊天**
+
+对于不想侧边栏聊天的用户，现在可以将聊天窗口弹出到编辑器中！我们还修复了许多 bug。
+
+2023年7月28日
+
+## **0.6.0 - 由 GPT-4 驱动的 Copilot 体验**
+
+**长 AI 补全**
+当你在任意行按下 ⌘/^+↩️ 时，现在将使用 GPT-4 为你提供快速补全！我们知道有时候我们都希望 Copilot 能够编写整个函数或大段代码。但 Copilot 可能会很慢，有时也不够智能 :(。因此我们尝试通过一种由 GPT-4 提供支持的新补全体验来解决这个问题。只需按下 ⌘/^+↩️，你就能获得来自 GPT-4 的长补全。
+
+**更好地支持远程 SSH**
+远程 SSH 现已内置于 Cursor。你无需修改行为，它应该可以直接工作 :) 我们知道这曾是许多依赖远程机器进行开发的用户的一大障碍。如果你仍遇到问题，请告诉我们，我们将尽快修复。
+
+**AI 代码检查器**
+AI 代码检查器现已对所有专业版用户开放！AI 将用蓝色突出显示代码中可疑的部分。你还可以添加自己想要的代码检查规则，这些规则很容易用自然语言表达，但传统代码检查器无法覆盖。
+
+2023年7月28日
+**0.5.1 - 性能热修复**
+修复了频繁使用 cmd-k 时可能出现的性能问题。
+
+Jul 27, 2023
+
+## 0.5.0 - 企业订阅支持及杂项修复
+
+1. 企业支持！
+2. 恢复了 Qmd 支持。
+3. 聊天中新增实验性 @Codebase 支持（即将在 cmd-k 中推出！）
+4. Linter 功能回归
+
+## [0.4.0 - “适用于所有代码库的 with codebase”！]
+
+现在您可以与任何代码库进行聊天。无需拥有 Github 仓库或通过 Github 登录。
+
+[2023 年 7 月 22 日](https://changelog.cursor.sh/#031---jupyter-cmd-k-context-building)
+
+## [0.3.1 - Jupyter CMD-k 上下文构建](https://changelog.cursor.sh/#031---jupyter-cmd-k-context-building)
+
+Cmd-K 现在可以再次查看您在 Jupyter 中的所有单元格！
+
+[2023 年 7 月 21 日](https://changelog.cursor.sh/#030---ssh-and-wsl-fixes)
+
+## [0.3.0 - SSH 和 WSL 修复](https://changelog.cursor.sh/#030---ssh-and-wsl-fixes)
+
+- SSH 和 WSL 应该可以再次正常工作。
+- 在新窗口屏幕上可以看到最近的文件夹。
+- 带有代码库上下文的聊天中出现的空消息不再无限加载。
+
+## [0.2.50 - 热修复](https://changelog.cursor.sh/#0250---hotfixes)
+
+- Cmd-L 现在可以正确聚焦到聊天中。
+- 高级上下文控件只有在您已索引代码库时才会显示。
+
+[2023 年 7 月 19 日]
+
+## [0.2.49 - 适用于代码库范围聊天的高级上下文]
+
+此版本包括：
+
+- 对代码库范围聊天的上下文构建能力提供更多控制。
+- 改进了 CMD-k 的代码生成流程，确保无 Linter 错误（在相关情况下，您将看到“尝试修复 Linter 错误”按钮）。
+- CMD-K 的一些 UI/UX 调整。
+- Bug 修复。
+
+[2023 年 7 月 15 日](https://changelog.cursor.sh/#0248---infinite-chat-loop-hotfix)
+
+## [0.2.48 - 无限聊天循环热修复](https://changelog.cursor.sh/#0248---infinite-chat-loop-hotfix)
+
+此更新修复了聊天窗格中的无限循环 bug。
+
+[2023 年 7 月 12 日](https://changelog.cursor.sh/#0247---patch-for-wslssh-search-and-extensions)
+
+## [0.2.47 - WSL/SSH 的搜索和扩展补丁](https://changelog.cursor.sh/#0247---patch-for-wslssh-search-and-extensions)
+
+此更新修复了 WSL 和 SSH 用户的搜索（Cmd/Win+Shift+F）及许多扩展的问题。
+
+[2023 年 7 月 11 日](https://changelog.cursor.sh/#0246---patch-for-cmd-k-generates)
+
+## [0.2.46 - CMD-k 生成的补丁](https://changelog.cursor.sh/#0246---patch-for-cmd-k-generates)
+
+此更新改进了 CMD-k 在未选择任何代码时的提示。
+
+[2023 年 7 月 10 日](https://changelog.cursor.sh/#0245---arm-windows-cmd-shift-f)
+
+## [0.2.45 - ARM Windows 的 Cmd-Shift-F](https://changelog.cursor.sh/#0245---arm-windows-cmd-shift-f)
+
+此更新为 ARM Windows 计算机提供了 Ctrl+Shift+F 的乐观修复。
+
+[2023 年 7 月 7 日](https://changelog.cursor.sh/#0244---improvements-to-many-features-fixes-to-python)
+
+## [0.2.44 - 多项功能改进，修复 Python](https://changelog.cursor.sh/#0244---improvements-to-many-features-fixes-to-python)
+
+- 改进了“@添加新文档”体验。
+- 恢复了对 Python/Pylance 的支持。
+- 改善了 @ 符号的键盘使用体验。
+- 更清晰地显示 AI 正在查看哪些文档。
+- 当您引用文档时，AI 会附带引用响应。
+- 修复了 Jupyter 的 Cmd-K。
+- 聊天/编辑工具提示更少遮挡代码。
+- 改进了在自定义主题开启时 Cursor 的外观。
+- 导入 VS Code 扩展时现在会考虑已启用/禁用的扩展。
+- CMD-k 对长差异（超过 100 行代码）的支持更好。
+
+## [0.2.43 - CMD+K 修复](https://changelog.cursor.sh/#0243---fix-for-cmdk)
+
+修复了 CMD+K 的一些边缘案例。
+
+[2023 年 7 月 4 日](https://changelog.cursor.sh/#0242---fix-for-cmdshiftf-mac-arm)
+
+## [0.2.42 - CMD+Shift+F (Mac ARM) 修复](https://changelog.cursor.sh/#0242---fix-for-cmdshiftf-mac-arm)
+
+修复了针对未安装 Rosetta 的 Mac ARM 用户的 VS Code 代码库范围搜索。
+
+[2023 年 7 月 4 日]
+
+## [0.2.41 - “with codebase” 功能热修复]
+
+修复了聊天中 “with codebase” 功能的问题。
+
+[2023 年 7 月 4 日](https://changelog.cursor.sh/#0240---release-for-linux)
+
+## [0.2.40 - Linux 版本发布](https://changelog.cursor.sh/#0240---release-for-linux)
+
+此版本对 Mac 和 Windows 无任何更改，但修复了 Linux 用户的问题，现在他们可以升级到最新版本。
+
+[2023 年 7 月 3 日](https://changelog.cursor.sh/#0239---new-inline-edits)
+
+## [0.2.39 - 新的内联编辑](https://changelog.cursor.sh/#0239---new-inline-edits)
+
+CMD+K 的 UI 已更改：它现在是编辑器内的，“粘滞的”，并且兼容 @ 符号。我们希望这可以帮助您保持工作流顺畅，更快地对提示进行迭代。（此外，现在可以在聊天中使用上下箭头来查看历史记录。）
+
+此外，Cursor 的 AI 现在将使用流行的文档来改善回答。例如，如果您询问“如何使用 boto3 获取所有 S3 存储桶？” 它将搜索 boto3 文档以找到答案。要添加自己的文档或显式引用现有文档，请在聊天中键入 '@library_name'。
+
+### Bug 修复：
+
+1. 长代码选择不会再导致编辑器崩溃。
+2. 自动修复错误不会再弹出问题视图（特别是修复了当启用“保存时自动修复”时的一个烦人 bug）。
+
+[2023 年 6 月 27 日](https://changelog.cursor.sh/#0237---more-fixes)
+
+## [0.2.37 - 更多修复](https://changelog.cursor.sh/#0237---more-fixes)
+
+- 改善了 @ 符号的键盘使用体验。
+- 修复了 CMD+K 对某些用户失效的 bug。
+- 改善了对扩展的支持（特别是重新启用了欢迎视图）。
+
+[2023 年 6 月 27 日](https://changelog.cursor.sh/#0236---hotfixes)
+
+## [0.2.36 - 热修复](https://changelog.cursor.sh/#0236---hotfixes)
+
+1. 如果您没有打开文件夹，聊天功能现在可以再次工作。
+2. CMD-Shift-E 再次可以在聊天中修复错误。
+3. `cursor://` 深层链接现在有效，因此您应该可以登录扩展了。
+4. 自动滚动功能再次有效。
+5. 修复了几个内联差异的 CMD-Z bug。
+6. 您现在可以在 Cursor 中再次使用运行和调试功能（工具栏回来了）。
+7. 早期支持斜线命令。
+8. 如果您未登录，我们将再次显示登录弹窗。
+9. Cursor 现在基于 VSCodium 1.79.2 版本，附带安全更新和一些小功能。
+
+## [0.2.35 - 聊天热修复](https://changelog.cursor.sh/#0235---hotfix-for-chat)
+
+修复了在某些非 Git 文件夹中聊天功能失效的问题。
+
+[2023 年 6 月 24 日](https://changelog.cursor.sh/#0234---chat-v2)
+
+## [0.2.34 - 聊天 v2](https://changelog.cursor.sh/#0234---chat-v2)
+
+聊天功能进行了全面升级！现在您可以使用 @ 符号向 AI 展示文件/代码/文档。聊天历史更清晰，更容易查看 AI 能看到的内容，并且代码块在粘贴时会自动格式化。
+
+[2023 年 6 月 16 日](https://changelog.cursor.sh/#0233---azure-support)
+
+## [0.2.33 - Azure 支持](https://changelog.cursor.sh/#0233---azure-support)
+
+我们新增了使用 Azure OpenAI 凭据的支持。同时还进行了小幅改进和修复。
+
+[2023 年 6 月 14 日](https://changelog.cursor.sh/#0232---small-improvements)
+
+## [0.2.32 - 小幅改进](https://changelog.cursor.sh/#0232---small-improvements)
+
+修复了上一个版本引入的保存时格式化问题，同时对 AI linter 和代码库范围聊天进行了小幅优化。
+
+[2023 年 6 月 11 日](https://changelog.cursor.sh/#0231---hotfix-for-chat-focus)
+
+## [0.2.31 - 聊天聚焦热修复](https://changelog.cursor.sh/#0231---hotfix-for-chat-focus)
+
+聊天功能现在不会再抢走您的焦点！
+
+[2023 年 6 月 9 日](https://changelog.cursor.sh/#0230---show-the-ai-documentation)
+
+## [0.2.30 - 显示 AI 文档](https://changelog.cursor.sh/#0230---show-the-ai-documentation)
+
+现在您可以让 AI 阅读文档，这将提高其回答有关您常用库问题的能力。使用此功能，只需点击聊天窗格右上角的“文档”按钮。
+
+[2023 年 6 月 6 日]
+
+## [0.2.28 & 0.2.29 - 代码库上下文修复]
+
+对代码库上下文 v1 的热修复。
+
+[2023 年 6 月 6 日]
+
+## [0.2.27 - 代码库上下文 v2]
+
+我们改进了代码库上下文功能！
+
+为充分利用此功能，请导航至设置（右上角按钮），然后选择“同步当前代码库”。
+
+通过 Github 登录后，添加您希望同步的仓库！
+
+完成后，您将在搜索窗格和聊天中（通过按 CMD+Enter）看到改进的代码库上下文版本。
+
+[2023 年 6 月 6 日]
+
+## [0.2.26 - 代码库上下文 v1]
+
+### 代码库上下文 v1
+
+推出第一个版本的代码库范围上下文！
+
+转到“搜索”窗格即可查看新上下文。或在聊天中按 CMD+Enter，即可获得使用完整代码库上下文的响应。
+
+![](https://changelog.cursor.sh/_next/image?url=%2F_next%2Fstatic%2Fmedia%2FcodebaseContext.d0caa93e.gif&w=3840&q=75)
+
+## [v0.2.25 - 扩展热修复（2023-06-03）](https://changelog.cursor.sh/#v0225---hot-fix-for-extensions-2023-06-03)
+
+还修复了许多人遇到的 Jupyter 问题。
+
+[2023 年 6 月 2 日](https://changelog.cursor.sh/#v0224---minor-fixes-2023-06-02)
+
+## [v0.2.24 - 小修复（2023-06-02）](https://changelog.cursor.sh/#v0224---minor-fixes-2023-06-02)
+
+修复了 Toolformer 和 AI linter 的一些小问题。
+
+[2023 年 6 月 1 日](https://changelog.cursor.sh/#v0223---ai-linting-2023-06-01)
+
+## [v0.2.23 - AI Linting（2023-06-01）](https://changelog.cursor.sh/#v0223---ai-linting-2023-06-01)
+
+在“更多”标签中，您可以让 GPT-3.5 或 GPT-4 定期检查代码中的问题。
+
+[2023 年 5 月 20 日](https://changelog.cursor.sh/#v0218---upgrades-to-gpt-4-and-please-give-us-feedback-2023-05-20)
+
+## [v0.2.18 - GPT-4 升级及反馈请求！！（2023-05-20）](https://changelog.cursor.sh/#v0218---upgrades-to-gpt-4-and-please-give-us-feedback-2023-05-20)
+
+### GPT-4 升级
+
+- 所有用户可免费获得 10 次 GPT-4 请求！！
+- 在模型间切换变得更加容易，GPT-4 的过渡更加顺畅。
+
+### 请提供反馈！！
+
+![img](https://changelog.cursor.sh/_next/image?url=%2F_next%2Fstatic%2Fmedia%2FfeedbackModal.9eb91dd1.png&w=640&q=75)
+
+- 添加了一个新反馈按钮，位于应用程序的右上角。
+- 我们非常重视您的反馈以及 bug 报告！过去几周我们已修复了许多问题，并将继续改进产品。
+- 我们还推出了新的反馈对话框以便于报告问题和建议。
+
+[2023 年 5 月 18 日](https://changelog.cursor.sh/#v0217---fixes-2023-05-018)
+
+## [v0.2.17 - 修复！（2023-05-18）](https://changelog.cursor.sh/#v0217---fixes-2023-05-018)
+
+### Bug 修复
+
+- 修复了“无限加载”问题。
+- 重新引入了“新 AI 项目”功能。
+
+[2023 年 5 月 17 日](https://changelog.cursor.sh/#v0216---terminal-debugger-and-our-biggest-bug-bash-yet-v0212)
+
+## [v0.2.16 - 终端调试器，以及最大规模 Bug 修复（2023-05-17）](https://changelog.cursor.sh/#v0216---terminal-debugger-and-our-biggest-bug-bash-yet-v0212)
+
+### 终端内调试
+
+- 按 CMD+D 自动调试终端错误。
+- 按 CMD+Shift+L，模型会将终端上下文添加到聊天中。
+
+### 活动栏固定
+
+- 您可以将自定义扩展固定到左上角的活动栏。
+
+  ![img](https://changelog.cursor.sh/_next/image?url=%2F_next%2Fstatic%2Fmedia%2FpinnedExtensions.1362cfc6.png&w=640&q=75)
+
+### 更好的 Jupyter 支持
+
+- 支持整个笔记本的上下文导入。
+- 一些小 bug 修复。
+
+### 差异生成改进
+
+- 局部差异接受/拒绝。
+- 生成操作可在您点击其他地方时继续。
+
+- 修复了选中区域外编辑的差异 bug。
+
+### 生活质量改进
+
+- 按 ESC 键退出聊天。
+- 修复了聊天中代码块缩小的问题。
+- 提升了远程 SSH 的易用性。
+- 改进了 Cursor Tutor 的引导体验。
+- 为 Toolformer 提供了更好的提示词。
+
+[2023 年 5 月 9 日](https://changelog.cursor.sh/#v0211---enhanced-chat-experience-2023-05-09)
+
+## [v0.2.11 - 增强聊天体验（2023-05-09）](https://changelog.cursor.sh/#v0211---enhanced-chat-experience-2023-05-09)
+
+### Bug 修复
+
+- 修复了“更多”标签的问题。
+- 更新了聊天中 Option+Enter 功能。
+
+[2023 年 5 月 6 日](https://changelog.cursor.sh/#v0210---crucial-bug-fixes-2023-05-06)
+
+## [v0.2.10 - 关键 Bug 修复（2023-05-06）](https://changelog.cursor.sh/#v0210---crucial-bug-fixes-2023-05-06)
+
+### Bug 修复
+
+- 针对两个长期存在的问题的热修复：
+  - 聊天窗口在某些工作区中无法正常使用。
+  - 偶尔按下回车键无响应。
+
+[2023 年 5 月 4 日](https://changelog.cursor.sh/#v029---enhanced-features--improvements-2023-05-04)
+
+## [v0.2.9 - 功能增强及改进（2023-05-04）](https://changelog.cursor.sh/#v029---enhanced-features--improvements-2023-05-04)
+
+### 新功能
+
+- 一键从 VS Code 导入扩展（测试版）。作为用户热切期盼的功能，我们很高兴推出一键扩展导入的测试版！
+- Alpha 功能：🧠 提问整个代码仓库 🛠️。按住 ⌥+Enter 在聊天中试验这一功能！它允许模型深入理解您的请求，在文件中搜索，并提供精心准备的答案。此功能仍处于 Alpha 阶段，我们将持续改进，欢迎反馈！
+
+### Bug 修复
+
+- 改进了编辑和生成的提示。
+- 修复了登录问题。
+- 添加了隐藏工具提示的功能（Cursor 配置 > 高级 > 聊天/编辑工具提示）。
+- 为项目生成功能延长了提示词长度。
+- GPT-4 项目生成功能现已开放。
+
+[2023 年 4 月 29 日](https://changelog.cursor.sh/#v028---multi-file-diffs--remote-ssh-2023-04-29)
+
+## [v0.2.8 - 多文件差异与远程 SSH（2023-04-29）](https://changelog.cursor.sh/#v028---multi-file-diffs--remote-ssh-2023-04-29)
+
+### 新功能
+
+- 实验性支持多文件差异。
+- 🌐 通过“OpenRemote - SSH”扩展支持远程 SSH。
+
+[2023 年 4 月 19 日](https://changelog.cursor.sh/#v026---gpt-4--project-generation-2023-04-19)
+
+## [v0.2.6 - GPT-4 & 项目生成（2023-04-19）](https://changelog.cursor.sh/#v026---gpt-4--project-generation-2023-04-19)
+
+### 新功能
+
+- GPT-4 现已对专业用户开放：
+  - 包含 150k GPT-4 Token。
+  - 设置齿轮中切换模型。
+  - 所有 AI 功能的质量提升。
+- 新实验性功能：从单个提示生成完整项目。
+
+[2023 年 4 月 17 日](https://changelog.cursor.sh/#v025---scroll-bar-hotfix-2023-04-17)
+
+## [v0.2.5 - 滚动条热修复（2023-04-17）](https://changelog.cursor.sh/#v025---scroll-bar-hotfix-2023-04-17)
+
+### Bug 修复
+
+- 滚动条的热修复。
+
+[2023 年 4
+
+月 16 日](https://changelog.cursor.sh/#v024---chat-scrolling--ghost-mode-2023-04-16)
+
+## [v0.2.4 - 聊天滚动和幽灵模式（2023-04-16）](https://changelog.cursor.sh/#v024---chat-scrolling--ghost-mode-2023-04-16)
+
+### 新功能
+
+- 修复了聊天中的滚动问题。
+- 幽灵模式，允许选择不在服务器上存储任何数据。
+
+### Bug 修复
+
+- 更优雅的编辑，现在支持 CMD-Z。
+- 修复了流式差异中的各种 bug。
+
+[2023 年 4 月 14 日](https://changelog.cursor.sh/#v023---enhanced-error-handling-2023-04-14)
+
+## [v0.2.3 - 增强错误处理（2023-04-14）](https://changelog.cursor.sh/#v023---enhanced-error-handling-2023-04-14)
+
+### 新功能
+
+- 悬停在错误上即可让 AI 解释或修复。
+
+### Bug 修复
+
+- 修复了 Linux 上的设置图标问题。
+- 启动时不再安装 “cursor” 命令。
+
+### 即将推出
+
+- GPT-4 支持。
+
+[2023 年 4 月 7 日](https://changelog.cursor.sh/#v022---bug-fixes-galore-2023-04-07)
+
+## [v0.2.2 - 大量 Bug 修复（2023-04-07）](https://changelog.cursor.sh/#v022---bug-fixes-galore-2023-04-07)
+
+### Bug 修复
+
+- 修复了 Mac 自动更新问题。
+- 修复了“未定义 URI”问题。
+- 关闭了“cursor .” 命令的自动安装功能（并修复了该功能的安装问题）。
+
+[2023 年 4 月 6 日](https://changelog.cursor.sh/#v021---more-bug-fixes-2023-04-06)
+
+## [v0.2.1 - 更多 Bug 修复（2023-04-06）](https://changelog.cursor.sh/#v021---more-bug-fixes-2023-04-06)
+
+### Bug 修复
+
+- 包括 Bug 修复。
+
+[2023 年 4 月 6 日](https://changelog.cursor.sh/#v020---introducing-cursor-020-2023-04-06)
+
+## [v0.2.0 - 推出 Cursor 0.2.0！（2023-04-06）](https://changelog.cursor.sh/#v020---introducing-cursor-020-2023-04-06)
+
+- 我们已将 Cursor 构建转移到基于 VSCodium 分支的版本，放弃了之前基于 Codemirror 的方法。
+- 这样我们可以专注于 AI 功能，同时利用 VSCode 成熟的文本编辑功能。
+- 我们的目标是创建一个专为与 AI 配合编程优化的 IDE。
+- 目前它类似于带有 AI 功能的标准代码编辑器，但我们计划显著改进编程体验。
+
+### 新功能
+
+- 迁移到基于 VSCodium 分支的版本。
+- 专注于增强 AI 的协同编程能力。
+
+[2023 年 3 月 30 日](https://changelog.cursor.sh/#v0112-2023-03-30)
+
+## [v0.1.12（2023-03-30）](https://changelog.cursor.sh/#v0112-2023-03-30)
+
+### 新功能
+
+- 使用 AI 现在需要登录。
+- 可使用 OpenAI API 密钥以成本价享受无限请求（如可用，支持 GPT-4）。
+
+### Bug 修复
+
+- 清理了聊天样式。
+- 其他小改动。
+
+[2023 年 3 月 28 日](https://changelog.cursor.sh/#v0111-2023-03-28)
+
+## [v0.1.11（2023-03-28）](https://changelog.cursor.sh/#v0111-2023-03-28)
+
+### Bug 修复
+
+- 修复了终端的一个小问题。
+
+[2023 年 3 月 28 日](https://changelog.cursor.sh/#v0110-2023-03-28)
+
+## [v0.1.10（2023-03-28）](https://changelog.cursor.sh/#v0110-2023-03-28)
+
+### Bug 修复
+
+- 修复了一些键盘快捷键的问题。
+- 其他一些小改进。
+
+[2023 年 3 月 27 日](https://changelog.cursor.sh/#v019-2023-03-27)
+
+## [v0.1.9（2023-03-27）](https://changelog.cursor.sh/#v019-2023-03-27)
+
+### 新功能
+
+- 在当前文件夹中打开终端。
+- 添加了可选的付费计划，以避免服务器容量限制。
+
+### Bug 修复
+
+- 修改了自动更新功能，现在会通知有新版本可用。
+- 其他问题修复。
+
+[2023 年 3 月 25 日](https://changelog.cursor.sh/#v017-2023-03-25)
+
+## [v0.1.7（2023-03-25）](https://changelog.cursor.sh/#v017-2023-03-25)
+
+### 新功能
+
+- 支持文件名的模糊搜索。
+
+### Bug 修复
+
+- 修复了终端相关问题。
+- 滚动条恢复正常。
+- 其他修复（包括许多来自 PR 的修复 🙂）。
+
+[2023 年 3 月 24 日](https://changelog.cursor.sh/#v016-2023-03-24)
+
+## [v0.1.6（2023-03-24）](https://changelog.cursor.sh/#v016-2023-03-24)
+
+### Bug 修复
+
+- 修复了快捷键问题。
+
+[2023 年 3 月 23 日](https://changelog.cursor.sh/#v015-2023-03-23)
+
+## [v0.1.5（2023-03-23）](https://changelog.cursor.sh/#v015-2023-03-23)
+
+### 新功能
+
+- 自动应用聊天建议。
+- 可要求 AI 修复语言错误。
+- 聊天历史可在会话之间保存。
+
+### Bug 修复
+
+- 聊天中的内容更易于选择和复制。
+- 侧边栏支持调整大小。
+- 终端不再干扰聊天。
+
+### 即将推出
+
+- 语言服务器/CoPilot 的修复。
+
+[2023 年 3 月 18 日](https://changelog.cursor.sh/#v012-013-2023-03-18)
+
+## [v0.1.2-0.1.3（2023-03-18）](https://changelog.cursor.sh/#v012-013-2023-03-18)
+
+### 新功能
+
+- 内置终端。
+- 差异会自动继续。
+
+### Bug 修复
+
+- 更多差异修复。
+- 提示栏中上/下箭头的快捷键进行了调整。
+- 可从提示栏打开聊天历史。
+
+### 即将推出
+
+- 聊天将自动将建议的更改插入编辑器。
+
+[2023 年 3 月 14 日](https://changelog.cursor.sh/#v0037-2023-03-14)
+
+## [v0.0.37（2023-03-14）](https://changelog.cursor.sh/#v0037-2023-03-14)
+
+### 新功能
+
+- 支持 Windows 和 Linux 🥳。
+- 可进行任意长度的编辑。
+
+### Bug 修复
+
+- 差异不再消失。
+- 在同一文件的多个选项卡中编辑时无问题。
+
+### 即将推出
+
+- 使用 AI 一键修复所有 Lint 错误 😎。
+
+[2023 年 3 月 25 日](https://changelog.cursor.sh/#v017-2023-03-25)
+
+## [v0.1.7（2023-03-25）](https://changelog.cursor.sh/#v017-2023-03-25)
+
+### 新功能
+
+- 支持文件名的模糊搜索。
+
+### Bug 修复
+
+- 修复了终端相关问题。
+- 滚动条恢复正常。
+- 其他修复（包括许多来自 PR 的修复 🙂）。
+
+[2023 年 3 月 24 日](https://changelog.cursor.sh/#v016-2023-03-24)
+
+## [v0.1.6（2023-03-24）](https://changelog.cursor.sh/#v016-2023-03-24)
+
+### Bug 修复
+
+- 修复了快捷键问题。
+
+[2023 年 3 月 23 日](https://changelog.cursor.sh/#v015-2023-03-23)
+
+## [v0.1.5（2023-03-23）](https://changelog.cursor.sh/#v015-2023-03-23)
+
+### 新功能
+
+- 自动应用聊天建议。
+- 可要求 AI 修复语言错误。
+- 聊天历史可在会话之间保存。
+
+### Bug 修复
+
+- 聊天中的内容更易于选择和复制。
+- 侧边栏支持调整大小。
+- 终端不再干扰聊天。
+
+### 即将推出
+
+- 语言服务器/CoPilot 的修复。
+
+[2023 年 3 月 18 日](https://changelog.cursor.sh/#v012-013-2023-03-18)
+
+## [v0.1.2-0.1.3（2023-03-18）](https://changelog.cursor.sh/#v012-013-2023-03-18)
+
+### 新功能
+
+- 内置终端。
+- 差异会自动继续。
+
+### Bug 修复
+
+- 更多差异修复。
+- 提示栏中上/下箭头的快捷键进行了调整。
+- 可从提示栏打开聊天历史。
+
+### 即将推出
+
+- 聊天将自动将建议的更改插入编辑器。
+
+[2023 年 3 月 14 日](https://changelog.cursor.sh/#v0037-2023-03-14)
+
+## [v0.0.37（2023-03-14）](https://changelog.cursor.sh/#v0037-2023-03-14)
+
+### 新功能
+
+- 支持 Windows 和 Linux 🥳。
+- 可进行任意长度的编辑。
+
+### Bug 修复
+
+- 差异不再消失。
+- 在同一文件的多个选项卡中编辑时无问题。
+
+### 即将推出
+
+- 使用 AI 一键修复所有 Lint 错误 😎。
\ No newline at end of file
diff --git a/docs/md/AI/llm/goodbye-cursor-hello-windsurf.md b/docs/md/AI/agent/goodbye-cursor-hello-windsurf.md
similarity index 100%
rename from docs/md/AI/llm/goodbye-cursor-hello-windsurf.md
rename to docs/md/AI/agent/goodbye-cursor-hello-windsurf.md
diff --git a/docs/md/AI/ai-trends-disrupting-software-teams.md b/docs/md/AI/ai-trends-disrupting-software-teams.md
new file mode 100644
index 000000000..e41e62849
--- /dev/null
+++ b/docs/md/AI/ai-trends-disrupting-software-teams.md
@@ -0,0 +1,239 @@
+# AI驱动软件团队变革：未来趋势解读
+
+## 0 关键要点
+
+- AI 正在改变代码编写方式，开发者需要从“代码输入专家”转变为“AI 合作伙伴”
+- 运维团队需掌握 AI 驱动的运维工具，从手动编写自动化脚本转向设计可观察性策略，以引导 AI 系统实现预期行为
+- 成功应用 AI，需技术文档人员专注更高价值工作，如收集用户问题、记录事故经验、分析文档使用模式、识别知识空白等
+- 不主动规划 AI 助手的 SaaS 供应商，可能被 AI 原生创业公司颠覆，这些新兴公司提供更高效用户体验
+- 组织越来越多地采用 AI Agent，以协调、规划和执行复杂的业务任务，并尽量减少人为干预。
+
+软件业正经云计算以来最重大变革。AI正从根本改变软件开发、运维和交互方式。我见证了从 [SOA 到微服务]、从[容器到无服务器]的发展，如今，AI变革更深远。不仅自动化编码或在应用程序中添加聊天机器人，而是全新开发范式、运维实践和用户交互模式，重塑团队结构和软件的使用方式。
+
+本文将探讨五大正在影响软件团队并将在未来几年愈发重要的趋势。分析这些变化的实际案例，并讨论从开发者到架构师再到产品经理等不同角色，如何适应并在这个新环境中蓬勃发展。
+
+先看看最根本变化——**代码编写方式变革**。
+
+## 1 生成式软件开发
+
+软件开发演进历程令人惊叹，从最初打孔卡编程，到多层次抽象提升，每一步都在降低开发门槛。
+
+### **AI 原生开发：软件开发的下一步演进**
+
+软件开发的演变历程经历了多个阶段：
+
+1. **汇编语言时代** —— 需要深入的技术专业知识。
+2. **系统级语言（C、C++）** —— 提供更强的硬件控制能力，同时降低了一些复杂性。
+3. **托管运行时（Java、JavaScript）** —— 通过虚拟机和自动内存管理提高了开发效率。
+4. **高级脚本语言（Python）** —— 进一步简化开发，使编程更加易学易用。
+
+**AI 原生开发**（AI-Native Development）是这一演进的最新阶段。它有许多不同的称谓（[点击查看](https://generativeprogrammer.com/p/talk-draw-generate-10-ways-for-creating)），但核心思想是：**用 AI 直接生成代码，减少手动编码的工作量**。
+
+## **AI 如何改变软件开发？**
+
+### **1. 代码生成和自动化编辑**
+
+**生成式 AI（GenAI）和大语言模型（LLM）** 正在减少手工编码的需求。开发者无需一行行手动编写代码，而是可以**通过 AI 进行多行编辑、生成应用骨架，甚至完整的软件组件**。
+
+### **2. 用自然语言创建完整应用**
+
+在某些受控环境（如 Web 应用开发）中，AI 已能够**通过文本、语音指令或图像** 生成并运行**全栈应用**。这延续了软件开发**越来越抽象化、可访问性越来越高**的趋势，彻底改变了传统的开发流程。
+
+------
+
+### **AI 代码辅助工具生态**
+
+![AI 代码辅助工具生态](https://imgopt.infoq.com/fit-in/3000x4000/filters:quality(85)/filters:no_upscale()/articles/ai-trends-disrupting-software-teams/en/resources/92figure-1-1742210590444.jpg)
+
+AI 代码辅助工具生态
+
+随着 AI 继续发展，软件开发将变得更加智能化。未来，开发者的工作重点将从“编写代码”转向“指导 AI 生成代码”，这不仅提高了生产力，也改变了编程的本质。
+
+### 1.1 AI助力软件开发的两大方向
+
+当前 AI 赋能的开发工具正沿如下方向演进：
+
+#### 1.1.1 AI 增强型 IDE & 代码助手
+
+代表工具：[GitHub Copilot](https://github.com/features/copilot)、[Cursor](https://www.cursor.com/)、[Windsurf](https://codeium.com/windsurf)
+
+可提供智能代码补全和生成功能，分析项目上下文、依赖关系和模式，建议相关代码片段，并在开发者熟悉的环境中完成函数。
+
+其他工具还可用于 [代码审查](https://www.devtoolsacademy.com/blog/coderabbit-vs-others-ai-code-review-tools/) 和 [现代化改造](https://martinfowler.com/articles/legacy-modernization-gen-ai.html) 旧代码，帮助团队以低风险方式逐步引入 AI，提高开发效率。
+
+#### 1.1.2 自主编码Agent
+
+代表平台：[Devin](https://devin.ai/)、[Bolt](https://bolt.new/)、[v0](https://v0.dev/)、[Replit](https://replit.com/)、[Lovable](https://lovable.dev/)
+
+这些平台不仅能提供代码建议，还能在特定领域（如 UI 和 js）解析高层次需求、提出架构方案、生成完整应用，甚至进行部署运行。
+
+让非传统开发者和半技术人员也能利用自然语言或设计模型快速构建软件。
+
+目前，生成式软件开发仍处于早期阶段，稳定性和可复现性仍是挑战，尚未完全融入现有的软件工程实践。
+
+### 1.2 影响及应对
+
+- 开发者需适应 AI 赋能的开发模式，从“代码输入专家”转变为 AI 合作伙伴，学会提供清晰上下文、优化需求输入（Prompt），并指导 AI 生成符合预期代码
+- AI生成代码仍缺乏可扩展性、安全性和业务背景判断力，因此具有架构设计、系统思维和业务理解能力的工程师更具竞争力
+- 学习AI的优势与局限，掌握 AI 辅助工具，并专注系统架构、领域知识和批判性思维，将成为软件工程师未来职业发展关键
+
+## 2 AI驱动的运维
+
+现代分布式系统规模和复杂性已超人类传统监控和故障排除能力，而AI助力的代码生成进一步加速应用的增长和复杂度。因此，传统可观测性手段（手动查日志、基于阈值告警、静态仪表盘）已无法满足需求。
+
+### 2.1 AI咋提升运维效率？
+
+- **预测性分析**：通过分析历史攻击数据，发现复杂模式，提前识别潜在威胁
+- **行为分析**：实时检测用户行为异常，发现可能的账户泄露或内部风险
+- **异常检测**：AI 可持续监控网络流量、日志和 API 交互，发现非正常行为，提高零日攻击检测能力
+- **自动根因分析**：AI 平台（如 [Resolve.ai](http://resolve.ai/)）可整合基础设施、应用日志和部署历史，自动分析问题并提供解决方案
+
+![img](https://imgopt.infoq.com/fit-in/3000x4000/filters:quality(85)/filters:no_upscale()/articles/ai-trends-disrupting-software-teams/en/resources/70figure-2-1742211972313.jpg)
+
+**Automated Root Cause Analysis (Example: [Resolve.ai](https://resolve.ai/))**
+
+#### 示例
+
+若某服务出现延迟，AI可自动关联最近的部署、基础设施变更和过往类似故障，并生成专门的分析仪表盘，在IM软件中向团队汇报修复方案，大幅缩短故障处理时间。
+
+### 2.2 影响及应对
+
+- 运维团队需掌握 AI 赋能的运维工具，从编写复杂查询和手动解析日志，转向设计全面的可观测性策略，确保 AI 生成的建议符合系统架构和业务需求
+- AI 让运维从被动故障响应变为主动预防和优化，团队需要适应这一角色转变
+
+## 3 上下文感知的互动式文档
+
+软件文档一直是推动技术普及的关键，但随软件更新速度加快，传统文档维护成本越来越高。AI使文档不仅更易撰写，也更易交互。
+
+### 3.1 AI咋改变文档管理？
+
+#### 3.1.1 文档自动生成
+
+AI 可基于代码、API 和开发者讨论自动生成结构化文档、代码示例和 FAQ，减少人工工作量。
+
+#### 3.1.2 文档嵌入式 AI 交互
+
+如 [Kapa.ai](http://kapa.ai/) 和 [Inkeep](https://inkeep.com/) 可将 AI 集成到文档门户或产品界面，让开发者通过对话方式获取信息。
+
+#### 3.1.3 自动知识捕获 & 支持集成
+
+如 [Pylon](https://docs.usepylon.com/pylon-docs/support-workflows/issues/copilot)，可分析开发者提问、工单和事故报告，动态优化文档内容。
+
+### 3.2 影响及应对
+
+- 传统手动编写和维护文档方式正被 AI 取代，单纯依赖 AI 生成内容也不行
+- 成功的技术文档团队需利用 AI，提高文档质量和可访问性，如收集用户问题、总结最佳实践、分析文档使用模式，并确保信息在合适的场景精准推送
+- 未来技术文档不再是静态文本，而是互动式、上下文感知的动态知识系统
+
+### 小结
+
+AI 正在彻底改变软件开发、运维和文档管理方式，软件团队需要快速适应这一趋势。开发者、运维人员和文档团队都需要学会如何利用 AI，而不是被 AI 取代。未来的赢家将是那些能够将 AI 与人类智慧相结合、提高生产力、优化流程并创造更好用户体验的人。
+
+## 4 上下文感知的AI助手咋变成 SaaS 界面？
+
+**Serverless 架构和开发者工具的初衷是让开发者专注于业务逻辑，而平台负责基础设施管理、扩展、安全性和可观测性。** 但现实serverless生态复杂性带来新挑战。开发者需应对大量服务、API 和配置，导致文档负担大幅增加，掌握最佳实践成为一项全职工作。随 serverless 服务更强大和更精细化，连接和配置它们所需的工作量也在增加，影响开发效率。
+
+**AI现正改善 SaaS 体验，通过直接嵌入产品的上下文感知助手，提供实时、智能指导。** 过去，开发者需查阅文档、安装CLI或手动调试 API 请求，如今，AI 界面可理解用户需求，提供相关信息，甚至直接执行任务。如借助 [Model Context Protocol (MCP)](https://github.com/modelcontextprotocol) 等标准，AI 助手能够解析用户的上下文，并与外部资源交互。不久后，用户将不仅仅收到操作指南，而是能够 **在聊天界面内直接执行任务，让 AI 从“被动助手”变成“主动解决者”**。
+
+AI 助手的不同模式：嵌入式、扩展式、独立式
+
+![img](https://imgopt.infoq.com/fit-in/3000x4000/filters:quality(85)/filters:no_upscale()/articles/ai-trends-disrupting-software-teams/en/resources/60figure-3-1742211972313.jpg)
+
+不同 SaaS 产品有不同 AI 助手集成方式：
+
+### 4.1 嵌入式 AI 助手（深度集成到 SaaS 内部）
+
+如，[Supabase AI Assistant](https://supabase.com/features/ai-assistant) 直接集成在 [Supabase](https://supabase.com/) 的 UI 中，能够理解产品域（Supabase）、用户当前状态（已启用的服务、访问权限等），并与 API 直接交互。遇到数据库查询问题时，它不仅能解释概念，还能生成 SQL 查询、分析性能影响，甚至在用户允许的情况下直接执行查询。
+
+### 4.2 扩展式 AI 助手（作为某个产品的辅助入口）
+
+ [v0.dev](https://v0.dev/) 由 Vercel 推出，虽然它与 [Vercel](https://vercel.com/) 相关，但并不完全绑定，以吸引新用户。例如，用户可以先在 v0.dev 上创建网站，后续可能会托管到 Vercel，而不必一开始就接触 Vercel 的复杂功能。
+
+### 4.3 独立的 AI 助手 SaaS（作为第三方 AI 服务）
+
+如 [Lovable.dev](https://lovable.dev/)、Bolt.new 和 Replit 这类 AI 原生服务，主要面向非技术或半技术用户，并作为某些 SaaS 的前端接口。例如，Lovable.dev 无缝集成 Supabase 作为后端存储，Bolt.new 则集成 Netlify 和 GitHub。
+
+### 4.4 谁将受影响？咋适应？
+
+- **所有 SaaS 产品都将受到影响**。自然语言交互正在成为用户界面的标准，尤其是技术产品的入门阶段。
+- **AI 将成为产品增长的加速器**（[Product-Led Growth](https://productled.com/book/product-led-growth)）。它可以降低入门门槛，帮助用户更快理解和使用功能。
+- **不是简单加个聊天框就够了**。需要思考 AI 如何真正增强产品价值，例如：
+  - 数据存储服务可以通过 AI 直接生成数据库模式、查询数据、创建测试数据，而不仅仅依赖 SQL 客户端。
+  - 监控工具可以让用户用自然语言分析日志、查找异常，而不是手动筛选数据。
+  - AI 助手应该提供实用功能，而不仅仅是搜索和回答问题。
+
+ 如果你是 SaaS 公司的产品体验负责人，该如何应对？
+
+1. **亲自使用 AI**——尝试 AI 助手和代码助手，深入了解它们的能力和局限性。
+2. **在公司内部发起 AI 计划**——帮助团队学习 AI 相关知识，并寻找潜在应用场景。
+3. **消除产品使用中的阻碍**——利用自然语言界面（如聊天交互）优化用户体验。
+4. **挖掘 AI 的真正价值**——不要仅仅添加一个聊天机器人，而是思考 AI 如何增强你的产品价值主张。
+5. **AI 是能力放大器**——探索 AI 如何帮助你的产品拓展新的应用场景或用户群体。
+
+## 5 智能代理系统的崛起
+
+越来越多的企业正在采用**自主 AI 代理**（Agent），让它们能够自主规划、协调并执行复杂的业务任务，减少人工干预。
+像 **AutoGPT、AutoGen、Dapr Agents、LangGraph** 等项目，是早期热门的 AI 代理框架，而整个技术生态正在快速发展。
+与过去单一任务的 AI 模型不同，**智能代理系统正在演变为 AI 服务网络**，需要分布式系统能力，包括：
+
+- **工作流编排**
+- **异步消息处理**
+- **状态管理**
+- **高可靠性**
+- **安全性**
+- **可观测性**
+
+这些代理系统远远超越了传统的 API 集成，正在重新定义软件自动化。
+
+### 谁将受到影响？如何应对？
+
+这一变革将影响所有技术岗位，就像**互联网、微服务、云计算、无服务器架构**曾经对行业的冲击一样：
+
+- **开发者** 需要学习 **智能代理设计模式**、**大语言模型（LLM）对话 API**、**AI 代理编排技术**，以连接和协调不同的 AI 代理。
+- **架构师** 需要设计**生产级、成本优化**的 AI 解决方案，并将智能代理系统与现有云计算和 SaaS 平台集成。
+- **运维团队** 需要**部署新的 LLM 监控、可观测性、追踪工具**，因为 AI 应用的行为与传统软件完全不同。此外，还需确保新旧运维工具的兼容性。例如，Dapr 项目已集成 **Conversation API**，支持 AI 交互的可观测性和安全性。
+- **平台工程师** 需要构建**标准化开发路径**，简化 AI 代理的开发、部署和管理。
+- **产品经理** 需要掌握**AI 评估技术（Evals）**，衡量 AI 驱动界面的有效性，因为用户的主要交互方式将是“提示词 + AI 响应”。
+
+**好消息是：** 目前已有大量开源工具和免费学习资源。企业要么投资培训现有团队，让他们掌握智能代理系统开发能力，要么招聘具备该技能的新人才。
+ **智能代理系统并非短期趋势，而是软件自动化的下一阶段演进。**
+
+## 6 AI 行动计划
+
+AI 发展迅猛，因此企业需要采取**系统化、可持续**的方式来构建 AI 基础能力，包括：
+
+- 学习**大语言模型（LLM）基础知识**，理解它的工作原理、能力与局限性。
+- 掌握**提示工程（Prompt Engineering）**，熟悉现有 AI 工具，为未来 AI 机会做好准备。
+- 让团队内部展开**关于 AI 的深度讨论**，共同探索 AI 发展方向。
+
+### 不同角色的下一步行动
+
+- **开发者**
+  - **必备技能**：掌握 **Cursor、GitHub Copilot** 等代码助手，**CodeRabbit** 之类的 AI 代码审查工具。
+  - **行动策略**：将 AI 工具集成到日常工作中，优先应用在**低风险场景**，如自动化代码生成、代码补全、Bug 修复等。如果公司限制使用，可在**开源项目**或**个人项目**中尝试，并向同事展示其优缺点。
+- **运维团队（Ops）**
+  - **探索 AI 自动化能力**，减少人工介入。
+  - **准备运维 AI 负载**，无论是偶尔调用 LLM API，还是运行完整的 AI 代理系统。
+- **架构师**
+  - **重点学习** LLM 驱动的 AI 体系架构，并了解**智能代理系统如何融入企业 IT 环境**。
+  - 关注**AI 应用的安全性**，例如 [OWASP LLM Top 10 安全指南](https://genai.owasp.org/llm-top-10/)。
+  - **制定 AI 战略计划**：要么为传统应用赋能 AI 功能，要么**从零构建 AI 原生系统**。
+- **技术写作人员（Technical Writers）**
+  - **AI 将成为主要的写作工具**，应积极尝试不同的 AI 生成工具、模型和提示词，**优化文档自动化工作流**。
+  - **内容趋势**：未来的技术文档将变得**更具互动性、更接近对话形式**。
+- **产品经理（PM）**
+  - **紧跟 AI 发展趋势**，了解 AI 如何影响产品战略。
+  - **研究 AI 原生产品**，思考如何利用**自然语言界面**和 AI 助手提升用户体验。
+
+## 7 未来十年，AI 仍将主导软件行业变革
+
+软件开发、运维、架构设计等所有技术领域都将经历变革。无论你的职位是什么，尽早掌握 AI 相关技能，才能在未来占据有利位置。
+
+🔹 **从现在开始学习**，因为 AI 的变革才刚刚开始，它不会是短暂的潮流，而是未来十年的核心趋势。
+
+**AI 正在重塑软件世界，及早行动是唯一的选择。** 🚀
+
+参考：
+
+- https://substack.com/@bibryam/note/c-82526818
+- [GenerativeProgrammer.com](http://generativeprogrammer.com/)
\ No newline at end of file
diff --git a/docs/md/AI/llm/llama-4-multimodal-intelligence.md b/docs/md/AI/llm/llama-4-multimodal-intelligence.md
new file mode 100644
index 000000000..20e8bfa32
--- /dev/null
+++ b/docs/md/AI/llm/llama-4-multimodal-intelligence.md
@@ -0,0 +1,137 @@
+# Llama 4 家族：原生多模态 AI 创新的新时代开启
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/04/211e8961da9feef6bcd28c136aed2719.png)
+
+## 0 要点总结
+
+- Meta发布 Llama 4 系列的首批模型，帮用户打造更个性化多模态体验
+- **Llama 4 Scout** 是有 170 亿激活参数、16 个专家模块的模型，同类中全球最强多模态模型，性能超越以往所有 Llama 系列模型，能在一张 NVIDIA H100 GPU 上运行。该模型支持业界领先的 1000 万上下文窗口，在多个权威测试中表现优于 Gemma 3、Gemini 2.0 Flash-Lite 和 Mistral 3.1
+- **Llama 4 Maverick** 也拥有 170 亿激活参数，但配置多达 128 个专家模块，是同类中最强的多模态模型，在多个广泛测试中超越 GPT-4o 和 Gemini 2.0 Flash，推理和编程能力可与 DeepSeek v3 相当，但激活参数数量不到其一半。其聊天版在 [LMArena](https://lmarena.ai/leaderboard) 上取得了 1417 的 ELO 分数，性能与成本比行业领先
+- 这些出色的模型得益于“教师模型” **Llama 4 Behemoth** 的知识蒸馏。Behemoth 拥有 2880 亿激活参数和 16 个专家模块，是我们最强大的模型，在多项 STEM 基准测试中超越 GPT-4.5、Claude Sonnet 3.7 和 Gemini 2.0 Pro。目前该模型仍在训练中，我们将持续分享更多细节。
+- 立即前往 [llama.com](https://www.llama.com/llama-downloads/) 或 [Hugging Face](https://huggingface.co/meta-llama) 下载 Llama 4 Scout 与 Maverick。也可在 WhatsApp、Messenger、Instagram 私信体验基于 Llama 4 构建的 Meta AI。
+
+随 AI 在日常生活中的广泛应用，确保领先的模型与系统开放可用，对推动个性化体验创新至关重要。支持整个 [Llama 生态](https://www.llama.com/) 的最先进模型组合。正式推出的 **Llama 4 Scout** 和 **Llama 4 Maverick**，是首批开放权重、原生多模态、支持超长上下文窗口、采用 MoE架构构建的模型。“巨兽”—— **Llama 4 Behemoth**，不仅是迄今最强大的模型之一，也是新一代模型的“老师”。
+
+这些 Llama 4 模型的发布标志着 Llama 生态迈入新纪元。Llama 4 系列中的 Scout 和 Maverick 都是高效设计的模型：
+
+- 前者能以 Int4 量化方式部署在单张 H100 GPU 上
+- 后者则适配于单个 H100 主机
+
+训练了 Behemoth 教师模型，在 STEM 基准（如 MATH-500 和 GPQA Diamond）中表现优于 GPT-4.5、Claude Sonnet 3.7 和 Gemini 2.0 Pro。
+
+开放才能推动创新，对开发者、Meta 和整个世界都是利好。可通过 [llama.com](https://www.llama.com/llama-downloads/) 和 [Hugging Face](https://huggingface.co/meta-llama) 下载 Scout 与 Maverick。同时，Meta AI 也已在 WhatsApp、Messenger、Instagram 私信启用 Llama 4 模型。
+
+这只是 Llama 4 系列的开始。最智能的系统应能泛化行动、自然对话并解决未曾遇到的问题。赋予 Llama 在这些领域的“超能力”，将催生更优质的产品和更多开发者创新机会。
+
+无论你是构建应用的开发者，集成 AI 的企业用户，或是对 AI 潜力充满好奇的普通用户，**Llama 4 Scout 和 Maverick 都是将下一代智能融入产品的最佳选择**。接下来，介绍它们的四大研发阶段以及设计过程中的一些关键洞察。
+
+## 1 预训练阶段
+
+这些模型代表 Llama 系列的巅峰之作，具备强大多模态能力，同时在成本上更具优势，甚至性能超越了一些参数规模更大的模型。为打造 Llama 下一代模型，在预训练阶段采用了多项新技术。
+
+### MoE
+
+Llama 4是首批采用MoE的模型。MoE架构的一个核心优势：每个 token 只激活模型中一小部分参数，从而大幅提高训练与推理的效率。在给定的 FLOPs（浮点运算）预算下，MoE 模型的效果优于传统的密集模型。
+
+![img](https://my-img.javaedge.com.cn/javaedge-blog/2025/04/aa872e17b8b0d87617976405248de16a.png)
+
+以 **Llama 4 Maverick** 为例：它拥有 170 亿激活参数，总参数数为 4000 亿。其网络结构在推理过程中交替使用密集层与 MoE 层。每个 token 会被送入一个共享专家和一个 128 个路由专家之一，这种机制确保模型在保持全参数存储的同时，仅激活必要部分，从而提升运行效率、降低成本与延迟。Maverick 可在一台 NVIDIA H100 DGX 主机上运行，也支持分布式部署以实现最大效率。
+
+Llama 4 天生支持多模态输入，采用 **早期融合（early fusion）机制**，将文本与视觉 token 一体化输入模型主干。使得能用大量未标注的文本、图像和视频数据对模型进行联合预训练。同时，升级视觉编码器，基于 MetaCLIP 的改进版，在预训练阶段与冻结的 Llama 主干协同优化。
+
+### 新训练方法MetaP
+
+精确控制每层学习率和初始化比例。这些超参数在不同 batch size、模型宽度、深度和 token 数下都具有良好的迁移性。Llama 4 预训练涵盖 200 多种语言，其中 100 多种语言的数据量超过 10 亿 tokens，总体上多语种训练 token 数量是 Llama 3 的 10 倍。
+
+### FP8 精度
+
+用 **FP8 精度** 进行训练，保持模型质量的同时提高训练效率。如训练 Behemoth 时，用 32000 张 GPU，并实现 390 TFLOPs/GPU 的高效能。整个训练数据超过 **30 万亿个 token**，是 Llama 3 的两倍，数据类型包含多样的文本、图像和视频内容。
+
+训练中期，采用“mid-training”阶段，通过专门数据集提升模型的核心能力，如支持更长上下文的能力。得益于这些改进，Llama 4 Scout 实现 **业界领先的 1000 万 token 输入长度**。
+
+## 2 后训练阶段
+
+新模型有大小多种选择，以满足不同应用场景与开发者需求。**Llama 4 Maverick** 在图像和文本理解方面表现卓越，是多语言 AI 应用和创意写作的理想选择。
+
+后训练阶段最大的挑战是保持不同输入模态、推理能力与对话能力之间的平衡。为此，设计“多模态课程”训练策略，确保模型不因学习多模态而牺牲单一模态性能。更新了后训练流程，采取轻量监督微调（SFT）> 在线强化学习（RL）> 轻量偏好优化（DPO）的方式。发现SFT 与 DPO 若使用不当，会限制模型在 RL 阶段的探索，特别是在推理、编程和数学领域会导致效果下降。
+
+为解决这问题，剔除超过 50% 的“简单样本”，仅对更难数据进行 SFT。之后 RL 阶段用更具挑战性提示，实现性能飞跃。采用 **持续在线 RL 策略**：训练模型 → 用模型筛选中等难度以上的提示 → 再训练，如此循环，有效平衡计算成本与精度。最终，我们通过轻量 DPO 优化边缘情况，全面提升模型的智能与对话能力。
+
+**Llama 4 Maverick 拥有 170 亿激活参数、128 个专家模块与 4000 亿总参数**，在性能上超越 Llama 3.3 的 70B 模型。它是目前最顶级的多模态模型，在编程、推理、多语言、长文本与图像等任务中优于 GPT-4o 与 Gemini 2.0，与 DeepSeek v3.1 的表现不相上下。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/04/61be08075862447da6a83e8202a24dc7.png)
+
+**Llama 4 Scout** 是一款通用模型，具备 170 亿激活参数、16 个专家模块、1090 亿总参数，性能在同类模型首屈一指。它将上下文长度从 Llama 3 的 128K 大幅提升至 **1000 万 tokens**，支持多文档摘要、个性化任务解析、大型代码库推理等复杂应用。
+
+Scout 在预训练和后训练阶段都使用 256K 上下文长度，出色的长文本泛化能力。文本检索、代码负对数似然（NLL）评估等任务表现优秀。一大创新是采用 **不使用位置嵌入的交错注意力机制（iRoPE）**，通过 [温度调节推理机制](https://arxiv.org/pdf/2501.19399) 提升对超长输入的处理能力。
+
+<video src="https://video.frmq2-1.fna.fbcdn.net/o1/v/t2/f2/m69/AQPOK-zv-evJXKxKpQvs7yehBVW3egp3F3nSsmhPO5Vn_h2O_9Kf-c5X8V8_pyutvHErRTu3ygYQ1CUKi3wWxr-I.mp4?strext=1&amp;_nc_cat=1&amp;_nc_oc=AdmtYxlVppj6Le7awab_Pe2fmRVG4VKqQLkJP6rGq9Lbl6O4H6ZrguQU-hRCiRLahus&amp;_nc_sid=5e9851&amp;_nc_ht=video.frmq2-1.fna.fbcdn.net&amp;_nc_ohc=nZfoCLgKLykQ7kNvwH-8Q18&amp;efg=eyJ2ZW5jb2RlX3RhZyI6Inhwdl9wcm9ncmVzc2l2ZS5GQUNFQk9PSy4uQzMuMTkyMC5kYXNoX2gyNjQtYmFzaWMtZ2VuMl8xMDgwcCIsInhwdl9hc3NldF9pZCI6MTE3NzY3MjI1MDUxOTU5NiwidmlfdXNlY2FzZV9pZCI6MTA4MjUsImR1cmF0aW9uX3MiOjE4LCJ1cmxnZW5fc291cmNlIjoid3d3In0%3D&amp;ccb=17-1&amp;vs=af314ec2e78309dd&amp;_nc_vs=HBksFQIYOnBhc3N0aHJvdWdoX2V2ZXJzdG9yZS9HRXpoRlIwaXFZTFkwN2tFQUFNdUlDNkp4TE1nYnY0R0FBQUYVAALIAQAVAhg6cGFzc3Rocm91Z2hfZXZlcnN0b3JlL0dGaUNDaDI0bjJLTm1PVUVBSUpRLThuaVo4VUNidjRHQUFBRhUCAsgBACgAGAAbAogHdXNlX29pbAExEnByb2dyZXNzaXZlX3JlY2lwZQExFQAAJtjAu4LGxZcEFQIoAkMzLBdAMgAAAAAAABgaZGFzaF9oMjY0LWJhc2ljLWdlbjJfMTA4MHARAHUCAA&amp;_nc_zt=28&amp;oh=00_AfEwGzSRF0gThyeB1z23DOns6Kuhu6SDMYWXhhOzZ7jikQ&amp;oe=67F8747A" class="_9rzn _9lwe" controls="1" controlslist="nodownload" loop="1" muted="1" poster="https://scontent-tpe1-1.xx.fbcdn.net/v/t39.8562-6/488601380_691716116851230_4462222921335148419_n.png?_nc_cat=107&amp;ccb=1-7&amp;_nc_sid=f537c7&amp;_nc_ohc=sbMiCDM-eJsQ7kNvwFojA91&amp;_nc_oc=AdnSiFgEMbKwhChwc05yLw7rO1Ar4Az4gKMRw5rajZHMSyVyaRu5tpevsKvAGTr9PL4&amp;_nc_zt=14&amp;_nc_ht=scontent-tpe1-1.xx&amp;_nc_gid=bf4LXMFndm6IkNxalboZ7w&amp;oh=00_AfGTJj0sHEDw-dl07aqYwMlfKb8gK_1A7qJgjwAVIwwO4g&amp;oe=67F8502D" id="u_0_8_ec" style="height: auto; width: 702px;"></video>
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/04/05612ee80f4df6fbbf3793796657dae1.png)
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/04/edcae9afe120cec3c0621bc865f08901.png)
+
+对两个模型都进行广泛的图像和视频帧训练，以增强它们对视觉内容的理解能力，包括时间相关活动和图像之间的关联。这让模型在处理多图输入时能轻松地结合文字提示进行视觉推理与理解。预训练阶段使用最多48张图像的输入，并在后期测试中验证模型在处理最多8张图像时的良好表现。
+
+**Llama 4 Scout** 在图像定位方面表现尤为出色，能将用户的提示准确对应到图像中的具体视觉元素，实现更精确的视觉问答。这款模型在编程、推理、长文本理解和图像处理等方面全面超越以往版本的 Llama 模型，性能领先同类模型。
+
+## 3 推出更大规模的Llama：2 万亿参数巨兽 Behemoth
+
+Llama 4 Behemoth——拥有高级智能的“教师模型”，在同类模型中表现领先。Behemoth 是一个多模态专家混合（MoE）模型，激活参数达 2880 亿，拥有 16 个专家模块，总参数量接近两万亿。在数学、多语言和图像基准测试中表现一流，因此成为训练更小的 Llama 4 模型的理想“老师”。
+
+从 Behemoth 模型中通过“共蒸馏”（codistillation）技术训练出 Llama 4 Maverick，有效提升最终任务表现。还研发了一种全新的损失函数，在训练过程中动态调整软标签和硬标签的权重。通过在 Behemoth 运行前向传递，生成用于训练学生模型的数据，大幅降低训练成本。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/04/dbf5260ff3877e139e6f994e5d2c3d26.png)
+
+对拥有两万亿参数模型，后期训练本就是巨大挑战。从数据量级就开始彻底改革训练方法。为提升性能，将监督微调（SFT）数据削减95%（相比于小模型只需要削减50%），以更专注数据质量和效率。
+
+先进行轻量级SFT，再进行大规模强化学习（RL），能显著提升模型的推理和编程能力。RL策略包括：
+
+- 使用 pass@k 方法选取具有挑战性的提示构建训练课程
+- 动态过滤无效提示
+- 混合多个任务的提示组成训练批次
+- 使用多种系统指令样本，确保模型能广泛适应不同任务
+
+为支持 2 万亿参数的 RL 训练，重构整个强化学习基础设施。对 MoE 并行架构优化，提高训练速度，并开发完全异步的在线 RL 框架，提升训练的灵活性和效率。通过将不同模型分配到不同 GPU 并进行资源平衡，实现训练效率10倍提升。
+
+## 4 安全机制与防护措施
+
+致力打造有用且安全的模型，同时规避潜在的重大风险。Llama 4 遵循《AI 使用开发指南》中的最佳实践，从预训练到系统级都融入了防护机制，以保障开发者免受恶意行为干扰，从而开发出更安全、可靠的应用。
+
+### 4.1 预训练与后训练防护
+
+- **预训练**：使用数据过滤等方法保护模型。
+- **后训练**：通过一系列技术确保模型遵循平台政策，保持对用户和开发者的友好性和安全性。
+
+### 4.2 系统级方法
+
+开源多种安全工具，方便集成进 Llama 模型或第三方系统：
+
+- **Llama Guard**：与 MLCommons 联合开发的[风险分类法](https://arxiv.org/abs/2404.12241)构建的输入输出安全模型。
+- **Prompt Guard**：一个可识别恶意提示（如 Jailbreak 和提示注入）的分类模型。
+- **CyberSecEval**：帮助开发者了解和降低生成式 AI 网络安全风险的评估工具。
+
+这些工具支持高度定制，开发者可根据应用需求进行优化配置。
+
+### 4.3 安全评估与红队测试
+
+在各种使用场景下进行系统化测试，并将测试结果反馈到模型后训练。使用动态对抗性探测技术（包括自动和人工测试）识别模型的潜在风险点。
+
+一种新测试方式——**生成式攻击智能代理测试（GOAT）**，可模拟中等技能水平的攻击者进行多轮交互，扩大测试覆盖范围。GOAT自动化测试能替代人工团队处理已知风险区域，让专家更专注新型对抗场景，提高测试效率。
+
+### 4.4 解决语言模型中的偏见问题
+
+LLM易出现偏见，尤其在社会和政治话题偏向自由派，因为网络训练数据本身就存在倾向性。
+
+目标是消除偏见，让 Llama 公正理解并表达有争议话题的不同观点，而非偏袒。Llama 4 在这方面取得重大进展：
+
+- 拒答比例从 Llama 3 的 7% 降低至 Llama 4 的 2% 以下
+- 对具有争议性的问题，拒答不平衡的比例降至 1% 以下
+- 表现出强烈政治倾向的响应率仅为 Llama 3 的一半，与 Grok 相当
+
+## 5 探索 Llama 生态系统
+
+除了模型智能，用户还希望模型反应个性化、速度快。Llama 4 是迄今为止最先进模型，已为此进行优化。模型只是打造完整体验的一部分。
+
+**本项目感谢以下 AI 生态伙伴的大力支持（按字母顺序排列）：**
+Accenture、AMD、Arm、CentML、Cerebras、Databricks、Deepinfra、DeepLearning.AI、Dell、Deloitte、Fireworks AI、IBM Watsonx、Infosys、Intel、Kaggle、Mediatek、Nebius、Oracle Cloud、PwC、Qualcomm、SambaNova、Sarvam AI、Scale AI、Scaleway、Snowflake、TensorWave、Together AI、vLLM、Wipro。
\ No newline at end of file
diff --git a/docs/md/other/guide-to-reading.md b/docs/md/other/guide-to-reading.md
index 55eb75b17..9c80df292 100644
--- a/docs/md/other/guide-to-reading.md
+++ b/docs/md/other/guide-to-reading.md
@@ -7,19 +7,11 @@ title: 目录
 ## 作者团简介
 
 ### JavaEdge
-魔都架构师，多家大厂后端一线研发经验，在分布式系统设计、数据平台架构和AI应用开发等领域都有丰富实践经验。
-
-各大技术社区头部专家博主。具有丰富的引领团队经验，深厚业务架构和解决方案的积累。
-
-> 负责：
-> - 中央/分销预订系统性能优化
-> - 活动&券等营销中台建设
-> - 交易平台及数据中台等架构和开发设计
-> - 车联网核心平台-物联网连接平台、大数据平台架构设计及优化
-> - LLM Agent应用开发
-> - 区块链应用开发
-> 
->  目前主攻市级软件项目设计、构建服务全社会的应用系统。
+- 🚀 魔都架构师 | 全网30W技术追随者
+- 🔧 大厂分布式系统/数据中台实战专家
+- 🏆 主导交易系统百万级流量调优 & 车联网平台架构
+- 🧠 AIGC应用开发先行者 | 区块链落地实践者
+- 🌍 以技术驱动创新，我们的征途是改变世界！
 
 ### 11来了
 

From 308a5058ea75b76da31812829a17dba97b0af2f7 Mon Sep 17 00:00:00 2001
From: JavaEdge <sss2855845850@gmail.com>
Date: Tue, 8 Apr 2025 12:13:03 +0800
Subject: [PATCH 13/20] docs

---
 .vscode/.server-controller-port.log           |   2 +-
 api-gateway-architecture.drawio               | 105 +++++++++
 api_gateway_architecture.drawio               |  12 ++
 api_gateway_security_architecture.drawio      | 113 ++++++++++
 security/oauth2_and_encryption.drawio         | 114 ++++++++++
 security/oauth2_and_encryption_diagram.drawio | 199 ++++++++++++++++++
 6 files changed, 544 insertions(+), 1 deletion(-)
 create mode 100644 api-gateway-architecture.drawio
 create mode 100644 api_gateway_architecture.drawio
 create mode 100644 api_gateway_security_architecture.drawio
 create mode 100644 security/oauth2_and_encryption.drawio
 create mode 100644 security/oauth2_and_encryption_diagram.drawio

diff --git a/.vscode/.server-controller-port.log b/.vscode/.server-controller-port.log
index f15ce2139..a75930b74 100644
--- a/.vscode/.server-controller-port.log
+++ b/.vscode/.server-controller-port.log
@@ -1,5 +1,5 @@
 {
   "port": 9145,
-  "time": 1741529993430,
+  "time": 1744085260411,
   "version": "0.0.3"
 }
\ No newline at end of file
diff --git a/api-gateway-architecture.drawio b/api-gateway-architecture.drawio
new file mode 100644
index 000000000..d3778c709
--- /dev/null
+++ b/api-gateway-architecture.drawio
@@ -0,0 +1,105 @@
+<mxfile host="65bd71144e">
+    <diagram id="C5RBs43oDa-KdzZeNtuy" name="API Gateway Architecture">
+        <mxGraphModel dx="1468" dy="626" grid="0" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="1169" pageHeight="827" math="0" shadow="0">
+            <root>
+                <mxCell id="WIyWlLk6GJQsqaUBKTNV-0"/>
+                <mxCell id="WIyWlLk6GJQsqaUBKTNV-1" parent="WIyWlLk6GJQsqaUBKTNV-0"/>
+                <mxCell id="title-1" value="联盟平台API治理" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=24;fontStyle=1" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+                    <mxGeometry x="415" y="50" width="340" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="client-group" value="客户端" style="swimlane;fontStyle=1;align=center;verticalAlign=top;childLayout=stackLayout;horizontal=1;startSize=26;horizontalStack=0;resizeParent=1;resizeLast=0;collapsible=1;marginBottom=0;rounded=0;shadow=0;strokeWidth=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+                    <mxGeometry x="30" y="145" width="180" height="150" as="geometry"/>
+                </mxCell>
+                <mxCell id="client-web" value="&lt;div&gt;&lt;br&gt;&lt;/div&gt;Web应用" style="verticalAlign=middle;align=center;overflow=fill;fontSize=12;fontFamily=Helvetica;html=1;rounded=1;fontStyle=1;strokeWidth=3;fillColor=#E6FFCC" parent="client-group" vertex="1">
+                    <mxGeometry y="26" width="180" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="client-mobile" value="&lt;div&gt;&lt;br&gt;&lt;/div&gt;移动应用" style="verticalAlign=middle;align=center;overflow=fill;fontSize=12;fontFamily=Helvetica;html=1;rounded=1;fontStyle=1;strokeWidth=3;fillColor=#E6FFCC" parent="client-group" vertex="1">
+                    <mxGeometry y="66" width="180" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="client-iot" value="&lt;div&gt;&lt;br&gt;&lt;/div&gt;IoT设备" style="verticalAlign=middle;align=center;overflow=fill;fontSize=12;fontFamily=Helvetica;html=1;rounded=1;fontStyle=1;strokeWidth=3;fillColor=#E6FFCC" parent="client-group" vertex="1">
+                    <mxGeometry y="106" width="180" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="gateway-main" value="API网关" style="swimlane;fontStyle=1;align=center;verticalAlign=top;childLayout=stackLayout;horizontal=1;startSize=26;horizontalStack=0;resizeParent=1;resizeLast=0;collapsible=1;marginBottom=0;rounded=0;shadow=0;strokeWidth=1;fillColor=#f8cecc;strokeColor=#b85450;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+                    <mxGeometry x="310" y="100" width="550" height="240" as="geometry"/>
+                </mxCell>
+                <mxCell id="security-layer" value="安全管理层" style="swimlane;fontStyle=1;align=center;verticalAlign=top;childLayout=stackLayout;horizontal=1;startSize=26;horizontalStack=0;resizeParent=1;resizeLast=0;collapsible=1;marginBottom=0;rounded=0;shadow=0;strokeWidth=1;fillColor=#fff2cc;strokeColor=#d6b656;" parent="gateway-main" vertex="1">
+                    <mxGeometry x="20" y="40" width="160" height="160" as="geometry"/>
+                </mxCell>
+                <mxCell id="sec-auth" value="认证 (Authentication)" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" parent="security-layer" vertex="1">
+                    <mxGeometry y="36" width="160" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="sec-authz" value="授权 (Authorization)" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" parent="security-layer" vertex="1">
+                    <mxGeometry y="76" width="160" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="sec-encryption" value="加密 (SSL/TLS)" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" parent="security-layer" vertex="1">
+                    <mxGeometry y="116" width="160" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="traffic-layer" value="流量控制层" style="swimlane;fontStyle=1;align=center;verticalAlign=top;childLayout=stackLayout;horizontal=1;startSize=26;horizontalStack=0;resizeParent=1;resizeLast=0;collapsible=1;marginBottom=0;rounded=0;shadow=0;strokeWidth=1;fillColor=#fff2cc;strokeColor=#d6b656;" parent="gateway-main" vertex="1">
+                    <mxGeometry x="195" y="40" width="160" height="160" as="geometry"/>
+                </mxCell>
+                <mxCell id="traffic-rate" value="限流 (Rate Limiting)" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" parent="traffic-layer" vertex="1">
+                    <mxGeometry y="36" width="160" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="traffic-circuit" value="熔断 (Circuit Breaking)" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" parent="traffic-layer" vertex="1">
+                    <mxGeometry y="76" width="160" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="traffic-load" value="负载均衡" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" parent="traffic-layer" vertex="1">
+                    <mxGeometry y="116" width="160" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="routing-layer" value="请求路由层" style="swimlane;fontStyle=1;align=center;verticalAlign=top;childLayout=stackLayout;horizontal=1;startSize=26;horizontalStack=0;resizeParent=1;resizeLast=0;collapsible=1;marginBottom=0;rounded=0;shadow=0;strokeWidth=1;fillColor=#fff2cc;strokeColor=#d6b656;" parent="gateway-main" vertex="1">
+                    <mxGeometry x="370" y="40" width="160" height="160" as="geometry"/>
+                </mxCell>
+                <mxCell id="routing-endpoint" value="路径映射" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" parent="routing-layer" vertex="1">
+                    <mxGeometry y="36" width="160" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="routing-transform" value="数据转换" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" parent="routing-layer" vertex="1">
+                    <mxGeometry y="76" width="160" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="routing-protocol" value="协议转换" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" parent="routing-layer" vertex="1">
+                    <mxGeometry y="116" width="160" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="backend-group" value="后端服务" style="swimlane;fontStyle=1;align=center;verticalAlign=top;childLayout=stackLayout;horizontal=1;startSize=26;horizontalStack=0;resizeParent=1;resizeLast=0;collapsible=1;marginBottom=0;rounded=0;shadow=0;strokeWidth=1;fillColor=#d5e8d4;strokeColor=#82b366;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+                    <mxGeometry x="310" y="390" width="550" height="160" as="geometry"/>
+                </mxCell>
+                <mxCell id="backend-rest" value="RESTful 微服务" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#e1d5e7;strokeColor=#9673a6;" parent="backend-group" vertex="1">
+                    <mxGeometry x="40" y="56" width="120" height="60" as="geometry"/>
+                </mxCell>
+                <mxCell id="backend-grpc" value="gRPC 服务" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#e1d5e7;strokeColor=#9673a6;" parent="backend-group" vertex="1">
+                    <mxGeometry x="215" y="56" width="120" height="60" as="geometry"/>
+                </mxCell>
+                <mxCell id="backend-legacy" value="遗留系统" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#e1d5e7;strokeColor=#9673a6;" parent="backend-group" vertex="1">
+                    <mxGeometry x="390" y="56" width="120" height="60" as="geometry"/>
+                </mxCell>
+                <mxCell id="support-group" value="支持系统" style="swimlane;fontStyle=1;align=center;verticalAlign=top;childLayout=stackLayout;horizontal=1;startSize=26;horizontalStack=0;resizeParent=1;resizeLast=0;collapsible=1;marginBottom=0;rounded=0;shadow=0;strokeWidth=1;fillColor=#e1d5e7;strokeColor=#9673a6;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+                    <mxGeometry x="950" y="145" width="180" height="150" as="geometry"/>
+                </mxCell>
+                <mxCell id="support-monitor" value="&lt;div&gt;&lt;br&gt;&lt;/div&gt;监控系统" style="verticalAlign=middle;align=center;overflow=fill;fontSize=12;fontFamily=Helvetica;html=1;rounded=1;fontStyle=1;strokeWidth=3;fillColor=#ffe6cc;strokeColor=#d79b00" parent="support-group" vertex="1">
+                    <mxGeometry y="26" width="180" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="support-logging" value="&lt;div&gt;&lt;br&gt;&lt;/div&gt;日志系统" style="verticalAlign=middle;align=center;overflow=fill;fontSize=12;fontFamily=Helvetica;html=1;rounded=1;fontStyle=1;strokeWidth=3;fillColor=#ffe6cc;strokeColor=#d79b00" parent="support-group" vertex="1">
+                    <mxGeometry y="66" width="180" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="support-config" value="&lt;div&gt;&lt;br&gt;&lt;/div&gt;配置中心" style="verticalAlign=middle;align=center;overflow=fill;fontSize=12;fontFamily=Helvetica;html=1;rounded=1;fontStyle=1;strokeWidth=3;fillColor=#ffe6cc;strokeColor=#d79b00" parent="support-group" vertex="1">
+                    <mxGeometry y="106" width="180" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="client-to-gateway" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;startArrow=none;startFill=0;endArrow=classic;endFill=1;strokeWidth=2;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="client-group" target="gateway-main" edge="1">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="client-protocol" value="HTTP/HTTPS&#xa;RESTful" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];fontStyle=1" parent="client-to-gateway" vertex="1" connectable="0">
+                    <mxGeometry x="-0.1538" y="1" relative="1" as="geometry">
+                        <mxPoint y="-19" as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="gateway-to-backend" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;startArrow=none;startFill=0;endArrow=classic;endFill=1;strokeWidth=2;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="gateway-main" target="backend-group" edge="1">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="gateway-to-support" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;startArrow=classic;startFill=1;endArrow=classic;endFill=1;strokeWidth=2;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="gateway-main" target="support-group" edge="1">
+                    <mxGeometry relative="1" as="geometry"/>
+                </mxCell>
+                <mxCell id="note-protocol" value="协议标准：RESTful API, HTTP/HTTPS" style="shape=note;strokeWidth=2;fontSize=14;size=20;whiteSpace=wrap;html=1;fillColor=#fff2cc;strokeColor=#d6b656;fontColor=#666600;fontStyle=1" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+                    <mxGeometry x="310" y="580" width="550" height="40" as="geometry"/>
+                </mxCell>
+            </root>
+        </mxGraphModel>
+    </diagram>
+</mxfile>
\ No newline at end of file
diff --git a/api_gateway_architecture.drawio b/api_gateway_architecture.drawio
new file mode 100644
index 000000000..c65e10902
--- /dev/null
+++ b/api_gateway_architecture.drawio
@@ -0,0 +1,12 @@
+<mxfile host="65bd71144e">
+    <diagram id="C5RBs43oDa-KdzZeNtuy" name="API Gateway Architecture">
+        <mxGraphModel dx="600" dy="557" grid="0" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="0" pageScale="1" pageWidth="827" pageHeight="1169" math="0" shadow="0">
+            <root>
+                <mxPoint x="343" y="383" as="targetPoint" id="0">
+                    <mxCell/>
+                </mxPoint>
+                <mxCell id="1" parent="0"/>
+            </root>
+        </mxGraphModel>
+    </diagram>
+</mxfile>
\ No newline at end of file
diff --git a/api_gateway_security_architecture.drawio b/api_gateway_security_architecture.drawio
new file mode 100644
index 000000000..19c8bb6eb
--- /dev/null
+++ b/api_gateway_security_architecture.drawio
@@ -0,0 +1,113 @@
+<mxfile host="65bd71144e">
+    <diagram id="API_Gateway_Security" name="API Gateway Security Architecture">
+        <mxGraphModel dx="997" dy="519" grid="0" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="0" pageScale="1" pageWidth="1169" pageHeight="827" math="0" shadow="0">
+            <root>
+                <mxCell id="0"/>
+                <mxCell id="1" parent="0"/>
+                <mxCell id="client_app" value="客户端应用" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#dae8fc;strokeColor=#6c8ebf;fontStyle=1;fontSize=14;" parent="1" vertex="1">
+                    <mxGeometry x="120" y="280" width="120" height="60" as="geometry"/>
+                </mxCell>
+                <mxCell id="api_gateway" value="API数据联盟网关平台" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#f8cecc;strokeColor=#b85450;fontStyle=1;fontSize=14;" parent="1" vertex="1">
+                    <mxGeometry x="400" y="280" width="140" height="60" as="geometry"/>
+                </mxCell>
+                <mxCell id="resource_server" value="资源服务器" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#d5e8d4;strokeColor=#82b366;fontStyle=1;fontSize=14;" parent="1" vertex="1">
+                    <mxGeometry x="680" y="280" width="120" height="60" as="geometry"/>
+                </mxCell>
+                <mxCell id="auth_server" value="授权服务器&#xa;(OAuth 2.0)" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#ffe6cc;strokeColor=#d79b00;fontStyle=1;fontSize=14;" parent="1" vertex="1">
+                    <mxGeometry x="400" y="120" width="140" height="60" as="geometry"/>
+                </mxCell>
+                <mxCell id="https_client_gateway" value="HTTPS" style="endArrow=classic;startArrow=classic;html=1;rounded=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;exitX=1;exitY=0.5;exitDx=0;exitDy=0;strokeWidth=2;fontSize=12;fontStyle=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" parent="1" source="client_app" target="api_gateway" edge="1">
+                    <mxGeometry width="50" height="50" relative="1" as="geometry">
+                        <mxPoint x="260" y="310" as="sourcePoint"/>
+                        <mxPoint x="310" y="260" as="targetPoint"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="https_gateway_resource" value="HTTPS" style="endArrow=classic;startArrow=classic;html=1;rounded=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;exitX=1;exitY=0.5;exitDx=0;exitDy=0;strokeWidth=2;fontSize=12;fontStyle=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" parent="1" source="api_gateway" target="resource_server" edge="1">
+                    <mxGeometry width="50" height="50" relative="1" as="geometry">
+                        <mxPoint x="530" y="310" as="sourcePoint"/>
+                        <mxPoint x="580" y="260" as="targetPoint"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="oauth_flow_1" value="1. 请求授权" style="endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;dashed=1;strokeWidth=1.5;fontSize=11;fillColor=#ffe6cc;strokeColor=#d79b00;" parent="1" source="client_app" target="auth_server" edge="1">
+                    <mxGeometry width="50" height="50" relative="1" as="geometry">
+                        <mxPoint x="530" y="310" as="sourcePoint"/>
+                        <mxPoint x="580" y="260" as="targetPoint"/>
+                        <Array as="points">
+                            <mxPoint x="180" y="150"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="oauth_flow_2" value="2. 返回Token" style="endArrow=classic;html=1;rounded=0;exitX=0;exitY=0.75;exitDx=0;exitDy=0;entryX=0.25;entryY=0;entryDx=0;entryDy=0;dashed=1;strokeWidth=1.5;fontSize=11;fillColor=#ffe6cc;strokeColor=#d79b00;" parent="1" source="auth_server" target="client_app" edge="1">
+                    <mxGeometry width="50" height="50" relative="1" as="geometry">
+                        <mxPoint x="530" y="310" as="sourcePoint"/>
+                        <mxPoint x="580" y="260" as="targetPoint"/>
+                        <Array as="points">
+                            <mxPoint x="150" y="165"/>
+                        </Array>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="oauth_flow_3" value="3. 带Token请求" style="endArrow=classic;html=1;rounded=0;exitX=0.75;exitY=0;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;dashed=1;strokeWidth=1.5;fontSize=11;fillColor=#ffe6cc;strokeColor=#d79b00;" parent="1" source="api_gateway" target="auth_server" edge="1">
+                    <mxGeometry x="0.8298" y="-20" width="50" height="50" relative="1" as="geometry">
+                        <mxPoint x="530" y="310" as="sourcePoint"/>
+                        <mxPoint x="580" y="260" as="targetPoint"/>
+                        <Array as="points">
+                            <mxPoint x="505" y="100"/>
+                            <mxPoint x="470" y="100"/>
+                        </Array>
+                        <mxPoint as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="oauth_flow_4" value="4. 验证Token" style="endArrow=classic;html=1;rounded=0;exitX=0.75;exitY=0;exitDx=0;exitDy=0;entryX=0.75;entryY=0;entryDx=0;entryDy=0;dashed=1;strokeWidth=1.5;fontSize=11;fillColor=#ffe6cc;strokeColor=#d79b00;" parent="1" source="auth_server" target="api_gateway" edge="1">
+                    <mxGeometry x="-0.6667" y="55" width="50" height="50" relative="1" as="geometry">
+                        <mxPoint x="530" y="310" as="sourcePoint"/>
+                        <mxPoint x="580" y="260" as="targetPoint"/>
+                        <Array as="points">
+                            <mxPoint x="505" y="80"/>
+                            <mxPoint x="505" y="80"/>
+                        </Array>
+                        <mxPoint as="offset"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="encryption_box1" value="加密数据传输" style="shape=hexagon;perimeter=hexagonPerimeter2;whiteSpace=wrap;html=1;fixedSize=1;fillColor=#e1d5e7;strokeColor=#9673a6;fontStyle=1;fontSize=12;" parent="1" vertex="1">
+                    <mxGeometry x="260" y="230" width="120" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="encryption_box2" value="加密数据传输" style="shape=hexagon;perimeter=hexagonPerimeter2;whiteSpace=wrap;html=1;fixedSize=1;fillColor=#e1d5e7;strokeColor=#9673a6;fontStyle=1;fontSize=12;" parent="1" vertex="1">
+                    <mxGeometry x="560" y="230" width="120" height="40" as="geometry"/>
+                </mxCell>
+                <mxCell id="security_box" value="安全保障" style="swimlane;fontStyle=1;childLayout=stackLayout;horizontal=1;startSize=26;fillColor=#e1d5e7;horizontalStack=0;resizeParent=1;resizeParentMax=0;resizeLast=0;collapsible=1;marginBottom=0;strokeColor=#9673a6;fontSize=14;" parent="1" vertex="1">
+                    <mxGeometry x="380" y="380" width="180" height="130" as="geometry"/>
+                </mxCell>
+                <mxCell id="security_item1" value="• OAuth 2.0 身份认证授权" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;fontSize=12;" parent="security_box" vertex="1">
+                    <mxGeometry y="26" width="180" height="26" as="geometry"/>
+                </mxCell>
+                <mxCell id="security_item2" value="• HTTPS 传输层加密" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;fontSize=12;" parent="security_box" vertex="1">
+                    <mxGeometry y="52" width="180" height="26" as="geometry"/>
+                </mxCell>
+                <mxCell id="security_item3" value="• AES 业务数据加密" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;fontSize=12;" parent="security_box" vertex="1">
+                    <mxGeometry y="78" width="180" height="26" as="geometry"/>
+                </mxCell>
+                <mxCell id="security_item4" value="• 防流量劫持和抓包分析" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;fontSize=12;" parent="security_box" vertex="1">
+                    <mxGeometry y="104" width="180" height="26" as="geometry"/>
+                </mxCell>
+                <mxCell id="aes_callout" value="AES加密算法&#xa;所有业务字段加密传输" style="shape=callout;whiteSpace=wrap;html=1;perimeter=calloutPerimeter;fillColor=#fff2cc;strokeColor=#d6b656;size=30;position=0.42;base=20;fontSize=11;fontStyle=1" parent="1" vertex="1">
+                    <mxGeometry x="400" y="170" width="140" height="70" as="geometry"/>
+                </mxCell>
+                <mxCell id="title" value="API数据联盟网关平台 - 安全架构" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=18;fontStyle=1" parent="1" vertex="1">
+                    <mxGeometry x="310" y="30" width="320" height="30" as="geometry"/>
+                </mxCell>
+                <mxCell id="hacker" value="黑客" style="shape=umlActor;verticalLabelPosition=bottom;verticalAlign=top;html=1;outlineConnect=0;fillColor=#f5f5f5;strokeColor=#666666;fontColor=#333333;" parent="1" vertex="1">
+                    <mxGeometry x="290" y="370" width="30" height="60" as="geometry"/>
+                </mxCell>
+                <mxCell id="hack_attempt" value="" style="endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=0.5;exitDx=0;exitDy=0;exitPerimeter=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;dashed=1;strokeWidth=1;strokeColor=#FF0000;" parent="1" edge="1">
+                    <mxGeometry width="50" height="50" relative="1" as="geometry">
+                        <mxPoint x="315" y="400" as="sourcePoint"/>
+                        <mxPoint x="330" y="270" as="targetPoint"/>
+                    </mxGeometry>
+                </mxCell>
+                <mxCell id="block_sign" value="" style="shape=umlDestroy;whiteSpace=wrap;html=1;strokeWidth=3;strokeColor=#FF0000;fillColor=#f8cecc;" parent="1" vertex="1">
+                    <mxGeometry x="300" y="300" width="30" height="30" as="geometry"/>
+                </mxCell>
+            </root>
+        </mxGraphModel>
+    </diagram>
+</mxfile>
\ No newline at end of file
diff --git a/security/oauth2_and_encryption.drawio b/security/oauth2_and_encryption.drawio
new file mode 100644
index 000000000..d7e77ffb3
--- /dev/null
+++ b/security/oauth2_and_encryption.drawio
@@ -0,0 +1,114 @@
+<mxfile host="app.diagrams.net" modified="2023-11-10T10:00:00.000Z" agent="5.0 (Macintosh)" etag="abcdefgh12345" version="21.0.2" type="device">
+  <diagram id="security_architecture" name="安全架构：OAuth2.0和数据加密">
+    <mxGraphModel dx="1186" dy="819" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="1169" pageHeight="827" math="0" shadow="0">
+      <root>
+        <mxCell id="0" />
+        <mxCell id="1" parent="0" />
+        
+        <!-- 标题 -->
+        <mxCell id="title" value="安全架构：OAuth2.0 认证与数据加密方案" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=20;fontStyle=1" vertex="1" parent="1">
+          <mxGeometry x="284.5" y="20" width="600" height="40" as="geometry" />
+        </mxCell>
+        
+        <!-- 系统组件 -->
+        <mxCell id="client" value="客户端应用" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" vertex="1" parent="1">
+          <mxGeometry x="160" y="200" width="120" height="60" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="resource_server" value="资源服务器" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#d5e8d4;strokeColor=#82b366;" vertex="1" parent="1">
+          <mxGeometry x="800" y="200" width="120" height="60" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="auth_server" value="授权服务器" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1">
+          <mxGeometry x="480" y="120" width="120" height="60" as="geometry" />
+        </mxCell>
+        
+        <!-- HTTPS 层 -->
+        <mxCell id="https_layer" value="HTTPS 安全传输层" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#f5f5f5;strokeColor=#666666;dashed=1;verticalAlign=top;fontColor=#333333;" vertex="1" parent="1">
+          <mxGeometry x="120" y="320" width="840" height="140" as="geometry" />
+        </mxCell>
+        
+        <!-- OAuth 流程 -->
+        <mxCell id="step1" value="1. 授权请求" style="endArrow=classic;html=1;rounded=0;exitX=1;exitY=0.25;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" edge="1" parent="1" source="client" target="auth_server">
+          <mxGeometry x="-0.0039" width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="550" y="370" as="sourcePoint" />
+            <mxPoint x="600" y="320" as="targetPoint" />
+            <Array as="points">
+              <mxPoint x="350" y="150" />
+            </Array>
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        
+        <mxCell id="step2" value="2. 授权码/令牌" style="endArrow=classic;html=1;rounded=0;exitX=0;exitY=0.75;exitDx=0;exitDy=0;entryX=1;entryY=0.25;entryDx=0;entryDy=0;dashed=1;" edge="1" parent="1" source="auth_server" target="client">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="550" y="370" as="sourcePoint" />
+            <mxPoint x="600" y="320" as="targetPoint" />
+            <Array as="points">
+              <mxPoint x="350" y="180" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        
+        <mxCell id="step4" value="4. 返回受保护资源(AES加密数据)" style="endArrow=classic;html=1;rounded=0;exitX=0;exitY=0.75;exitDx=0;exitDy=0;entryX=1;entryY=0.75;entryDx=0;entryDy=0;dashed=1;" edge="1" parent="1" source="resource_server" target="client">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="550" y="370" as="sourcePoint" />
+            <mxPoint x="600" y="320" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        
+        <mxCell id="step3" value="3. 携带访问令牌请求资源" style="endArrow=classic;html=1;rounded=0;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" edge="1" parent="1" source="client" target="resource_server">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="550" y="370" as="sourcePoint" />
+            <mxPoint x="600" y="320" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        
+        <mxCell id="token_validation" value="3.1 验证令牌" style="endArrow=classic;startArrow=classic;html=1;rounded=0;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=1;entryY=0.5;entryDx=0;entryDy=0;" edge="1" parent="1" source="resource_server" target="auth_server">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="550" y="370" as="sourcePoint" />
+            <mxPoint x="600" y="320" as="targetPoint" />
+            <Array as="points">
+              <mxPoint x="860" y="150" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        
+        <!-- 数据加密详情 -->
+        <mxCell id="aes_encryption" value="AES 加密业务数据" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#fff2cc;strokeColor=#d6b656;" vertex="1" parent="1">
+          <mxGeometry x="200" y="360" width="120" height="60" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="ssl_tls" value="SSL/TLS 加密" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#fff2cc;strokeColor=#d6b656;" vertex="1" parent="1">
+          <mxGeometry x="440" y="360" width="120" height="60" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="packet_protection" value="防流量劫持和抓包分析" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#fff2cc;strokeColor=#d6b656;" vertex="1" parent="1">
+          <mxGeometry x="680" y="360" width="120" height="60" as="geometry" />
+        </mxCell>
+        
+        <!-- 安全层描述 -->
+        <mxCell id="security_layers" value="安全防护层次" style="swimlane;fontStyle=0;childLayout=stackLayout;horizontal=1;startSize=30;horizontalStack=0;resizeParent=1;resizeParentMax=0;resizeLast=0;collapsible=1;marginBottom=0;whiteSpace=wrap;html=1;fillColor=#f8cecc;strokeColor=#b85450;" vertex="1" parent="1">
+          <mxGeometry x="400" y="500" width="280" height="150" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="layer1" value="1. OAuth2.0: 身份认证与授权" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=middle;spacingLeft=4;spacingRight=4;overflow=hidden;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;rotatable=0;whiteSpace=wrap;html=1;" vertex="1" parent="security_layers">
+          <mxGeometry y="30" width="280" height="30" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="layer2" value="2. HTTPS/SSL: 传输层加密" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=middle;spacingLeft=4;spacingRight=4;overflow=hidden;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;rotatable=0;whiteSpace=wrap;html=1;" vertex="1" parent="security_layers">
+          <mxGeometry y="60" width="280" height="30" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="layer3" value="3. AES: 业务数据加密" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=middle;spacingLeft=4;spacingRight=4;overflow=hidden;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;rotatable=0;whiteSpace=wrap;html=1;" vertex="1" parent="security_layers">
+          <mxGeometry y="90" width="280" height="30" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="layer4" value="4. 防护: 抵御流量劫持和抓包分析" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=middle;spacingLeft=4;spacingRight=4;overflow=hidden;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;rotatable=0;whiteSpace=wrap;html=1;" vertex="1" parent="security_layers">
+          <mxGeometry y="120" width="280" height="30" as="geometry" />
+        </mxCell>
+        
+      </root>
+    </mxGraphModel>
+  </diagram>
+</mxfile>
diff --git a/security/oauth2_and_encryption_diagram.drawio b/security/oauth2_and_encryption_diagram.drawio
new file mode 100644
index 000000000..4bc9f6ffc
--- /dev/null
+++ b/security/oauth2_and_encryption_diagram.drawio
@@ -0,0 +1,199 @@
+<mxfile host="app.diagrams.net" modified="2023-11-01T12:00:00.000Z" agent="5.0 (Macintosh)" etag="abc123" version="15.5.0" type="device">
+  <diagram id="security_flow" name="OAuth2.0和数据加密方案">
+    <mxGraphModel dx="1422" dy="762" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="1100" pageHeight="850" math="0" shadow="0">
+      <root>
+        <mxCell id="0" />
+        <mxCell id="1" parent="0" />
+        
+        <!-- 标题 -->
+        <mxCell id="title" value="OAuth 2.0 授权和数据加密方案" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=24;fontStyle=1" vertex="1" parent="1">
+          <mxGeometry x="300" y="20" width="500" height="40" as="geometry" />
+        </mxCell>
+        
+        <!-- OAuth 2.0 部分 -->
+        <mxCell id="oauth_title" value="OAuth 2.0 授权流程" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=18;fontStyle=1" vertex="1" parent="1">
+          <mxGeometry x="300" y="70" width="200" height="30" as="geometry" />
+        </mxCell>
+        
+        <!-- 角色定义 -->
+        <mxCell id="client_app" value="客户端应用&#xa;Client App" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#dae8fc;strokeColor=#6c8ebf;fontSize=14;" vertex="1" parent="1">
+          <mxGeometry x="100" y="130" width="120" height="60" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="resource_owner" value="资源所有者&#xa;Resource Owner" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#d5e8d4;strokeColor=#82b366;fontSize=14;" vertex="1" parent="1">
+          <mxGeometry x="340" y="130" width="120" height="60" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="auth_server" value="授权服务器&#xa;Authorization Server" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#ffe6cc;strokeColor=#d79b00;fontSize=14;" vertex="1" parent="1">
+          <mxGeometry x="580" y="130" width="120" height="60" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="resource_server" value="资源服务器&#xa;Resource Server" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#fff2cc;strokeColor=#d6b656;fontSize=14;" vertex="1" parent="1">
+          <mxGeometry x="820" y="130" width="120" height="60" as="geometry" />
+        </mxCell>
+        
+        <!-- OAuth流程 -->
+        <mxCell id="step1" value="1. 授权请求" style="endArrow=classic;html=1;rounded=0;exitX=1;exitY=0.25;exitDx=0;exitDy=0;entryX=0;entryY=0.25;entryDx=0;entryDy=0;fontSize=12;" edge="1" parent="1" source="client_app" target="resource_owner">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="270" y="160" as="sourcePoint" />
+            <mxPoint x="320" y="110" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        
+        <mxCell id="step2" value="2. 用户授权" style="endArrow=classic;html=1;rounded=0;exitX=1;exitY=0.25;exitDx=0;exitDy=0;entryX=0;entryY=0.25;entryDx=0;entryDy=0;fontSize=12;" edge="1" parent="1" source="resource_owner" target="auth_server">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="510" y="160" as="sourcePoint" />
+            <mxPoint x="560" y="110" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        
+        <mxCell id="step3" value="3. 授权码" style="endArrow=classic;html=1;rounded=0;exitX=0;exitY=0.5;exitDx=0;exitDy=0;entryX=1;entryY=0.5;entryDx=0;entryDy=0;dashed=1;fontSize=12;" edge="1" parent="1" source="auth_server" target="resource_owner">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="510" y="210" as="sourcePoint" />
+            <mxPoint x="560" y="160" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        
+        <mxCell id="step4" value="4. 授权码" style="endArrow=classic;html=1;rounded=0;exitX=0;exitY=0.5;exitDx=0;exitDy=0;entryX=1;entryY=0.5;entryDx=0;entryDy=0;dashed=1;fontSize=12;" edge="1" parent="1" source="resource_owner" target="client_app">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="270" y="210" as="sourcePoint" />
+            <mxPoint x="320" y="160" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        
+        <mxCell id="step5" value="5. 令牌请求&#xa;(授权码+Client Secret)" style="endArrow=classic;html=1;rounded=0;exitX=1;exitY=0.75;exitDx=0;exitDy=0;fontSize=12;entryX=0;entryY=0.75;entryDx=0;entryDy=0;" edge="1" parent="1" source="client_app" target="auth_server">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="270" y="260" as="sourcePoint" />
+            <mxPoint x="580" y="175" as="targetPoint" />
+            <Array as="points">
+              <mxPoint x="400" y="230" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        
+        <mxCell id="step6" value="6. 访问令牌+刷新令牌" style="endArrow=classic;html=1;rounded=0;exitX=0;exitY=1;exitDx=0;exitDy=0;entryX=1;entryY=1;entryDx=0;entryDy=0;dashed=1;fontSize=12;" edge="1" parent="1" source="auth_server" target="client_app">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="400" y="300" as="sourcePoint" />
+            <mxPoint x="450" y="250" as="targetPoint" />
+            <Array as="points">
+              <mxPoint x="400" y="260" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        
+        <mxCell id="step7" value="7. API请求+访问令牌" style="endArrow=classic;html=1;rounded=0;exitX=1;exitY=1;exitDx=0;exitDy=0;entryX=0;entryY=1;entryDx=0;entryDy=0;fontSize=12;" edge="1" parent="1" source="client_app" target="resource_server">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="400" y="300" as="sourcePoint" />
+            <mxPoint x="450" y="250" as="targetPoint" />
+            <Array as="points">
+              <mxPoint x="400" y="290" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        
+        <mxCell id="step8" value="8. 返回受保护资源" style="endArrow=classic;html=1;rounded=0;exitX=0;exitY=1;exitDx=0;exitDy=0;dashed=1;fontSize=12;entryX=1;entryY=1;entryDx=0;entryDy=0;" edge="1" parent="1" source="resource_server" target="client_app">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="400" y="300" as="sourcePoint" />
+            <mxPoint x="220" y="190" as="targetPoint" />
+            <Array as="points">
+              <mxPoint x="400" y="320" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        
+        <!-- 数据加密部分 -->
+        <mxCell id="encryption_title" value="数据加密方案" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=18;fontStyle=1" vertex="1" parent="1">
+          <mxGeometry x="300" y="380" width="200" height="30" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="platform_a" value="平台 A" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#f8cecc;strokeColor=#b85450;fontSize=14;" vertex="1" parent="1">
+          <mxGeometry x="180" y="460" width="120" height="60" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="platform_b" value="平台 B" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#e1d5e7;strokeColor=#9673a6;fontSize=14;" vertex="1" parent="1">
+          <mxGeometry x="680" y="460" width="120" height="60" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="https_layer" value="HTTPS 安全层" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#dae8fc;strokeColor=#6c8ebf;fontSize=14;dashed=1;" vertex="1" parent="1">
+          <mxGeometry x="140" y="560" width="700" height="40" as="geometry" />
+        </mxCell>
+        
+        <!-- 加密流程 -->
+        <mxCell id="data_encrypt_request" value="1. 业务数据(AES加密)" style="endArrow=classic;html=1;rounded=0;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=12;" edge="1" parent="1" source="platform_a" target="platform_b">
+          <mxGeometry x="-0.0476" y="15" width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="490" y="500" as="sourcePoint" />
+            <mxPoint x="540" y="450" as="targetPoint" />
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        
+        <mxCell id="data_decrypt_response" value="2. 响应数据(AES加密)" style="endArrow=classic;html=1;rounded=0;exitX=0;exitY=0.75;exitDx=0;exitDy=0;entryX=1;entryY=0.75;entryDx=0;entryDy=0;fontSize=12;" edge="1" parent="1" source="platform_b" target="platform_a">
+          <mxGeometry x="-0.0476" y="-15" width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="490" y="500" as="sourcePoint" />
+            <mxPoint x="540" y="450" as="targetPoint" />
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        
+        <!-- 加密图示 -->
+        <mxCell id="encryption_detail" value="" style="rounded=0;whiteSpace=wrap;html=1;fillColor=#f5f5f5;strokeColor=#666666;fontSize=12;dashed=1;fontColor=#333333;" vertex="1" parent="1">
+          <mxGeometry x="300" y="620" width="400" height="180" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="encryption_title_detail" value="AES 加密过程" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=14;fontStyle=1" vertex="1" parent="1">
+          <mxGeometry x="420" y="630" width="160" height="20" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="plaintext" value="明文数据" style="shape=document;whiteSpace=wrap;html=1;boundedLbl=1;fillColor=#d5e8d4;strokeColor=#82b366;fontSize=12;" vertex="1" parent="1">
+          <mxGeometry x="320" y="660" width="80" height="50" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="aes_key" value="AES密钥" style="shape=hexagon;perimeter=hexagonPerimeter2;whiteSpace=wrap;html=1;fixedSize=1;fillColor=#fff2cc;strokeColor=#d6b656;fontSize=12;" vertex="1" parent="1">
+          <mxGeometry x="430" y="700" width="100" height="40" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="ciphertext" value="密文数据" style="shape=document;whiteSpace=wrap;html=1;boundedLbl=1;fillColor=#f8cecc;strokeColor=#b85450;fontSize=12;" vertex="1" parent="1">
+          <mxGeometry x="600" y="660" width="80" height="50" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="encrypt_process" value="AES 加密" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#ffe6cc;strokeColor=#d79b00;fontSize=12;" vertex="1" parent="1">
+          <mxGeometry x="440" y="660" width="80" height="30" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="arrow1" value="" style="endArrow=classic;html=1;rounded=0;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=12;" edge="1" parent="1" source="plaintext" target="encrypt_process">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="490" y="700" as="sourcePoint" />
+            <mxPoint x="540" y="650" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        
+        <mxCell id="arrow2" value="" style="endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;fontSize=12;" edge="1" parent="1" source="aes_key" target="encrypt_process">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="490" y="700" as="sourcePoint" />
+            <mxPoint x="540" y="650" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        
+        <mxCell id="arrow3" value="" style="endArrow=classic;html=1;rounded=0;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;fontSize=12;" edge="1" parent="1" source="encrypt_process" target="ciphertext">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="490" y="700" as="sourcePoint" />
+            <mxPoint x="540" y="650" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        
+        <mxCell id="flow_within_https" value="注：所有通信均在HTTPS协议内进行，提供TLS/SSL加密保护" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=12;fontStyle=2" vertex="1" parent="1">
+          <mxGeometry x="320" y="750" width="360" height="20" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="note_https_aes" value="HTTPS保护传输层，AES加密保护业务数据层，双重保障数据安全" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=12;fontStyle=2" vertex="1" parent="1">
+          <mxGeometry x="320" y="770" width="360" height="20" as="geometry" />
+        </mxCell>
+        
+        <mxCell id="security_label" value="防止流量劫持和抓包分析" style="text;html=1;strokeColor=#b85450;fillColor=#f8cecc;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=1;fontSize=12;" vertex="1" parent="1">
+          <mxGeometry x="420" y="520" width="160" height="20" as="geometry" />
+        </mxCell>
+        
+      </root>
+    </mxGraphModel>
+  </diagram>
+</mxfile>

From 5ce1c045569ec2565a463c1b25f5d82071298212 Mon Sep 17 00:00:00 2001
From: JavaEdge <sss2855845850@gmail.com>
Date: Wed, 16 Apr 2025 11:08:56 +0800
Subject: [PATCH 14/20] =?UTF-8?q?docs:=E7=A7=BB=E9=99=A4=E6=97=A0=E7=94=A8?=
 =?UTF-8?q?=E6=96=87=E4=BB=B6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 api-gateway-architecture.drawio          | 105 ---------------------
 api_gateway_architecture.drawio          |  12 ---
 api_gateway_security_architecture.drawio | 113 -----------------------
 3 files changed, 230 deletions(-)
 delete mode 100644 api-gateway-architecture.drawio
 delete mode 100644 api_gateway_architecture.drawio
 delete mode 100644 api_gateway_security_architecture.drawio

diff --git a/api-gateway-architecture.drawio b/api-gateway-architecture.drawio
deleted file mode 100644
index d3778c709..000000000
--- a/api-gateway-architecture.drawio
+++ /dev/null
@@ -1,105 +0,0 @@
-<mxfile host="65bd71144e">
-    <diagram id="C5RBs43oDa-KdzZeNtuy" name="API Gateway Architecture">
-        <mxGraphModel dx="1468" dy="626" grid="0" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="1169" pageHeight="827" math="0" shadow="0">
-            <root>
-                <mxCell id="WIyWlLk6GJQsqaUBKTNV-0"/>
-                <mxCell id="WIyWlLk6GJQsqaUBKTNV-1" parent="WIyWlLk6GJQsqaUBKTNV-0"/>
-                <mxCell id="title-1" value="联盟平台API治理" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=24;fontStyle=1" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
-                    <mxGeometry x="415" y="50" width="340" height="40" as="geometry"/>
-                </mxCell>
-                <mxCell id="client-group" value="客户端" style="swimlane;fontStyle=1;align=center;verticalAlign=top;childLayout=stackLayout;horizontal=1;startSize=26;horizontalStack=0;resizeParent=1;resizeLast=0;collapsible=1;marginBottom=0;rounded=0;shadow=0;strokeWidth=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
-                    <mxGeometry x="30" y="145" width="180" height="150" as="geometry"/>
-                </mxCell>
-                <mxCell id="client-web" value="&lt;div&gt;&lt;br&gt;&lt;/div&gt;Web应用" style="verticalAlign=middle;align=center;overflow=fill;fontSize=12;fontFamily=Helvetica;html=1;rounded=1;fontStyle=1;strokeWidth=3;fillColor=#E6FFCC" parent="client-group" vertex="1">
-                    <mxGeometry y="26" width="180" height="40" as="geometry"/>
-                </mxCell>
-                <mxCell id="client-mobile" value="&lt;div&gt;&lt;br&gt;&lt;/div&gt;移动应用" style="verticalAlign=middle;align=center;overflow=fill;fontSize=12;fontFamily=Helvetica;html=1;rounded=1;fontStyle=1;strokeWidth=3;fillColor=#E6FFCC" parent="client-group" vertex="1">
-                    <mxGeometry y="66" width="180" height="40" as="geometry"/>
-                </mxCell>
-                <mxCell id="client-iot" value="&lt;div&gt;&lt;br&gt;&lt;/div&gt;IoT设备" style="verticalAlign=middle;align=center;overflow=fill;fontSize=12;fontFamily=Helvetica;html=1;rounded=1;fontStyle=1;strokeWidth=3;fillColor=#E6FFCC" parent="client-group" vertex="1">
-                    <mxGeometry y="106" width="180" height="40" as="geometry"/>
-                </mxCell>
-                <mxCell id="gateway-main" value="API网关" style="swimlane;fontStyle=1;align=center;verticalAlign=top;childLayout=stackLayout;horizontal=1;startSize=26;horizontalStack=0;resizeParent=1;resizeLast=0;collapsible=1;marginBottom=0;rounded=0;shadow=0;strokeWidth=1;fillColor=#f8cecc;strokeColor=#b85450;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
-                    <mxGeometry x="310" y="100" width="550" height="240" as="geometry"/>
-                </mxCell>
-                <mxCell id="security-layer" value="安全管理层" style="swimlane;fontStyle=1;align=center;verticalAlign=top;childLayout=stackLayout;horizontal=1;startSize=26;horizontalStack=0;resizeParent=1;resizeLast=0;collapsible=1;marginBottom=0;rounded=0;shadow=0;strokeWidth=1;fillColor=#fff2cc;strokeColor=#d6b656;" parent="gateway-main" vertex="1">
-                    <mxGeometry x="20" y="40" width="160" height="160" as="geometry"/>
-                </mxCell>
-                <mxCell id="sec-auth" value="认证 (Authentication)" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" parent="security-layer" vertex="1">
-                    <mxGeometry y="36" width="160" height="30" as="geometry"/>
-                </mxCell>
-                <mxCell id="sec-authz" value="授权 (Authorization)" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" parent="security-layer" vertex="1">
-                    <mxGeometry y="76" width="160" height="30" as="geometry"/>
-                </mxCell>
-                <mxCell id="sec-encryption" value="加密 (SSL/TLS)" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" parent="security-layer" vertex="1">
-                    <mxGeometry y="116" width="160" height="30" as="geometry"/>
-                </mxCell>
-                <mxCell id="traffic-layer" value="流量控制层" style="swimlane;fontStyle=1;align=center;verticalAlign=top;childLayout=stackLayout;horizontal=1;startSize=26;horizontalStack=0;resizeParent=1;resizeLast=0;collapsible=1;marginBottom=0;rounded=0;shadow=0;strokeWidth=1;fillColor=#fff2cc;strokeColor=#d6b656;" parent="gateway-main" vertex="1">
-                    <mxGeometry x="195" y="40" width="160" height="160" as="geometry"/>
-                </mxCell>
-                <mxCell id="traffic-rate" value="限流 (Rate Limiting)" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" parent="traffic-layer" vertex="1">
-                    <mxGeometry y="36" width="160" height="30" as="geometry"/>
-                </mxCell>
-                <mxCell id="traffic-circuit" value="熔断 (Circuit Breaking)" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" parent="traffic-layer" vertex="1">
-                    <mxGeometry y="76" width="160" height="30" as="geometry"/>
-                </mxCell>
-                <mxCell id="traffic-load" value="负载均衡" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" parent="traffic-layer" vertex="1">
-                    <mxGeometry y="116" width="160" height="30" as="geometry"/>
-                </mxCell>
-                <mxCell id="routing-layer" value="请求路由层" style="swimlane;fontStyle=1;align=center;verticalAlign=top;childLayout=stackLayout;horizontal=1;startSize=26;horizontalStack=0;resizeParent=1;resizeLast=0;collapsible=1;marginBottom=0;rounded=0;shadow=0;strokeWidth=1;fillColor=#fff2cc;strokeColor=#d6b656;" parent="gateway-main" vertex="1">
-                    <mxGeometry x="370" y="40" width="160" height="160" as="geometry"/>
-                </mxCell>
-                <mxCell id="routing-endpoint" value="路径映射" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" parent="routing-layer" vertex="1">
-                    <mxGeometry y="36" width="160" height="30" as="geometry"/>
-                </mxCell>
-                <mxCell id="routing-transform" value="数据转换" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" parent="routing-layer" vertex="1">
-                    <mxGeometry y="76" width="160" height="30" as="geometry"/>
-                </mxCell>
-                <mxCell id="routing-protocol" value="协议转换" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#f5f5f5;fontColor=#333333;strokeColor=#666666;" parent="routing-layer" vertex="1">
-                    <mxGeometry y="116" width="160" height="30" as="geometry"/>
-                </mxCell>
-                <mxCell id="backend-group" value="后端服务" style="swimlane;fontStyle=1;align=center;verticalAlign=top;childLayout=stackLayout;horizontal=1;startSize=26;horizontalStack=0;resizeParent=1;resizeLast=0;collapsible=1;marginBottom=0;rounded=0;shadow=0;strokeWidth=1;fillColor=#d5e8d4;strokeColor=#82b366;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
-                    <mxGeometry x="310" y="390" width="550" height="160" as="geometry"/>
-                </mxCell>
-                <mxCell id="backend-rest" value="RESTful 微服务" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#e1d5e7;strokeColor=#9673a6;" parent="backend-group" vertex="1">
-                    <mxGeometry x="40" y="56" width="120" height="60" as="geometry"/>
-                </mxCell>
-                <mxCell id="backend-grpc" value="gRPC 服务" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#e1d5e7;strokeColor=#9673a6;" parent="backend-group" vertex="1">
-                    <mxGeometry x="215" y="56" width="120" height="60" as="geometry"/>
-                </mxCell>
-                <mxCell id="backend-legacy" value="遗留系统" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#e1d5e7;strokeColor=#9673a6;" parent="backend-group" vertex="1">
-                    <mxGeometry x="390" y="56" width="120" height="60" as="geometry"/>
-                </mxCell>
-                <mxCell id="support-group" value="支持系统" style="swimlane;fontStyle=1;align=center;verticalAlign=top;childLayout=stackLayout;horizontal=1;startSize=26;horizontalStack=0;resizeParent=1;resizeLast=0;collapsible=1;marginBottom=0;rounded=0;shadow=0;strokeWidth=1;fillColor=#e1d5e7;strokeColor=#9673a6;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
-                    <mxGeometry x="950" y="145" width="180" height="150" as="geometry"/>
-                </mxCell>
-                <mxCell id="support-monitor" value="&lt;div&gt;&lt;br&gt;&lt;/div&gt;监控系统" style="verticalAlign=middle;align=center;overflow=fill;fontSize=12;fontFamily=Helvetica;html=1;rounded=1;fontStyle=1;strokeWidth=3;fillColor=#ffe6cc;strokeColor=#d79b00" parent="support-group" vertex="1">
-                    <mxGeometry y="26" width="180" height="40" as="geometry"/>
-                </mxCell>
-                <mxCell id="support-logging" value="&lt;div&gt;&lt;br&gt;&lt;/div&gt;日志系统" style="verticalAlign=middle;align=center;overflow=fill;fontSize=12;fontFamily=Helvetica;html=1;rounded=1;fontStyle=1;strokeWidth=3;fillColor=#ffe6cc;strokeColor=#d79b00" parent="support-group" vertex="1">
-                    <mxGeometry y="66" width="180" height="40" as="geometry"/>
-                </mxCell>
-                <mxCell id="support-config" value="&lt;div&gt;&lt;br&gt;&lt;/div&gt;配置中心" style="verticalAlign=middle;align=center;overflow=fill;fontSize=12;fontFamily=Helvetica;html=1;rounded=1;fontStyle=1;strokeWidth=3;fillColor=#ffe6cc;strokeColor=#d79b00" parent="support-group" vertex="1">
-                    <mxGeometry y="106" width="180" height="40" as="geometry"/>
-                </mxCell>
-                <mxCell id="client-to-gateway" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;startArrow=none;startFill=0;endArrow=classic;endFill=1;strokeWidth=2;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="client-group" target="gateway-main" edge="1">
-                    <mxGeometry relative="1" as="geometry"/>
-                </mxCell>
-                <mxCell id="client-protocol" value="HTTP/HTTPS&#xa;RESTful" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];fontStyle=1" parent="client-to-gateway" vertex="1" connectable="0">
-                    <mxGeometry x="-0.1538" y="1" relative="1" as="geometry">
-                        <mxPoint y="-19" as="offset"/>
-                    </mxGeometry>
-                </mxCell>
-                <mxCell id="gateway-to-backend" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;startArrow=none;startFill=0;endArrow=classic;endFill=1;strokeWidth=2;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="gateway-main" target="backend-group" edge="1">
-                    <mxGeometry relative="1" as="geometry"/>
-                </mxCell>
-                <mxCell id="gateway-to-support" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;startArrow=classic;startFill=1;endArrow=classic;endFill=1;strokeWidth=2;" parent="WIyWlLk6GJQsqaUBKTNV-1" source="gateway-main" target="support-group" edge="1">
-                    <mxGeometry relative="1" as="geometry"/>
-                </mxCell>
-                <mxCell id="note-protocol" value="协议标准：RESTful API, HTTP/HTTPS" style="shape=note;strokeWidth=2;fontSize=14;size=20;whiteSpace=wrap;html=1;fillColor=#fff2cc;strokeColor=#d6b656;fontColor=#666600;fontStyle=1" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
-                    <mxGeometry x="310" y="580" width="550" height="40" as="geometry"/>
-                </mxCell>
-            </root>
-        </mxGraphModel>
-    </diagram>
-</mxfile>
\ No newline at end of file
diff --git a/api_gateway_architecture.drawio b/api_gateway_architecture.drawio
deleted file mode 100644
index c65e10902..000000000
--- a/api_gateway_architecture.drawio
+++ /dev/null
@@ -1,12 +0,0 @@
-<mxfile host="65bd71144e">
-    <diagram id="C5RBs43oDa-KdzZeNtuy" name="API Gateway Architecture">
-        <mxGraphModel dx="600" dy="557" grid="0" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="0" pageScale="1" pageWidth="827" pageHeight="1169" math="0" shadow="0">
-            <root>
-                <mxPoint x="343" y="383" as="targetPoint" id="0">
-                    <mxCell/>
-                </mxPoint>
-                <mxCell id="1" parent="0"/>
-            </root>
-        </mxGraphModel>
-    </diagram>
-</mxfile>
\ No newline at end of file
diff --git a/api_gateway_security_architecture.drawio b/api_gateway_security_architecture.drawio
deleted file mode 100644
index 19c8bb6eb..000000000
--- a/api_gateway_security_architecture.drawio
+++ /dev/null
@@ -1,113 +0,0 @@
-<mxfile host="65bd71144e">
-    <diagram id="API_Gateway_Security" name="API Gateway Security Architecture">
-        <mxGraphModel dx="997" dy="519" grid="0" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="0" pageScale="1" pageWidth="1169" pageHeight="827" math="0" shadow="0">
-            <root>
-                <mxCell id="0"/>
-                <mxCell id="1" parent="0"/>
-                <mxCell id="client_app" value="客户端应用" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#dae8fc;strokeColor=#6c8ebf;fontStyle=1;fontSize=14;" parent="1" vertex="1">
-                    <mxGeometry x="120" y="280" width="120" height="60" as="geometry"/>
-                </mxCell>
-                <mxCell id="api_gateway" value="API数据联盟网关平台" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#f8cecc;strokeColor=#b85450;fontStyle=1;fontSize=14;" parent="1" vertex="1">
-                    <mxGeometry x="400" y="280" width="140" height="60" as="geometry"/>
-                </mxCell>
-                <mxCell id="resource_server" value="资源服务器" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#d5e8d4;strokeColor=#82b366;fontStyle=1;fontSize=14;" parent="1" vertex="1">
-                    <mxGeometry x="680" y="280" width="120" height="60" as="geometry"/>
-                </mxCell>
-                <mxCell id="auth_server" value="授权服务器&#xa;(OAuth 2.0)" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#ffe6cc;strokeColor=#d79b00;fontStyle=1;fontSize=14;" parent="1" vertex="1">
-                    <mxGeometry x="400" y="120" width="140" height="60" as="geometry"/>
-                </mxCell>
-                <mxCell id="https_client_gateway" value="HTTPS" style="endArrow=classic;startArrow=classic;html=1;rounded=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;exitX=1;exitY=0.5;exitDx=0;exitDy=0;strokeWidth=2;fontSize=12;fontStyle=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" parent="1" source="client_app" target="api_gateway" edge="1">
-                    <mxGeometry width="50" height="50" relative="1" as="geometry">
-                        <mxPoint x="260" y="310" as="sourcePoint"/>
-                        <mxPoint x="310" y="260" as="targetPoint"/>
-                    </mxGeometry>
-                </mxCell>
-                <mxCell id="https_gateway_resource" value="HTTPS" style="endArrow=classic;startArrow=classic;html=1;rounded=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;exitX=1;exitY=0.5;exitDx=0;exitDy=0;strokeWidth=2;fontSize=12;fontStyle=1;fillColor=#dae8fc;strokeColor=#6c8ebf;" parent="1" source="api_gateway" target="resource_server" edge="1">
-                    <mxGeometry width="50" height="50" relative="1" as="geometry">
-                        <mxPoint x="530" y="310" as="sourcePoint"/>
-                        <mxPoint x="580" y="260" as="targetPoint"/>
-                    </mxGeometry>
-                </mxCell>
-                <mxCell id="oauth_flow_1" value="1. 请求授权" style="endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=0;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;dashed=1;strokeWidth=1.5;fontSize=11;fillColor=#ffe6cc;strokeColor=#d79b00;" parent="1" source="client_app" target="auth_server" edge="1">
-                    <mxGeometry width="50" height="50" relative="1" as="geometry">
-                        <mxPoint x="530" y="310" as="sourcePoint"/>
-                        <mxPoint x="580" y="260" as="targetPoint"/>
-                        <Array as="points">
-                            <mxPoint x="180" y="150"/>
-                        </Array>
-                    </mxGeometry>
-                </mxCell>
-                <mxCell id="oauth_flow_2" value="2. 返回Token" style="endArrow=classic;html=1;rounded=0;exitX=0;exitY=0.75;exitDx=0;exitDy=0;entryX=0.25;entryY=0;entryDx=0;entryDy=0;dashed=1;strokeWidth=1.5;fontSize=11;fillColor=#ffe6cc;strokeColor=#d79b00;" parent="1" source="auth_server" target="client_app" edge="1">
-                    <mxGeometry width="50" height="50" relative="1" as="geometry">
-                        <mxPoint x="530" y="310" as="sourcePoint"/>
-                        <mxPoint x="580" y="260" as="targetPoint"/>
-                        <Array as="points">
-                            <mxPoint x="150" y="165"/>
-                        </Array>
-                    </mxGeometry>
-                </mxCell>
-                <mxCell id="oauth_flow_3" value="3. 带Token请求" style="endArrow=classic;html=1;rounded=0;exitX=0.75;exitY=0;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;dashed=1;strokeWidth=1.5;fontSize=11;fillColor=#ffe6cc;strokeColor=#d79b00;" parent="1" source="api_gateway" target="auth_server" edge="1">
-                    <mxGeometry x="0.8298" y="-20" width="50" height="50" relative="1" as="geometry">
-                        <mxPoint x="530" y="310" as="sourcePoint"/>
-                        <mxPoint x="580" y="260" as="targetPoint"/>
-                        <Array as="points">
-                            <mxPoint x="505" y="100"/>
-                            <mxPoint x="470" y="100"/>
-                        </Array>
-                        <mxPoint as="offset"/>
-                    </mxGeometry>
-                </mxCell>
-                <mxCell id="oauth_flow_4" value="4. 验证Token" style="endArrow=classic;html=1;rounded=0;exitX=0.75;exitY=0;exitDx=0;exitDy=0;entryX=0.75;entryY=0;entryDx=0;entryDy=0;dashed=1;strokeWidth=1.5;fontSize=11;fillColor=#ffe6cc;strokeColor=#d79b00;" parent="1" source="auth_server" target="api_gateway" edge="1">
-                    <mxGeometry x="-0.6667" y="55" width="50" height="50" relative="1" as="geometry">
-                        <mxPoint x="530" y="310" as="sourcePoint"/>
-                        <mxPoint x="580" y="260" as="targetPoint"/>
-                        <Array as="points">
-                            <mxPoint x="505" y="80"/>
-                            <mxPoint x="505" y="80"/>
-                        </Array>
-                        <mxPoint as="offset"/>
-                    </mxGeometry>
-                </mxCell>
-                <mxCell id="encryption_box1" value="加密数据传输" style="shape=hexagon;perimeter=hexagonPerimeter2;whiteSpace=wrap;html=1;fixedSize=1;fillColor=#e1d5e7;strokeColor=#9673a6;fontStyle=1;fontSize=12;" parent="1" vertex="1">
-                    <mxGeometry x="260" y="230" width="120" height="40" as="geometry"/>
-                </mxCell>
-                <mxCell id="encryption_box2" value="加密数据传输" style="shape=hexagon;perimeter=hexagonPerimeter2;whiteSpace=wrap;html=1;fixedSize=1;fillColor=#e1d5e7;strokeColor=#9673a6;fontStyle=1;fontSize=12;" parent="1" vertex="1">
-                    <mxGeometry x="560" y="230" width="120" height="40" as="geometry"/>
-                </mxCell>
-                <mxCell id="security_box" value="安全保障" style="swimlane;fontStyle=1;childLayout=stackLayout;horizontal=1;startSize=26;fillColor=#e1d5e7;horizontalStack=0;resizeParent=1;resizeParentMax=0;resizeLast=0;collapsible=1;marginBottom=0;strokeColor=#9673a6;fontSize=14;" parent="1" vertex="1">
-                    <mxGeometry x="380" y="380" width="180" height="130" as="geometry"/>
-                </mxCell>
-                <mxCell id="security_item1" value="• OAuth 2.0 身份认证授权" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;fontSize=12;" parent="security_box" vertex="1">
-                    <mxGeometry y="26" width="180" height="26" as="geometry"/>
-                </mxCell>
-                <mxCell id="security_item2" value="• HTTPS 传输层加密" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;fontSize=12;" parent="security_box" vertex="1">
-                    <mxGeometry y="52" width="180" height="26" as="geometry"/>
-                </mxCell>
-                <mxCell id="security_item3" value="• AES 业务数据加密" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;fontSize=12;" parent="security_box" vertex="1">
-                    <mxGeometry y="78" width="180" height="26" as="geometry"/>
-                </mxCell>
-                <mxCell id="security_item4" value="• 防流量劫持和抓包分析" style="text;strokeColor=none;fillColor=none;align=left;verticalAlign=top;spacingLeft=4;spacingRight=4;overflow=hidden;rotatable=0;points=[[0,0.5],[1,0.5]];portConstraint=eastwest;fontSize=12;" parent="security_box" vertex="1">
-                    <mxGeometry y="104" width="180" height="26" as="geometry"/>
-                </mxCell>
-                <mxCell id="aes_callout" value="AES加密算法&#xa;所有业务字段加密传输" style="shape=callout;whiteSpace=wrap;html=1;perimeter=calloutPerimeter;fillColor=#fff2cc;strokeColor=#d6b656;size=30;position=0.42;base=20;fontSize=11;fontStyle=1" parent="1" vertex="1">
-                    <mxGeometry x="400" y="170" width="140" height="70" as="geometry"/>
-                </mxCell>
-                <mxCell id="title" value="API数据联盟网关平台 - 安全架构" style="text;html=1;strokeColor=none;fillColor=none;align=center;verticalAlign=middle;whiteSpace=wrap;rounded=0;fontSize=18;fontStyle=1" parent="1" vertex="1">
-                    <mxGeometry x="310" y="30" width="320" height="30" as="geometry"/>
-                </mxCell>
-                <mxCell id="hacker" value="黑客" style="shape=umlActor;verticalLabelPosition=bottom;verticalAlign=top;html=1;outlineConnect=0;fillColor=#f5f5f5;strokeColor=#666666;fontColor=#333333;" parent="1" vertex="1">
-                    <mxGeometry x="290" y="370" width="30" height="60" as="geometry"/>
-                </mxCell>
-                <mxCell id="hack_attempt" value="" style="endArrow=classic;html=1;rounded=0;exitX=0.5;exitY=0.5;exitDx=0;exitDy=0;exitPerimeter=0;entryX=0.5;entryY=1;entryDx=0;entryDy=0;dashed=1;strokeWidth=1;strokeColor=#FF0000;" parent="1" edge="1">
-                    <mxGeometry width="50" height="50" relative="1" as="geometry">
-                        <mxPoint x="315" y="400" as="sourcePoint"/>
-                        <mxPoint x="330" y="270" as="targetPoint"/>
-                    </mxGeometry>
-                </mxCell>
-                <mxCell id="block_sign" value="" style="shape=umlDestroy;whiteSpace=wrap;html=1;strokeWidth=3;strokeColor=#FF0000;fillColor=#f8cecc;" parent="1" vertex="1">
-                    <mxGeometry x="300" y="300" width="30" height="30" as="geometry"/>
-                </mxCell>
-            </root>
-        </mxGraphModel>
-    </diagram>
-</mxfile>
\ No newline at end of file

From ebf199bbf4be03eeabfd0910a8e75c58396f1501 Mon Sep 17 00:00:00 2001
From: JavaEdge <sss2855845850@gmail.com>
Date: Fri, 18 Apr 2025 18:45:56 +0800
Subject: [PATCH 15/20] docs:update mcp

---
 docs/.vuepress/config.js                      | 4271 +++++++++--------
 .../mcp-and-the-future-of-ai-tooling.md       |    0
 docs/md/AI/{llm => mcp}/mcp-fad-or-fixture.md |    0
 docs/md/AI/mcp/resources.md                   |  236 +
 ...45\351\225\277\350\275\256\350\257\242.md" |  101 +-
 5 files changed, 2466 insertions(+), 2142 deletions(-)
 rename docs/md/AI/{llm => mcp}/mcp-and-the-future-of-ai-tooling.md (100%)
 rename docs/md/AI/{llm => mcp}/mcp-fad-or-fixture.md (100%)
 create mode 100644 docs/md/AI/mcp/resources.md

diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index 00c30cdbf..93868eb4c 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -139,2134 +139,2159 @@ module.exports = {
                 lastUpdated: "上次更新",
                 logo: `/favicon.ico`,
                 nav: [{
-                        text: '导读',
-                        link: '/md/other/guide-to-reading.md'
-                    },
-                    {
-                        text: '架构',
-                        items: [{
-                                text: '设计原则',
-                                items: [{
-                                    text: '设计原则概述',
-                                    link: '/md/design/01-单一职责原则.md'
-                                }, ]
-                            },
-                            {
-                                text: '设计模式',
-                                items: [{
-                                    text: '模板方法设计模式（Template Pattern）',
-                                    link: '/md/design/模板方法设计模式（Template Pattern）.md'
-                                }, ]
-                            },
-                            {
-                                text: '重构',
-                                items: [{
-                                    text: '00-软件架构权衡-我们为什么以及如何进行权衡？',
-                                    link: '/md/design/00-软件架构权衡-我们为什么以及如何进行权衡？.md'
-                                }, ]
-                            },
-                            {
-                                text: '大厂业务架构',
-                                items: [{
-                                    text: '00-聚合支付架构',
-                                    link: '/md/biz-arch/00-聚合支付架构从零到一'
-                                }, ]
-                            },
-                            {
-                                text: '系统设计',
-                                items: [{
-                                    text: '00-优惠券系统设计',
-                                    link: '/md/biz-arch/00-优惠券系统设计 Coupon System'
-                                }, ]
-                            },
-
-                            {
-                                text: 'DDD',
-                                items: [{
-                                        text: '00-DDD专栏规划',
-                                        link: '/md/DDD/00-DDD专栏规划.md'
-                                    },
-
-                                    {
-                                        text: '事件驱动',
-                                        link: '/md/DDD/integrating-event-driven-microservices-with-request-response-APIs.md'
-                                    },
-                                    {
-                                        text: '00-大厂实践',
-                                        link: '/md/DDD/02-领域驱动设计DDD在B端营销系统的实践.md'
-                                    },
-
-                                ]
-                            },
-
-                            {
-                                text: '数据中台',
-                                items: [{
-                                    text: '00-新一代数据栈将逐步替代国内单一“数据中台”',
-                                    link: '/md/bigdata/00-新一代数据栈将逐步替代国内单一“数据中台”.md'
-                                }, ]
-                            },
-
-                            {
-                                text: '交易中台',
-                                items: [{
-                                    text: '00-如何防止订单二次重复支付？',
-                                    link: '/md/trade/00-如何防止订单二次重复支付？.md'
-                                }, ]
-                            },
-
-                            {
-                                text: '商品中心',
-                                items: [{
-                                    text: '00-商品中心的spu、sku设计.md',
-                                    link: '/md/product-center/00-商品中心的spu、sku设计.md'
-                                }, ]
-                            },
-
-                            {
-                                text: '用户画像',
-                                items: [{
-                                    text: '01-DMP系统简介.md',
-                                    link: '/md/biz-arch/01-DMP系统简介.md'
-                                }, ]
-                            },
-
-                            {
-                                text: '低代码',
-                                items: [{
-                                    text: '为什么“低代码”是未来趋势？.md',
-                                    link: '/md/low-code/为什么“低代码”是未来趋势？.md'
-                                }, ]
-                            },
-
-
-                        ]
-                    },
-                    {
-                        text: '项目',
-                        items: [{
-                                text: '12306',
-                                items: [{
-                                    text: '项目介绍',
-                                    link: '/md/12306/12306-basic-info.md'
-                                }]
-                            },
-                            {
-                                text: 'DDD商城',
-                                items: [{
-                                    text: '什么是DDD商城',
-                                    link: '/md/ddd-mall/什么是DDD商城.md'
-                                }]
-                            },
-
-                            {
-                                text: '风控系统引擎',
-                                items: [{
-                                    text: '风控引擎架构设计',
-                                    link: '/md/risk-control/risk-control-engine-architecture-design.md'
-                                }]
-                            },
-
-                            {
-                                text: 'Go微服务网关专栏概述',
-                                items: [{
-                                    text: 'Go微服务网关专栏概述',
-                                    link: '/md/go-gateway/00-Go微服务网关专栏概述.md'
-                                }]
-                            },
-                        ]
-                    },
-
-                    {
-                        text: '框架',
-                        items: [{
-                                text: 'RPC',
-                                items: [{
-                                    text: '熔断限流',
-                                    link: '/md/rpc/熔断限流.md'
-                                }, ]
-                            },
-
-                            {
-                                text: 'Netty',
-                                items: [{
-                                        text: 'Netty基础',
-                                        link: '/md/netty/Netty基本组件.md'
-                                    },
-
-                                    {
-                                        text: 'Netty实战',
-                                        link: '/md/netty/netty-off-heap-memory-leak-detection.md'
-                                    },
-                                ]
-                            },
-
-                            {
-                                text: 'ShardingSphere',
-                                items: [{
-                                    text: 'ShardingSphere',
-                                    link: '/md/ShardingSphere/14-ShardingSphere的分布式主键实现.md'
-                                }]
-                            },
-
-                            {
-                                text: 'kafka',
-                                items: [{
-                                    text: 'kafka',
-                                    link: '/md/kafka/00-Kafka专栏大纲.md'
-                                }]
-                            },
-
-                            {
-                                text: 'RocketMQ',
-                                items: [{
-                                    text: '消息队列基础',
-                                    link: '/md/RocketMQ/消息队列面试必问解析.md'
-                                }, ]
-                            },
-
-                            {
-                                text: 'RabbitMQ',
-                                items: [{
-                                    text: 'RabbitMQ',
-                                    link: '/md/rabbitmq/00-RabbitMQ实战下载与安装.md'
-                                }, ]
-                            },
-
-                            {
-                                text: '工作流引擎',
-                                items: [{
-                                    text: '00-Activiti7',
-                                    link: '/md/activiti/activiti7-introduction.md'
-                                }, ]
-                            },
-
-                            {
-                                text: 'MQTT',
-                                items: [{
-                                    text: '00-MQTT',
-                                    link: '/md/MQTT/07-MQTT发布订阅模式介绍.md'
-                                }, ]
-                            },
-
-                            {
-                                text: 'OAuth2.0',
-                                items: [{
-                                    text: 'OAuth2.0专栏概述',
-                                    link: '/md/security/OAuth 2.0实战-为什么要先获取授权码code.md'
-                                }, ]
-                            },
-
-                            {
-                                text: 'Arthas',
-                                items: [{
-                                    text: 'Arthas使用',
-                                    link: '/md/arthas/Arthas使用.md'
-                                }, ]
-                            },
-                        ]
-                    },
-
-                    {
-                        text: '后端',
-                        items: [{
-                                text: '并发',
-                                items: [{
-                                    text: '并发编程专栏概述',
-                                    link: '/md/java/并发编程专栏概述.md'
-                                }, ]
-                            },
-
-                            {
-                                text: '响应式编程',
-                                items: [{
-                                    text: '响应式编程专栏概述',
-                                    link: '/md/reactive/00-Spring响应式编程.md'
-                                }, ]
-                            },
-
-                            {
-                                text: 'JVM',
-                                items: [{
-                                    text: 'JVM基础',
-                                    link: '/md/jvm/JVM专栏概述.md'
-                                }, ]
-                            },
-
-                            {
-                                text: 'JDK新特性',
-                                items: [{
-                                    text: 'Oracle Java SE（标准版）支持路线图',
-                                    link: '/md/java/java-se-support-roadmap.md'
-                                }, ]
-                            },
-
-                            {
-                                text: 'IDEA新功能',
-                                items: [{
-                                    text: 'IntelliJ IDEA 2024.1 最新变化',
-                                    link: '/md/java/IntelliJ IDEA 2024.1 最新变化'
-                                }, ]
-                            },
-
-                            {
-                                text: 'Tomcat',
-                                items: [{
-                                    text: 'Tomcat网络编程',
-                                    link: '/md/tomcat/00-不知道这些Servlet规范、容器，还敢说自己是Java程序员.md'
-                                }, ]
-                            },
-
-                            {
-                                text: 'Spring',
-                                items: [{
-                                    text: 'SpringMVC拦截处理器',
-                                    link: '/md/spring/03-SpringMVC拦截处理器.md'
-                                }, ]
-                            },
-
-                            {
-                                text: 'SpringBoot',
-                                items: [{
-                                    text: '00-可能是全网最全的SpringBoot启动流程源码分析',
-                                    link: '/md/spring/00-可能是全网最全的SpringBoot启动流程源码分析.md'
-                                }, ]
-                            },
-
-                            {
-                                text: 'Dubbo',
-                                items: [{
-                                    text: '01-互联网架构的发展历程',
-                                    link: '/md/Dubbo/01-互联网架构的发展历程.md'
-                                }, ]
-                            },
-
-                            {
-                                text: 'SpringCloud',
-                                items: [{
-                                        text: 'SpringCloudAlibaba',
-                                        link: '/md/spring/spring-cloud/SpringCloudAlibaba介绍.md'
-                                    },
-                                    {
-                                        text: 'SpringCloudGateway工作原理与链路图',
-                                        link: '/md/spring/spring-cloud/SpringCloudGateway工作原理与链路图.md'
-                                    },
-
-                                    {
-                                        text: 'Seata',
-                                        link: '/md/seata/01-Seata客户端依赖坐标引入与踩坑排雷.md'
-                                    },
-                                ]
-                            },
-
-                            {
-                                text: '大厂实践',
-                                items: [{
-                                    text: '01-Segment为何永别微服务了？',
-                                    link: '/md/spring/spring-cloud/practise/01-Segment为何永别微服务了？.md'
-                                }, ]
-                            },
-                        ]
-                    },
-
-                    {
-                        text: '数据库',
-                        items: [{
-                                text: 'MySQL',
-                                items: [{
-                                    text: '00-MySQL专栏大纲',
-                                    link: '/md/mysql/00-MySQL专栏大纲.md'
-                                }]
-                            },
-
-                            {
-                                text: 'Redis',
-                                items: [{
-                                    text: '基础',
-                                    link: '/md/redis/00-数据结构的最佳实践.md'
-                                }, ]
-                            },
-
-                            {
-                                text: 'ElasticSearch',
-                                items: [{
-                                    text: 'ES专栏大纲',
-                                    link: '/md/es/ES专栏大纲.md'
-                                }]
-                            },
-
-                            {
-                                text: 'ClickHouse',
-                                items: [{
-                                    text: 'clickhouse概述',
-                                    link: '/md/ck/clickhouse概述.md'
-                                }]
-                            },
-
-                            {
-                                text: 'HBase',
-                                items: [{
-                                    text: 'HBase概述',
-                                    link: '/md/hbase/hbase-scan.md'
-                                }]
-                            },
-
-                            {
-                                text: 'Neo4j',
-                                items: [{
-                                    text: 'Neo4j：图数据库的革命性力量',
-                                    link: '/md/neo4j/neo4j-revolutionary-power-of-graph-databases.md'
-                                }]
-                            },
-
-                            {
-                                text: '分布式数据库',
-                                items: [{
-                                    text: '查询执行引擎：如何让聚合计算加速？',
-                                    link: '/md/distdb/21-查询执行引擎：加速聚合计算加速.md'
-                                }]
-                            },
-                        ]
-                    },
-
-
-                    {
-                        text: '大数据',
-                        items: [{
-                                text: '大数据平台',
-                                items: [{
-                                    text: '00-互联网大厂的大数据平台架构',
-                                    link: '/md/bigdata/大数据平台架构.md'
-                                }, ]
-                            },
-
-                            {
-                                text: '数据中台',
-                                items: [{
-                                    text: '01-大数据的尽头是数据中台吗？',
-                                    link: '/md/bigdata/01-大数据的尽头是数据中台吗？.md'
-                                }]
-                            },
-
-                            {
-                                text: 'Hadoop',
-                                items: [{
-                                    text: '00-安装下载Hadoop',
-                                    link: '/md/bigdata/安装下载Hadoop.md'
-                                }]
-                            },
-
-                            {
-                                text: 'Hive',
-                                items: [{
-                                    text: 'Hive专栏概述',
-                                    link: '/md/bigdata/Hive专栏概述.md'
-                                }, ]
-                            },
-
-                            {
-                                text: '数据仓库',
-                                items: [{
-                                    text: 'Spark+ClickHouse实战企业级数据仓库专栏',
-                                    link: '/md/bigdata/Spark+ClickHouse实战企业级数据仓库专栏.md'
-                                }, ]
-                            },
-
-                            {
-                                text: 'DataX',
-                                items: [{
-                                    text: 'DataX专栏',
-                                    link: '/md/bigdata/阿里云开源离线同步工具DataX3.0介绍.md'
-                                }, ]
-                            },
-
-                            {
-                                text: 'DolphinScheduler',
-                                items: [{
-                                    text: 'DolphinScheduler专栏',
-                                    link: '/md/bigdata/作业帮基于 DolphinScheduler 的数据开发平台实践.md'
-                                }, ]
-                            },
-
-                            {
-                                text: 'Spark',
-                                items: [{
-                                    text: '为啥要学习Spark？',
-                                    link: '/md/spark/为啥要学习Spark？.md'
-                                }, ]
-                            },
-
-                            {
-                                text: 'Flink',
-                                items: [{
-                                    text: 'Flink实战-概述',
-                                    link: '/md/flink/01-Flink实战-概述.md'
-                                }, ]
-                            },
-                        ]
-                    },
-
-                    {
-                        text: '云原生',
-                        items: [{
-                                text: 'Go',
-                                items: [{
-                                    text: '00-Go概述',
-                                    link: '/md/go/00-Go概述.md'
-                                }]
-                            },
-
-                            {
-                                text: 'Docker',
-                                items: [{
-                                    text: 'Docker基础命令大全',
-                                    link: '/md/docker/00-Docker基础命令大全.md'
-                                }]
-                            },
-
-                            {
-                                text: 'k8s',
-                                items: [{
-                                    text: 'Kubernetes的基本架构',
-                                    link: '/md/k8s/00-Kubernetes的基本架构.md'
-                                }]
-                            },
-
-                            {
-                                text: 'ServerLess',
-                                items: [{
-                                    text: 'serverless-is-a-scam',
-                                    link: '/md/serverless/serverless-is-a-scam.md'
-                                }]
-                            },
-
-                            {
-                                text: '监控',
-                                items: [{
-                                    text: '00-你居然还去服务器上捞日志，搭个日志收集系统难道不香么！',
-                                    link: '/md/monitor/00-你居然还去服务器上捞日志，搭个日志收集系统难道不香么！.md'
-                                }]
-                            },
-                        ]
-                    },
-
-                    {
-                        text: '音视频',
+                    text: '导读',
+                    link: '/md/other/guide-to-reading.md'
+                },
+                {
+                    text: '架构',
+                    items: [{
+                        text: '设计原则',
+                        items: [{
+                            text: '设计原则概述',
+                            link: '/md/design/01-单一职责原则.md'
+                        },]
+                    },
+                    {
+                        text: '设计模式',
+                        items: [{
+                            text: '模板方法设计模式（Template Pattern）',
+                            link: '/md/design/模板方法设计模式（Template Pattern）.md'
+                        },]
+                    },
+                    {
+                        text: '重构',
+                        items: [{
+                            text: '00-软件架构权衡-我们为什么以及如何进行权衡？',
+                            link: '/md/design/00-软件架构权衡-我们为什么以及如何进行权衡？.md'
+                        },]
+                    },
+                    {
+                        text: '大厂业务架构',
+                        items: [{
+                            text: '00-聚合支付架构',
+                            link: '/md/biz-arch/00-聚合支付架构从零到一'
+                        },]
+                    },
+                    {
+                        text: '系统设计',
+                        items: [{
+                            text: '00-优惠券系统设计',
+                            link: '/md/biz-arch/00-优惠券系统设计 Coupon System'
+                        },]
+                    },
+
+                    {
+                        text: 'DDD',
+                        items: [{
+                            text: '00-DDD专栏规划',
+                            link: '/md/DDD/00-DDD专栏规划.md'
+                        },
+
+                        {
+                            text: '事件驱动',
+                            link: '/md/DDD/integrating-event-driven-microservices-with-request-response-APIs.md'
+                        },
+                        {
+                            text: '00-大厂实践',
+                            link: '/md/DDD/02-领域驱动设计DDD在B端营销系统的实践.md'
+                        },
+
+                        ]
+                    },
+
+                    {
+                        text: '数据中台',
+                        items: [{
+                            text: '00-新一代数据栈将逐步替代国内单一“数据中台”',
+                            link: '/md/bigdata/00-新一代数据栈将逐步替代国内单一“数据中台”.md'
+                        },]
+                    },
+
+                    {
+                        text: '交易中台',
+                        items: [{
+                            text: '00-如何防止订单二次重复支付？',
+                            link: '/md/trade/00-如何防止订单二次重复支付？.md'
+                        },]
+                    },
+
+                    {
+                        text: '商品中心',
+                        items: [{
+                            text: '00-商品中心的spu、sku设计.md',
+                            link: '/md/product-center/00-商品中心的spu、sku设计.md'
+                        },]
+                    },
+
+                    {
+                        text: '用户画像',
+                        items: [{
+                            text: '01-DMP系统简介.md',
+                            link: '/md/biz-arch/01-DMP系统简介.md'
+                        },]
+                    },
+
+                    {
+                        text: '低代码',
+                        items: [{
+                            text: '为什么“低代码”是未来趋势？.md',
+                            link: '/md/low-code/为什么“低代码”是未来趋势？.md'
+                        },]
+                    },
+
+
+                    ]
+                },
+                {
+                    text: '项目',
+                    items: [{
+                        text: '12306',
+                        items: [{
+                            text: '项目介绍',
+                            link: '/md/12306/12306-basic-info.md'
+                        }]
+                    },
+                    {
+                        text: 'DDD商城',
+                        items: [{
+                            text: '什么是DDD商城',
+                            link: '/md/ddd-mall/什么是DDD商城.md'
+                        }]
+                    },
+
+                    {
+                        text: '风控系统引擎',
+                        items: [{
+                            text: '风控引擎架构设计',
+                            link: '/md/risk-control/risk-control-engine-architecture-design.md'
+                        }]
+                    },
+
+                    {
+                        text: 'Go微服务网关专栏概述',
+                        items: [{
+                            text: 'Go微服务网关专栏概述',
+                            link: '/md/go-gateway/00-Go微服务网关专栏概述.md'
+                        }]
+                    },
+                    ]
+                },
+
+                {
+                    text: '框架',
+                    items: [{
+                        text: 'RPC',
+                        items: [{
+                            text: '熔断限流',
+                            link: '/md/rpc/熔断限流.md'
+                        },]
+                    },
+
+                    {
+                        text: 'Netty',
+                        items: [{
+                            text: 'Netty基础',
+                            link: '/md/netty/Netty基本组件.md'
+                        },
+
+                        {
+                            text: 'Netty实战',
+                            link: '/md/netty/netty-off-heap-memory-leak-detection.md'
+                        },
+                        ]
+                    },
+
+                    {
+                        text: 'ShardingSphere',
+                        items: [{
+                            text: 'ShardingSphere',
+                            link: '/md/ShardingSphere/14-ShardingSphere的分布式主键实现.md'
+                        }]
+                    },
+
+                    {
+                        text: 'kafka',
+                        items: [{
+                            text: 'kafka',
+                            link: '/md/kafka/00-Kafka专栏大纲.md'
+                        }]
+                    },
+
+                    {
+                        text: 'RocketMQ',
+                        items: [{
+                            text: '消息队列基础',
+                            link: '/md/RocketMQ/消息队列面试必问解析.md'
+                        },]
+                    },
+
+                    {
+                        text: 'RabbitMQ',
+                        items: [{
+                            text: 'RabbitMQ',
+                            link: '/md/rabbitmq/00-RabbitMQ实战下载与安装.md'
+                        },]
+                    },
+
+                    {
+                        text: '工作流引擎',
+                        items: [{
+                            text: '00-Activiti7',
+                            link: '/md/activiti/activiti7-introduction.md'
+                        },]
+                    },
+
+                    {
+                        text: 'MQTT',
+                        items: [{
+                            text: '00-MQTT',
+                            link: '/md/MQTT/07-MQTT发布订阅模式介绍.md'
+                        },]
+                    },
+
+                    {
+                        text: 'OAuth2.0',
+                        items: [{
+                            text: 'OAuth2.0专栏概述',
+                            link: '/md/security/OAuth 2.0实战-为什么要先获取授权码code.md'
+                        },]
+                    },
+
+                    {
+                        text: 'Arthas',
+                        items: [{
+                            text: 'Arthas使用',
+                            link: '/md/arthas/Arthas使用.md'
+                        },]
+                    },
+                    ]
+                },
+
+                {
+                    text: '后端',
+                    items: [{
+                        text: '并发',
+                        items: [{
+                            text: '并发编程专栏概述',
+                            link: '/md/java/并发编程专栏概述.md'
+                        },]
+                    },
+
+                    {
+                        text: '响应式编程',
+                        items: [{
+                            text: '响应式编程专栏概述',
+                            link: '/md/reactive/00-Spring响应式编程.md'
+                        },]
+                    },
+
+                    {
+                        text: 'JVM',
+                        items: [{
+                            text: 'JVM基础',
+                            link: '/md/jvm/JVM专栏概述.md'
+                        },]
+                    },
+
+                    {
+                        text: 'JDK新特性',
+                        items: [{
+                            text: 'Oracle Java SE（标准版）支持路线图',
+                            link: '/md/java/java-se-support-roadmap.md'
+                        },]
+                    },
+
+                    {
+                        text: 'IDEA新功能',
+                        items: [{
+                            text: 'IntelliJ IDEA 2024.1 最新变化',
+                            link: '/md/java/IntelliJ IDEA 2024.1 最新变化'
+                        },]
+                    },
+
+                    {
+                        text: 'Tomcat',
+                        items: [{
+                            text: 'Tomcat网络编程',
+                            link: '/md/tomcat/00-不知道这些Servlet规范、容器，还敢说自己是Java程序员.md'
+                        },]
+                    },
+
+                    {
+                        text: 'Spring',
+                        items: [{
+                            text: 'SpringMVC拦截处理器',
+                            link: '/md/spring/03-SpringMVC拦截处理器.md'
+                        },]
+                    },
+
+                    {
+                        text: 'SpringBoot',
+                        items: [{
+                            text: '00-可能是全网最全的SpringBoot启动流程源码分析',
+                            link: '/md/spring/00-可能是全网最全的SpringBoot启动流程源码分析.md'
+                        },]
+                    },
+
+                    {
+                        text: 'Dubbo',
+                        items: [{
+                            text: '01-互联网架构的发展历程',
+                            link: '/md/Dubbo/01-互联网架构的发展历程.md'
+                        },]
+                    },
+
+                    {
+                        text: 'SpringCloud',
+                        items: [{
+                            text: 'SpringCloudAlibaba',
+                            link: '/md/spring/spring-cloud/SpringCloudAlibaba介绍.md'
+                        },
+                        {
+                            text: 'SpringCloudGateway工作原理与链路图',
+                            link: '/md/spring/spring-cloud/SpringCloudGateway工作原理与链路图.md'
+                        },
+
+                        {
+                            text: 'Seata',
+                            link: '/md/seata/01-Seata客户端依赖坐标引入与踩坑排雷.md'
+                        },
+                        ]
+                    },
+
+                    {
+                        text: '大厂实践',
+                        items: [{
+                            text: '01-Segment为何永别微服务了？',
+                            link: '/md/spring/spring-cloud/practise/01-Segment为何永别微服务了？.md'
+                        },]
+                    },
+                    ]
+                },
+
+                {
+                    text: '数据库',
+                    items: [{
+                        text: 'MySQL',
+                        items: [{
+                            text: '00-MySQL专栏大纲',
+                            link: '/md/mysql/00-MySQL专栏大纲.md'
+                        }]
+                    },
+
+                    {
+                        text: 'Redis',
                         items: [{
                             text: '基础',
-                            items: [{
-                                text: '音视频小白秒变大神？看完这条学习路线就够了！',
-                                link: '/md/ffmpeg/audio-video-roadmap.md'
-                            }]
-                        }, ]
+                            link: '/md/redis/00-数据结构的最佳实践.md'
+                        },]
+                    },
+
+                    {
+                        text: 'ElasticSearch',
+                        items: [{
+                            text: 'ES专栏大纲',
+                            link: '/md/es/ES专栏大纲.md'
+                        }]
+                    },
+
+                    {
+                        text: 'ClickHouse',
+                        items: [{
+                            text: 'clickhouse概述',
+                            link: '/md/ck/clickhouse概述.md'
+                        }]
+                    },
+
+                    {
+                        text: 'HBase',
+                        items: [{
+                            text: 'HBase概述',
+                            link: '/md/hbase/hbase-scan.md'
+                        }]
+                    },
+
+                    {
+                        text: 'Neo4j',
+                        items: [{
+                            text: 'Neo4j：图数据库的革命性力量',
+                            link: '/md/neo4j/neo4j-revolutionary-power-of-graph-databases.md'
+                        }]
+                    },
+
+                    {
+                        text: '分布式数据库',
+                        items: [{
+                            text: '查询执行引擎：如何让聚合计算加速？',
+                            link: '/md/distdb/21-查询执行引擎：加速聚合计算加速.md'
+                        }]
+                    },
+                    ]
+                },
+
+
+                {
+                    text: '大数据',
+                    items: [{
+                        text: '大数据平台',
+                        items: [{
+                            text: '00-互联网大厂的大数据平台架构',
+                            link: '/md/bigdata/大数据平台架构.md'
+                        },]
+                    },
+
+                    {
+                        text: '数据中台',
+                        items: [{
+                            text: '01-大数据的尽头是数据中台吗？',
+                            link: '/md/bigdata/01-大数据的尽头是数据中台吗？.md'
+                        }]
+                    },
+
+                    {
+                        text: 'Hadoop',
+                        items: [{
+                            text: '00-安装下载Hadoop',
+                            link: '/md/bigdata/安装下载Hadoop.md'
+                        }]
                     },
 
                     {
-                        text: '数分',
+                        text: 'Hive',
                         items: [{
-                            text: '数分基础',
-                            items: [{
-                                text: '为啥要学习数据分析？',
-                                link: '/md/data-analysis/basic/为啥要学习数据分析？.md'
-                            }]
-                        }, ]
+                            text: 'Hive专栏概述',
+                            link: '/md/bigdata/Hive专栏概述.md'
+                        },]
                     },
 
                     {
-                        text: '计科',
-                        items: [{
-                                text: '计算机网络',
-                                items: [{
-                                    text: '00-计算机网络-网络层原理',
-                                    link: '/md/network/计算机网络-网络层原理.md'
-                                }, ]
-                            },
+                        text: '数据仓库',
+                        items: [{
+                            text: 'Spark+ClickHouse实战企业级数据仓库专栏',
+                            link: '/md/bigdata/Spark+ClickHouse实战企业级数据仓库专栏.md'
+                        },]
+                    },
+
+                    {
+                        text: 'DataX',
+                        items: [{
+                            text: 'DataX专栏',
+                            link: '/md/bigdata/阿里云开源离线同步工具DataX3.0介绍.md'
+                        },]
+                    },
+
+                    {
+                        text: 'DolphinScheduler',
+                        items: [{
+                            text: 'DolphinScheduler专栏',
+                            link: '/md/bigdata/作业帮基于 DolphinScheduler 的数据开发平台实践.md'
+                        },]
+                    },
+
+                    {
+                        text: 'Spark',
+                        items: [{
+                            text: '为啥要学习Spark？',
+                            link: '/md/spark/为啥要学习Spark？.md'
+                        },]
+                    },
+
+                    {
+                        text: 'Flink',
+                        items: [{
+                            text: 'Flink实战-概述',
+                            link: '/md/flink/01-Flink实战-概述.md'
+                        },]
+                    },
+                    ]
+                },
+
+                {
+                    text: '云原生',
+                    items: [{
+                        text: 'Go',
+                        items: [{
+                            text: '00-Go概述',
+                            link: '/md/go/00-Go概述.md'
+                        }]
+                    },
+
+                    {
+                        text: 'Docker',
+                        items: [{
+                            text: 'Docker基础命令大全',
+                            link: '/md/docker/00-Docker基础命令大全.md'
+                        }]
+                    },
+
+                    {
+                        text: 'k8s',
+                        items: [{
+                            text: 'Kubernetes的基本架构',
+                            link: '/md/k8s/00-Kubernetes的基本架构.md'
+                        }]
+                    },
+
+                    {
+                        text: 'ServerLess',
+                        items: [{
+                            text: 'serverless-is-a-scam',
+                            link: '/md/serverless/serverless-is-a-scam.md'
+                        }]
+                    },
+
+                    {
+                        text: '监控',
+                        items: [{
+                            text: '00-你居然还去服务器上捞日志，搭个日志收集系统难道不香么！',
+                            link: '/md/monitor/00-你居然还去服务器上捞日志，搭个日志收集系统难道不香么！.md'
+                        }]
+                    },
+                    ]
+                },
+
+                {
+                    text: '音视频',
+                    items: [{
+                        text: '基础',
+                        items: [{
+                            text: '音视频小白秒变大神？看完这条学习路线就够了！',
+                            link: '/md/ffmpeg/audio-video-roadmap.md'
+                        }]
+                    },]
+                },
+
+                {
+                    text: '数分',
+                    items: [{
+                        text: '数分基础',
+                        items: [{
+                            text: '为啥要学习数据分析？',
+                            link: '/md/data-analysis/basic/为啥要学习数据分析？.md'
+                        }]
+                    },]
+                },
+
+                {
+                    text: '计科',
+                    items: [{
+                        text: '计算机网络',
+                        items: [{
+                            text: '00-计算机网络-网络层原理',
+                            link: '/md/network/计算机网络-网络层原理.md'
+                        },]
+                    },
 
-                            {
-                                text: 'Linux操作系统',
-                                items: [{
-                                    text: '00-操作系统专栏大纲',
-                                    link: '/md/linux/00-操作系统专栏大纲.md'
-                                }, ]
-                            },
+                    {
+                        text: 'Linux操作系统',
+                        items: [{
+                            text: '00-操作系统专栏大纲',
+                            link: '/md/linux/00-操作系统专栏大纲.md'
+                        },]
+                    },
 
-                            {
-                                text: '数据结构与算法',
-                                items: [{
-                                    text: '数据结构与算法专栏大纲',
-                                    link: '/md/algorithm/basic/00-数据结构与算法专栏大纲.md'
-                                }, ]
-                            },
+                    {
+                        text: '数据结构与算法',
+                        items: [{
+                            text: '数据结构与算法专栏大纲',
+                            link: '/md/algorithm/basic/00-数据结构与算法专栏大纲.md'
+                        },]
+                    },
 
-                            {
-                                text: '算法的工程应用',
-                                items: [{
-                                    text: '哈希算法原来有这么多应用场景！',
-                                    link: '/md/algorithm/practise/哈希算法原来有这么多应用场景！.md'
-                                }, ]
-                            },
+                    {
+                        text: '算法的工程应用',
+                        items: [{
+                            text: '哈希算法原来有这么多应用场景！',
+                            link: '/md/algorithm/practise/哈希算法原来有这么多应用场景！.md'
+                        },]
+                    },
 
-                            {
-                                text: '大厂算法面试',
-                                items: [{
-                                    text: '00-阿里秋招高频算法题汇总-基础篇',
-                                    link: '/md/algorithm/leetcode/00-阿里秋招高频算法题汇总-基础篇.md'
-                                }, ]
-                            },
+                    {
+                        text: '大厂算法面试',
+                        items: [{
+                            text: '00-阿里秋招高频算法题汇总-基础篇',
+                            link: '/md/algorithm/leetcode/00-阿里秋招高频算法题汇总-基础篇.md'
+                        },]
+                    },
 
-                            {
-                                text: '常见攻击手段',
-                                items: [{
-                                    text: '常见攻击手段概述',
-                                    link: '/md/security/OAuth 2.0实战-为什么要先获取授权码code.md'
-                                }, ]
-                            },
+                    {
+                        text: '常见攻击手段',
+                        items: [{
+                            text: '常见攻击手段概述',
+                            link: '/md/security/OAuth 2.0实战-为什么要先获取授权码code.md'
+                        },]
+                    },
+                    ]
+                },
+                {
+                    text: '面试',
+                    link: '/md/zqy/面试题/01-分布式技术面试实战.md'
+                },
+
+                {
+                    text: 'AI',
+                    items: [{
+                        text: 'Python基础',
+                        link: '/md/python/00-macOS和Linux安装和管理多个Python版本'
+                    },
+                    {
+                        text: 'AI算法',
+                        link: '/md/AI/ml/01-人工智能概要'
+                    },
+                    {
+                        text: 'AIGC应用开发',
+                        link: '/md/AI/AI大模型企业应用实战'
+                    },
+                    {
+                        text: 'LangChain4j',
+                        link: '/md/AI/langchain4j/01-intro'
+                    },
+                    {
+                        text: 'MCP',
+                        link: '/md/AI/mcp/mcp-fad-or-fixture'
+                    },
+                    {
+                        text: '大模型平台和Prompt工程',
+                        link: '/md/AI/llm/GPTs'
+                    },
+                    {
+                        text: 'AI Agent',
+                        link: '/md/AI/agent/changelog-cursor'
+                    },
+                    ]
+                },
+
+                {
+                    text: 'Vue',
+                    items: [{
+                        text: '01-Vue开发实战',
+                        link: '/md/vue/01-Vue开发实战.md'
+                    },]
+                },
+
+                {
+                    text: '区块链',
+                    items: [{
+                        text: '区块链核心概念',
+                        link: '/md/chain/00-区块链专栏概述.md'
+                    },
+                    {
+                        text: '百度联盟链XuperChain',
+                        link: '/md/chain/03-百度联盟链Xuperchain核心概念.md'
+                    },
+                    {
+                        text: 'Flow平台实战',
+                        link: '/md/chain/02-认识Flow Cadence.md'
+                    },
+                    {
+                        text: '以太坊区块链',
+                        link: '/md/chain/01-以太坊智能合约与高级语言.md'
+                    },
+
+                    ]
+                },
+
+                {
+                    text: '职业',
+                    items: [{
+                        text: '职业规划',
+                        link: '/md/career/为什么中国的程序员有35岁危机'
+                    },
+                    {
+                        text: '晋升',
+                        link: '/md/career/p6-promotion-guide'
+                    },
+
+                    {
+                        text: '职场',
+                        link: '/md/career/经常被压缩开发时间，延期还要背锅，如何破局？'
+                    },
+
+                    {
+                        text: '书单',
+                        link: '/md/career/Java-reading-list'
+                    },
+
+                    {
+                        text: '00-如何学习项目管理专栏',
+                        link: '/md/mgr/00-如何学习项目管理专栏.md'
+                    },
+
+                    ]
+                },
+
+                {
+                    text: '副业',
+                    items: [{
+                        text: '副业',
+                        link: '/md/sideline/16-精益独立开发实践.md'
+                    },]
+                },
+                ],
+                // 文章详情页的侧边导航栏
+                sidebar: {
+                    "/md/Dubbo/": [{
+                        title: "Dubbo深入理解系列",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "01-互联网架构的发展历程.md",
+                            "02-Dubbo特性及工作原理.md",
+                            "03-Dubbo的负载均衡及高性能RPC调用.md",
+                            "04-Dubbo的通信协议.md",
+                            "05-Dubbo的应用及注册和SPI机制.md",
+                            "06-Dubbo相关面试题和源码使用技巧.md",
+                            "07-Dubbo真实生产环境思考.md"
+                        ]
+                    }],
+                    "/md/zqy/面试题/": [{
+                        title: "面试突击",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "01-分布式技术面试实战.md",
+                            "02-注册中心和网关面试实战.md",
+                            "03-生产部署面试实战.md",
+                            "04-分布式锁、幂等性问题实战.md",
+                            "05-Java基础面试实战.md",
+                            "06-Spring面试实战.md",
+                            "07-计算机网络面试实战.md",
+                            "08-数据库面试实战.md",
+                            "09-网络通信及可见性面试实战.md",
+                            "10-Java 系统架构安全面试实战.md",
+                            "11-深挖网络 IO 面试实战.md",
+                            "12-分布式架构、性能优化、场景设计面试实战.md",
+                        ]
+                    },
+                    {
+
+                        title: "面试大全",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "面试题-Java基础.md",
+                            "面试题-MySQL.md",
+                            "面试题-Netty.md",
+                            "面试题-Redis.md",
+                            "面试题-场景题.md"
+                        ]
+                    },
+                    {
+                        title: "面试高频考点",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "gaopin/00-RocketMQ可靠性、重复消费解决方案.md",
+                            "gaopin/01-RocketMQ有序性、消息积压解决方案.md",
+                            "gaopin/02-Redis的IO多路复用.md",
+                            "gaopin/03-ZooKeeper运行原理.md"
+                        ]
+                    },
+                    {
+                        title: "互联网大厂面经",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "mianjing/00-淘天提前批面试.md",
+                            "mianjing/01-饿了么一面.md",
+                            "mianjing/02-美团优选后端一面.md",
+                            "mianjing/03.腾讯后端一面.md",
+                            "mianjing/04.美团优选后端一面.md",
+                            "mianjing/05.携程暑期实习一面.md",
+                            "mianjing/06.携程暑期实习二面.md",
+                        ]
+                    },
+                    {
+                        title: "架构设计",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "jiagou/01-B站评论系统架构设计.md",
+                            "jiagou/02-该从哪些方面提升系统的吞吐量？.md"
+                        ]
+                    }
+                    ],
+                    "/md/biz-arch/": [{
+                        title: "大厂业务架构",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-聚合支付架构从零到一",
+                            "01-供应链域数据中台设计",
+                            "02-供应链采购视角的业务系统架构",
+                            "03-客服平台架构实践",
+                            "04-数据质量中心系统设计",
+                            "05-大厂CRM系统架构优化实战",
+                            "06-运营后台系统设计",
+                            "07-大厂报价查询系统性能优化之道",
+                            "08-视频推荐索引构建",
+                            "小游戏的大促实践",
+                            "事件中心架构概述",
+                            "高性能排名系统的核心架构原理，架构师必看！",
+                        ]
+                    },
+                    {
+                        title: "系统设计",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-优惠券系统设计 Coupon System",
+                            "设计消息通知系统（Notification System）",
+                            "System design: Uber",
+                            "短链系统设计（design tiny url）",
+                            "打造一个高并发的十万用户 IM 聊天系统，你需要了解这些架构设计技巧！",
+                            "netflixs-distributed-counter-abstraction",
+                            "data-gateway-a-platform-for-growing-and-protecting-the-data-tier",
+                            "enhancing-netflix-reliability-with-service-level-prioritized-load-shedding",
+                            "title-launch-observability-at-netflix-scale",
+                            "cloud-efficiency-at-netflix",
+                            "linkedin-architecture-which-enables-searching-a-message-within-150ms",
+                            "how-meta-improved-their-cache-consistency-to-99-99999999",
+                        ]
+                    },
+
+                    {
+                        title: "用户画像",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "01-DMP系统简介",
+                            "05-用户画像是什么？",
+                            "06-构建高质量的用户画像",
+                            "07-用户画像和特征工程",
+                        ]
+                    },
+
+                    {
+                        title: "低代码",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "为什么“低代码”是未来趋势？",
+                            "01-低代码平台到底是什么样的？",
+                        ]
+                    },
+                    ],
+
+                    "/md/mgr/": [{
+                        title: "项目管理",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-如何学习项目管理专栏",
+                            "00-咋带领团队做成事？",
+                            "01-避免新手常犯的项目管理错误",
+                        ]
+                    },
+                    {
+                        title: "技术管理",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-新一代数据栈将逐步替代国内单一“数据中台”",
+                        ]
+                    },
+                    ],
+                    "/md/trade/": [{
+                        title: "交易中台",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-如何防止订单二次重复支付？",
+                            "01-扫码支付后都发生了啥？",
+                            "02-大厂的第三方支付业务架构设计",
+                            "wechat-pay-development-guide-avoid-pitfalls",
+                            "high-avail-payments",
+                        ]
+                    }],
+
+                    "/md/product-center/": [{
+                        title: "商品中心",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-商品中心的spu、sku设计",
+                            "01-电商商品中心解密：仅凭SKU真的足够吗？",
+                            "02-大厂电商设计解析之商品管理系统",
+                        ]
+                    }],
+
+                    "/md/bigdata/": [{
+                        title: "大数据平台",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "大数据平台架构",
+                            "中小企业参考的商业大数据平台",
+                            "对象存储",
+                            "02-分布式对象存储设计原理",
+                            "AB测试与灰度发布",
+                            "当大数据遇上物联网",
+                            "移动计算",
+                            "大数据基准测试",
+                        ]
+                    },
+                    {
+                        title: "数据中台",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-新一代数据栈将逐步替代国内单一“数据中台”",
+                            "01-大数据的尽头是数据中台吗？",
+                            "03-构建数据中台的三要素：方法论、组织和技术",
+                            "05-如何统一管理纷繁杂乱的数据指标？",
+                        ]
+                    },
+                    {
+                        title: "Hadoop",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "安装下载Hadoop",
+                            "01-Hadoop",
+                            "HDFS",
+                            "03-HDFS伪分布式环境搭建",
+                            "04-hdfs dfs命令详解",
+                        ]
+                    },
+                    {
+                        title: "Hive",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "Hive专栏概述",
+                            "Hive 2.x 的安装与配置",
+                            "Hive执行原理",
+                            "Hive分区和分桶",
+                            "Hive修复分区",
+                            "hive的严格模式",
+                            "hiveserver2",
+                        ]
+                    },
+                    {
+                        title: "数据仓库",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "维度建模理论之事实表",
+                            "维度建模理论之维度表",
+                            "数仓逻辑模型",
+                            "数仓业务调研",
+                            "数仓分层和数仓建模",
+                            "轻松驾驭Hive数仓",
+                            "数仓开发之ODS层",
+                            "数仓开发之DIM层",
+                            "数仓开发之DWD层",
+                            "数仓开发之DWS层",
+                            "数仓开发之ADS层",
+                            "OLAP平台架构演化历程",
+                        ]
+                    },
+
+                    {
+                        title: "DataX",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "阿里云开源离线同步工具DataX3.0介绍",
+                            "数仓数据导出",
+                        ]
+                    },
+
+                    {
+                        title: "DolphinScheduler",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "DolphinScheduler简介",
+                            "DolphinScheduler部署",
+                            "DolphinScheduler参数",
+                            "DolphinScheduler资源中心",
+                            "DolphinScheduler告警通知",
+                            "作业帮基于 DolphinScheduler 的数据开发平台实践",
+                        ]
+                    },
+                    ],
+
+                    "/md/rpc/": [{
+                        title: "RPC",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "04-RPC框架在网络通信的网络IO模型选型",
+                            "熔断限流",
+                            "11-RPC的负载均衡",
+                            "rpc-retry-mechanism",
+                            "RPC-Traffic-Replay",
+                        ]
+                    }],
+
+                    "/md/ShardingSphere/": [{
+                        title: "ShardingSphere",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "10-顶级企业如何用数据脱敏保护用户隐私！",
+                            "11-动态配置管理背后的编排治理真相！",
+                            "14-ShardingSphere的分布式主键实现",
+                            "19-路由引擎：如何在路由过程中集成多种路由策略和路由算法？",
+                            "ShardingSphere 如何完美驾驭分布式事务与 XA 协议？",
+                            "ShardingSphere 如何轻松驾驭 Seata 柔性分布式事务？",
+                        ]
+                    }],
+
+                    "/md/network/": [{
+                        title: "计算机网络",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "TCP协议详解",
+                            "TCP连接的建立和断开受哪些系统配置影响？",
+                            "天天说架构，那CDN到底是什么？",
+                            "计算机网络-网络层原理",
+                        ]
+                    }],
+
+                    "/md/linux/": [{
+                        title: "Linux操作系统",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-操作系统专栏大纲",
+                            "01-Linux命令",
+                            "02-进程管理",
+                            "04-还记得纸带编程吗？",
+                            "超线程（Hyper-Threading），单指令多数据流（SIMD）技术"
+                        ]
+                    }],
+
+                    "/md/MQTT/": [{
+                        title: "MQTT",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "MQTT与Kafka在物联网消息与流数据集成实践",
+                            "07-MQTT发布订阅模式介绍"
+                        ]
+                    }],
+
+                    "/md/activiti/": [{
+                        title: "Activiti7",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "activiti7-introduction",
+                        ]
+                    }],
+
+                    "/md/spider/": [{
+                        title: "爬虫",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-爬虫基础.md"
+                        ]
+                    }],
+
+                    "/md/ffmpeg/": [{
+                        title: "音视频基础",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "audio-video-roadmap",
+                            "video-basic",
+                        ]
+                    }],
+
+                    "/md/data-analysis/basic/": [{
+                        title: "数分基础",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "为啥要学习数据分析？",
+                            "correct-data-analysis-learning-methods",
+                            "learning-path-data-mining",
+                            "企业如何利用数据打造精准用户画像？",
+                            "如何自动化采集数据",
+                            "how-to-use-octoparse-for-data-scraping",
+                        ]
+                    }],
+
+                    "/md/java/": [{
+                        title: "并发",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-Java并发编程.md",
+                            "01-synchronized原理.md",
+                            "02-volatile原理.md",
+                            "03-ReentrantLock与AQS.md",
+                            "04-线程池以及生产环境使用.md",
+                            "05-京东并行框架asyncTool如何针对高并发场景进行优化？.md",
+                            "java21-virtual-threads-where-did-my-lock-go",
+                        ]
+                    },
+                    {
+                        title: "JDK新特性",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "java-se-support-roadmap",
+                            "Java9新特性概述",
+                            "jdk14-new-features-complete-guide",
+                            "JDK16新特性",
+                            "understanding-java17-new-features-sealed-classes",
+                            "JDK21新特性",
+                            "JDK22新特性",
+                            "JDK23新特性",
+                            "java2024",
+                        ]
+                    },
+
+                    {
+                        title: "IDEA新功能",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "IntelliJ IDEA 2024.1 最新变化",
+                            "What’s-New-in-IntelliJ-IDEA-2024.2",
+                            "What’s-New-in-IntelliJ-IDEA-2024.3",
+                        ]
+                    },
+                    ],
+
+                    "/md/jvm/": [{
+                        title: "JVM基础",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "JVM专栏概述",
+                            "01-JVM虚拟机-上篇",
+                            "02-JVM虚拟机-下篇",
+                            "00-JDK为何自己首先破坏双亲委派模型",
+                            "00-G1垃圾收集器的日志格式",
+                            "Metadata GC Threshold in Java",
+                            "对象内存分配及Minor GC和Full GC全过程",
+                            "Java 性能调优：优化 GC 线程设置",
+                            "JDK性能调优神器",
+                        ]
+                    },
+
+                    {
+                        title: "JVM调优",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "高并发BI系统避免频繁Y-GC",
+                            "线上频繁Full GC，原来是外包同学不合理设置JVM参数！",
+                            "Java NIO为何导致堆外内存OOM了？",
+                            "一次由热部署导致的OOM排查经历",
+                            "队列积压了百万条消息，线上直接OOM了！",
+                        ]
+                    },
+                    ],
+
+                    "/md/algorithm/leetcode/": [{
+                        title: "大厂算法面试",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-阿里秋招高频算法题汇总-基础篇",
+                            "01-阿里秋招高频算法题汇总-中级篇",
+                            "02-阿里秋招高频算法题汇总-进阶篇",
+                            "03-字节秋招高频算法题汇总-基础篇",
+                            "04-字节秋招高频算法题汇总-中级篇",
+                            "05-字节秋招高频算法题汇总-进阶篇",
+                        ]
+                    },],
+
+                    "/md/algorithm/basic/": [{
+                        title: "数据结构与算法",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-数据结构与算法专栏大纲",
+                            "【图解数据结构与算法】LRU缓存淘汰算法面试时到底该怎么写",
+                            "【图解数据结构】外行人也能看懂的哈希表",
+                            "dag-directed-acyclic-graph",
+                        ]
+                    }],
+
+                    "/md/algorithm/practise/": [{
+                        title: "工程应用",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "哈希算法原来有这么多应用场景！",
+                        ]
+                    }],
+
+                    "/md/spring/": [{
+                        title: "Spring",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "Spring之BeanNameAware和BeanFactoryAware接口",
+                            "这次彻底搞懂IoC容器依赖注入的源码",
+                            "别小看Spring过滤器,这些知识点你必须得掌握",
+                            "Spring框架使用了哪些设计模式",
+                            "阿里四面：你知道Spring AOP创建Proxy的过程吗？",
+                        ]
+                    },
+
+                    {
+                        title: "SpringMVC",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "01-SpringMVC的AsyncHandlerInterceptor异步的处理器拦截器",
+                            "02-实现http请求的异步长轮询",
+                            "03-SpringMVC拦截处理器",
+                            "SpringMVC-service-doDispatch",
+                            "SpringMVC-DispatcherServlet-doDispatch",
+                        ]
+                    },
+
+                    {
+                        title: "SpringBoot",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-可能是全网最全的SpringBoot启动流程源码分析",
+                            "01-HelloSpringBoot应用程序",
+                            "SpringBoot默认线程池",
+                        ]
+                    },
+
+                    {
+                        title: "SpringBoot新特性",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "SpringBoot3.4-release",
+                        ]
+                    },
+                    ],
+
+
+                    "/md/tomcat/": [{
+                        title: "Tomcat",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-不知道这些Servlet规范、容器，还敢说自己是Java程序员",
+                            "01-Jetty架构设计之Connector、Handler组件",
+                            "03-Tomcat的生命周期管理",
+                            "04-Tomcat实现热部署、热加载原理解析",
+                            "05-Tomcat如何打破双亲委派机制实现隔离Web应用的？",
+                            "Tomcat进程占用CPU过高怎么办？",
+                        ]
+                    }],
+
+
+                    "/md/seata/": [{
+                        title: "Seata",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "01-Seata客户端依赖坐标引入与踩坑排雷",
+                            "02-Seata客户端全局事务配置与实现",
+                            "03-Seata柔性事务",
+                            "04-Seata是什么?",
+                            "05-开始",
+                            "docker-install-configure-seata-server",
+                        ]
+                    }],
+
+                    "/md/spring/spring-cloud/": [{
+                        title: "SpringCloudAlibaba",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "SpringCloudAlibaba介绍.md",
+                        ]
+                    },
+
+                    {
+                        title: "SpringCloudGateway组件",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "SpringCloudGateway工作原理与链路图.md",
+                            "SpringCloudGateway核心之Predicate.md",
+                            "SpringCloudGateway之Filter多过程介绍.md",
+                            "SpringCloudGateway之熔断集成篇.md",
+                            "SpringCloudGateway之限流集成篇.md",
+                            "SpringCloudGateway之统一鉴权篇.md",
+                            "SpringCloudGateway之高性能篇.md"
+                        ]
+                    }
+                    ],
+
+                    "/md/spring/spring-cloud/practise": [{
+                        title: "大厂实践",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "01-Segment为何永别微服务了？",
+                        ]
+                    },],
+
+                    "/md/DDD/": [{
+                        title: "DDD基础知识",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-DDD专栏规划",
+                            "基于电商履约场景的DDD实战",
+                            "11-上下文映射",
+                            "13-DDD分层架构及代码目录结构",
+                            "domain-service",
+                            "23-理解领域事件（Domain Event）",
+                        ]
+                    },
+
+                    {
+                        title: "事件驱动",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "integrating-event-driven-microservices-with-request-response-APIs",
+                            "decouple-event-retrieval-from-processing",
+                            "use-circuit-breaker-to-pause-event-retrieval",
+                            "rate-limit-event-processing",
+                            "event-versioning",
+                        ]
+                    },
+                    {
+                        title: "DDD大厂实践",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "02-领域驱动设计DDD在B端营销系统的实践",
+                            "04-DDD设计流程，以业务案例解读",
+                            "09-DDD在大厂交易系统演进的应用",
+                        ]
+                    },
+                    ],
+
+                    "/md/mysql/": [{
+                        title: "MySQL基础",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-MySQL专栏大纲",
+                            "how-to-use-indexes-when-grouping-in-sql",
+                            "mysql-architecture-design",
+                            "InnoDB架构设计",
+                            "mysql-read-write-splitting",
+                            "为什么临时表可以重名？",
+                            "为什么阿里不推荐使用MySQL分区表？",
+                            "一文看懂这篇MySQL的锁机制",
+                        ]
+                    },
+
+                    {
+                        title: "MySQL实战",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "Java生态中性能最强数据库连接池HikariCP",
+                            "Java业务系统是怎么和MySQL交互的？",
+                            "亿级数据量商品系统的SQL调优实战",
+                            "MySQL查询优化",
+                            "MySQL深分页调优实战",
+                            "online-sql-deadlock-incident-how-to-prevent-deadlocks",
+                        ]
+                    },
+
+                    {
+                        title: "MySQL新特性",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "MySQL新特性",
+                            "what-is-new-in-mysql9",
+                        ]
+                    },
+                    ],
+
+                    "/md/reactive/": [{
+                        title: "响应式编程",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-Spring响应式编程",
+                            "响应式编程的适用场景",
+                            "01-想让系统更具有弹性？了解背压机制和响应式流的秘密！",
+                            "04-Spring为何偏爱Reactor响应式编程框架",
+                            "05-流式操作：如何使用 Flux 和 Mono 高效构建响应式数据流？",
+                        ]
+                    }],
+
+                    "/md/go/": [{
+                        title: "Go",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-Go概述",
+                            "01-macOS 安装go配置GOROOT GOPATH",
+                            "02-Go基本语法",
+                            "03-Go的数组array和切片slice语法详解",
+                        ]
+                    }],
+
+                    "/md/docker/": [{
+                        title: "Docker",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "Docker环境搭建",
+                            "00-Docker基础命令大全",
+                            "01-标准化打包技术",
+                            "通俗易懂的图文解密Docker容器网络",
+                        ]
+                    }],
+                    "/md/k8s/": [{
+                        title: "Kubernetes安装和使用",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "01-一键部署神器kubeadm",
+                            "快速搭建Kubernetes集群",
+                            "kubectl命令",
+                            "Kubernetes容器日志处理方案",
+                        ]
+                    },
+
+                    {
+                        title: "Kubernetes核心组件",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-Kubernetes的基本架构",
+                            "nature-of-kubernetes",
+                            "02-Kubernetes核心组件之kube-proxy实现原理",
+                            "pod-in-kubernetes",
+                            "kubernetes-workloads-controllers-deployment",
+                            "23-0-声明式API",
+                            "23-1-Envoy",
+                        ]
+                    },
+
+                    {
+                        title: "Kubernetes部署应用",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "使用 Kubernetes 部署 Nginx 应用",
+                        ]
+                    },
+
+                    {
+                        title: "Kubernetes云平台KubeSphere",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-为啥选择 kubesphere",
+                        ]
+                    },
+                    ],
+
+                    "/md/monitor/": [{
+                        title: "监控",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-你居然还去服务器上捞日志，搭个日志收集系统难道不香么！",
+                            "03-Loki 日志监控",
+                        ]
+                    },
+
+                    {
+                        title: "性能分析",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "并发用户、RPS、TPS的解读",
+                            "01-性能分析思路",
+                            "performance-optimization-guide",
+                        ]
+                    },
+                    ],
+
+                    "/md/netty/": [{
+                        title: "Netty基础",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "01-Netty源码面试实战+原理(一)-鸿蒙篇",
+                            "netty-basic-components",
+                            "ChannelPipeline接口",
+                            "(06-1)-ChannelHandler 家族",
+                            "(08)-学习Netty BootStrap的核心知识，成为网络编程高手！",
+                            "11-4-解码基于分隔符的协议和基于长度的协议",
+                            "18-检测新连接",
+                        ]
+                    },
+
+                    {
+                        title: "Netty实战",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "netty-off-heap-memory-leak-detection",
+                        ]
+                    },
+                    ],
+
+                    "/md/kafka/": [{
+                        title: "kafka",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-Kafka专栏大纲",
+                            "01-为何大厂都选择Kafka作为消息队列",
+                            "Kafka门派知多少",
+                            "08-全网最全图解Kafka适用场景",
+                            "09-消息队列的消息大量积压怎么办？",
+                            "13-KafkaAdminClient",
+                            "15-基于kafka实现延迟队列",
+                            "kafka-transaction-implementation",
+                            "kafka-versions",
+                        ]
+                    },],
+
+                    "/md/serverless/": [{
+                        title: "serverLess",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "serverless-is-a-scam",
+                        ]
+                    },],
+
+                    "/md/RocketMQ/": [{
+                        title: "消息队列基础",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "消息队列面试必问解析",
+                            "消息队列的事务消息",
+                            "避免无法克服的队列积压",
+                            "消息恰好被消费一次",
+                        ]
+                    },
+
+                    {
+                        title: "RocketMQ基础",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "01-RocketMQ核心内容",
+                            "RocketMQ各版本新特性",
+                            "01-基本概念",
+                            "02-下载安装",
+                            "03-消息的有序性",
+                            "04 - 订阅机制",
+                            "RocketMQ的延时消息",
+                            "RocketMQ 5.x任意时间延时消息原理",
+                            "05 - 批量消息和事务消息",
+                            "RocketMQ如何实现事务？",
+                        ]
+                    },
+
+                    {
+                        title: "RocketMQ存储设计",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "核心概念",
+                        ]
+                    },
+
+                    {
+                        title: "RocketMQ业务实战",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "02-基于电商场景的高并发RocketMQ实战",
+                            "RocketMQ在基金大厂的分布式事务实践",
+                        ]
+                    },
+                    ],
+
+                    "/md/rabbitmq/": [{
+                        title: "RabbitMQ",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-RabbitMQ实战下载与安装",
+                            "04-RabbitMQ & Spring整合开发",
+                            "RabbitMQ消费端幂等性概念及解决方案",
+                            "用了这么久的RabbitMQ异步编程竟然都是错的",
+                            "08-RabbitMQ的七种队列模式",
+                            "RabbitMQ的 RPC 消息模式你会了吗？",
+                            "12-RabbitMQ实战-消费端ACK、NACK及重回队列机制",
                         ]
-                    },
-                    {
-                        text: '面试',
-                        link: '/md/zqy/面试题/01-分布式技术面试实战.md'
-                    },
+                    },],
 
-                    {
-                        text: 'AI',
-                        items: [{
-                                text: 'Python基础',
-                                link: '/md/python/00-macOS和Linux安装和管理多个Python版本'
-                            },
-                            {
-                                text: 'AI算法',
-                                link: '/md/AI/ml/01-人工智能概要'
-                            },
-                            {
-                                text: 'AIGC应用开发',
-                                link: '/md/AI/AI大模型企业应用实战'
-                            },
-                            {
-                                text: '大模型平台和Prompt工程',
-                                link: '/md/AI/llm/GPTs'
-                            },
-                            {
-                                text: 'AI Agent',
-                                link: '/md/AI/agent/changelog-cursor'
-                            },
+                    "/md/redis/": [{
+                        title: "数据结构",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "Redis的整数数组和压缩列表",
+                            "Sorted sets、zset数据结构详解",
+                            "Redis Quicklist",
                         ]
                     },
-
                     {
-                        text: 'Vue',
-                        items: [{
-                            text: '01-Vue开发实战',
-                            link: '/md/vue/01-Vue开发实战.md'
-                        }, ]
+                        title: "持久化",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "Redis的RDB源码解析",
+                        ]
                     },
-
                     {
-                        text: '区块链',
-                        items: [{
-                                text: '区块链核心概念',
-                                link: '/md/chain/00-区块链专栏概述.md'
-                            },
-                            {
-                                text: '百度联盟链XuperChain',
-                                link: '/md/chain/03-百度联盟链Xuperchain核心概念.md'
-                            },
-                            {
-                                text: 'Flow平台实战',
-                                link: '/md/chain/02-认识Flow Cadence.md'
-                            },
-                            {
-                                text: '以太坊区块链',
-                                link: '/md/chain/01-以太坊智能合约与高级语言.md'
-                            },
-
+                        title: "基础",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "01-Redis和ZK分布式锁优缺点对比以及生产环境使用建议",
+                            "05-缓存读写策略模式详解",
+                            "06-如何快速定位 Redis 热 key",
+                            "Redis异步子线程原理详解",
+                            "12-Redis 闭源？",
                         ]
                     },
-
                     {
-                        text: '职业',
-                        items: [{
-                                text: '职业规划',
-                                link: '/md/career/为什么中国的程序员有35岁危机'
-                            },
-                            {
-                                text: '晋升',
-                                link: '/md/career/p6-promotion-guide'
-                            },
-
-                            {
-                                text: '职场',
-                                link: '/md/career/经常被压缩开发时间，延期还要背锅，如何破局？'
-                            },
-
-                            {
-                                text: '书单',
-                                link: '/md/career/Java-reading-list'
-                            },
-
-                            {
-                                text: '00-如何学习项目管理专栏',
-                                link: '/md/mgr/00-如何学习项目管理专栏.md'
-                            },
-
+                        title: "源码",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "02-Redisson可重入锁加锁源码分析",
+                            "03-Redisson公平锁加锁源码分析",
+                            "04-Redisson读写锁加锁机制分析",
                         ]
                     },
-
                     {
-                        text: '副业',
-                        items: [{
-                            text: '副业',
-                            link: '/md/sideline/16-精益独立开发实践.md'
-                        }, ]
-                    },
-                ],
-                // 文章详情页的侧边导航栏
-                sidebar: {
-                    "/md/Dubbo/": [{
-                        title: "Dubbo深入理解系列",
+                        title: "业务",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "01-互联网架构的发展历程.md",
-                            "02-Dubbo特性及工作原理.md",
-                            "03-Dubbo的负载均衡及高性能RPC调用.md",
-                            "04-Dubbo的通信协议.md",
-                            "05-Dubbo的应用及注册和SPI机制.md",
-                            "06-Dubbo相关面试题和源码使用技巧.md",
-                            "07-Dubbo真实生产环境思考.md"
+                            "00-数据结构的最佳实践",
                         ]
-                    }],
-                    "/md/zqy/面试题/": [{
-                            title: "面试突击",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "01-分布式技术面试实战.md",
-                                "02-注册中心和网关面试实战.md",
-                                "03-生产部署面试实战.md",
-                                "04-分布式锁、幂等性问题实战.md",
-                                "05-Java基础面试实战.md",
-                                "06-Spring面试实战.md",
-                                "07-计算机网络面试实战.md",
-                                "08-数据库面试实战.md",
-                                "09-网络通信及可见性面试实战.md",
-                                "10-Java 系统架构安全面试实战.md",
-                                "11-深挖网络 IO 面试实战.md",
-                                "12-分布式架构、性能优化、场景设计面试实战.md",
-                            ]
-                        },
-                        {
-
-                            title: "面试大全",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "面试题-Java基础.md",
-                                "面试题-MySQL.md",
-                                "面试题-Netty.md",
-                                "面试题-Redis.md",
-                                "面试题-场景题.md"
-                            ]
-                        },
-                        {
-                            title: "面试高频考点",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "gaopin/00-RocketMQ可靠性、重复消费解决方案.md",
-                                "gaopin/01-RocketMQ有序性、消息积压解决方案.md",
-                                "gaopin/02-Redis的IO多路复用.md",
-                                "gaopin/03-ZooKeeper运行原理.md"
-                            ]
-                        },
-                        {
-                            title: "互联网大厂面经",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "mianjing/00-淘天提前批面试.md",
-                                "mianjing/01-饿了么一面.md",
-                                "mianjing/02-美团优选后端一面.md",
-                                "mianjing/03.腾讯后端一面.md",
-                                "mianjing/04.美团优选后端一面.md",
-                                "mianjing/05.携程暑期实习一面.md",
-                                "mianjing/06.携程暑期实习二面.md",
-                            ]
-                        },
-                        {
-                            title: "架构设计",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "jiagou/01-B站评论系统架构设计.md",
-                                "jiagou/02-该从哪些方面提升系统的吞吐量？.md"
-                            ]
-                        }
-                    ],
-                    "/md/biz-arch/": [{
-                            title: "大厂业务架构",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "00-聚合支付架构从零到一",
-                                "01-供应链域数据中台设计",
-                                "02-供应链采购视角的业务系统架构",
-                                "03-客服平台架构实践",
-                                "04-数据质量中心系统设计",
-                                "05-大厂CRM系统架构优化实战",
-                                "06-运营后台系统设计",
-                                "07-大厂报价查询系统性能优化之道",
-                                "08-视频推荐索引构建",
-                                "小游戏的大促实践",
-                                "事件中心架构概述",
-                                "高性能排名系统的核心架构原理，架构师必看！",
-                            ]
-                        },
-                        {
-                            title: "系统设计",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "00-优惠券系统设计 Coupon System",
-                                "设计消息通知系统（Notification System）",
-                                "System design: Uber",
-                                "短链系统设计（design tiny url）",
-                                "打造一个高并发的十万用户 IM 聊天系统，你需要了解这些架构设计技巧！",
-                                "netflixs-distributed-counter-abstraction",
-                                "data-gateway-a-platform-for-growing-and-protecting-the-data-tier",
-                                "enhancing-netflix-reliability-with-service-level-prioritized-load-shedding",
-                                "title-launch-observability-at-netflix-scale",
-                                "cloud-efficiency-at-netflix",
-                                "linkedin-architecture-which-enables-searching-a-message-within-150ms",
-                                "how-meta-improved-their-cache-consistency-to-99-99999999",
-                            ]
-                        },
-
-                        {
-                            title: "用户画像",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "01-DMP系统简介",
-                                "05-用户画像是什么？",
-                                "06-构建高质量的用户画像",
-                                "07-用户画像和特征工程",
-                            ]
-                        },
-
-                        {
-                            title: "低代码",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "为什么“低代码”是未来趋势？",
-                                "01-低代码平台到底是什么样的？",
-                            ]
-                        },
-                    ],
-
-                    "/md/mgr/": [{
-                            title: "项目管理",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "00-如何学习项目管理专栏",
-                                "00-咋带领团队做成事？",
-                                "01-避免新手常犯的项目管理错误",
-                            ]
-                        },
-                        {
-                            title: "技术管理",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "00-新一代数据栈将逐步替代国内单一“数据中台”",
-                            ]
-                        },
+                    },
                     ],
-                    "/md/trade/": [{
-                        title: "交易中台",
+                    "/md/es/": [{
+                        title: "ElasticSearch",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "00-如何防止订单二次重复支付？",
-                            "01-扫码支付后都发生了啥？",
-                            "02-大厂的第三方支付业务架构设计",
-                            "wechat-pay-development-guide-avoid-pitfalls",
-                            "high-avail-payments",
+                            "ES专栏大纲",
+                            "ES基本概念",
+                            "02-MacOS下载安装启动ES和Kibana",
+                            "03-核心概念之NRT Document Index 分片 副本",
+                            "04-Kibana常见RESTful API操作",
+                            "05-倒排索引与分词",
+                            "07-整合进 SpringBoot 项目",
                         ]
                     }],
-
-                    "/md/product-center/": [{
-                        title: "商品中心",
+                    "/md/ck/": [{
+                        title: "ClickHouse",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "00-商品中心的spu、sku设计",
-                            "01-电商商品中心解密：仅凭SKU真的足够吗？",
-                            "02-大厂电商设计解析之商品管理系统",
+                            "clickhouse概述",
+                            "单机安装部署",
+                            "客户端基本操作",
+                            "为啥要学习ClickHouse",
+                            "为啥适合OLAP？",
+                            "clickhouse-jdbc",
                         ]
                     }],
 
-                    "/md/bigdata/": [{
-                            title: "大数据平台",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "大数据平台架构",
-                                "中小企业参考的商业大数据平台",
-                                "对象存储",
-                                "02-分布式对象存储设计原理",
-                                "AB测试与灰度发布",
-                                "当大数据遇上物联网",
-                                "移动计算",
-                                "大数据基准测试",
-                            ]
-                        },
-                        {
-                            title: "数据中台",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "00-新一代数据栈将逐步替代国内单一“数据中台”",
-                                "01-大数据的尽头是数据中台吗？",
-                                "03-构建数据中台的三要素：方法论、组织和技术",
-                                "05-如何统一管理纷繁杂乱的数据指标？",
-                            ]
-                        },
-                        {
-                            title: "Hadoop",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "安装下载Hadoop",
-                                "01-Hadoop",
-                                "HDFS",
-                                "03-HDFS伪分布式环境搭建",
-                                "04-hdfs dfs命令详解",
-                            ]
-                        },
-                        {
-                            title: "Hive",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "Hive专栏概述",
-                                "Hive 2.x 的安装与配置",
-                                "Hive执行原理",
-                                "Hive分区和分桶",
-                                "Hive修复分区",
-                                "hive的严格模式",
-                                "hiveserver2",
-                            ]
-                        },
-                        {
-                            title: "数据仓库",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "维度建模理论之事实表",
-                                "维度建模理论之维度表",
-                                "数仓逻辑模型",
-                                "数仓业务调研",
-                                "数仓分层和数仓建模",
-                                "轻松驾驭Hive数仓",
-                                "数仓开发之ODS层",
-                                "数仓开发之DIM层",
-                                "数仓开发之DWD层",
-                                "数仓开发之DWS层",
-                                "数仓开发之ADS层",
-                                "OLAP平台架构演化历程",
-                            ]
-                        },
-
-                        {
-                            title: "DataX",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "阿里云开源离线同步工具DataX3.0介绍",
-                                "数仓数据导出",
-                            ]
-                        },
-
-                        {
-                            title: "DolphinScheduler",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "DolphinScheduler简介",
-                                "DolphinScheduler部署",
-                                "DolphinScheduler参数",
-                                "DolphinScheduler资源中心",
-                                "DolphinScheduler告警通知",
-                                "作业帮基于 DolphinScheduler 的数据开发平台实践",
-                            ]
-                        },
-                    ],
-
-                    "/md/rpc/": [{
-                        title: "RPC",
+                    "/md/neo4j/": [{
+                        title: "Neo4j",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "04-RPC框架在网络通信的网络IO模型选型",
-                            "熔断限流",
-                            "11-RPC的负载均衡",
-                            "rpc-retry-mechanism",
-                            "RPC-Traffic-Replay",
+                            "neo4j-revolutionary-power-of-graph-databases",
                         ]
                     }],
 
-                    "/md/ShardingSphere/": [{
-                        title: "ShardingSphere",
+                    "/md/distdb/": [{
+                        title: "分布式数据库",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "10-顶级企业如何用数据脱敏保护用户隐私！",
-                            "11-动态配置管理背后的编排治理真相！",
-                            "14-ShardingSphere的分布式主键实现",
-                            "19-路由引擎：如何在路由过程中集成多种路由策略和路由算法？",
-                            "ShardingSphere 如何完美驾驭分布式事务与 XA 协议？",
-                            "ShardingSphere 如何轻松驾驭 Seata 柔性分布式事务？",
+                            "01-爆火的分布式数据库到底是个啥？",
+                            "03-BASE 还能撑多久？强一致性才是事务处理的终极奥义！",
+                            "18-分布式数据库的HTAP能统一OLTP和 OLAP吗？",
+                            "21-查询执行引擎：加速聚合计算加速",
+
                         ]
                     }],
 
-                    "/md/network/": [{
-                        title: "计算机网络",
+                    "/md/12306/": [{
+                        title: "项目介绍",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "TCP协议详解",
-                            "TCP连接的建立和断开受哪些系统配置影响？",
-                            "天天说架构，那CDN到底是什么？",
-                            "计算机网络-网络层原理",
+                            "12306-basic-info",
                         ]
-                    }],
-
-                    "/md/linux/": [{
-                        title: "Linux操作系统",
+                    },
+                    {
+                        title: "快速开始",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "00-操作系统专栏大纲",
-                            "01-Linux命令",
-                            "02-进程管理",
-                            "04-还记得纸带编程吗？",
-                            "超线程（Hyper-Threading），单指令多数据流（SIMD）技术"
+                            "环境搭建.md",
                         ]
-                    }],
-
-                    "/md/MQTT/": [{
-                        title: "MQTT",
+                    },
+                    {
+                        title: "核心技术文档",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "MQTT与Kafka在物联网消息与流数据集成实践",
-                            "07-MQTT发布订阅模式介绍"
+                            "如何生成分布式ID.md",
+                            "详解雪花算法.md",
+                            "责任链模式重构复杂业务场景.md",
+                            "死磕设计模式之抽象责任链模式.md",
+                            "策略模式在项目设计中的应用.md",
+                            "死磕设计模式之抽象策略模式.md",
+                            // "Builder模式在项目设计中的应用.md",
+                            "单例+简单工厂模式在项目设计中的应用.md",
+                            "选择合适的缓存过期策略",
+                            "Redis缓存雪崩、缓存穿透、缓存击穿解决方案详解",
+                            "redisson分布式锁使用",
+                            "redis-cache-expiry-strategy",
+                            "MySQL深分页调优实战",
+                            "ES深分页问题解决方案",
+                            "SpringBoot统一异常处理流程",
+                            "如何处理消息丢失问题？",
+                            "12306架构设计难点"
                         ]
-                    }],
+                    }
+                    ],
 
-                    "/md/activiti/": [{
-                        title: "Activiti7",
+
+                    "/md/ddd-mall/": [{
+                        title: "项目介绍",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "activiti7-introduction",
+                            "什么是DDD商城",
                         ]
-                    }],
+                    },
 
-                    "/md/spider/": [{
-                        title: "爬虫",
+                    {
+                        title: "电商业务",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "00-爬虫基础.md"
+                            "04-BFF 架构简介",
+                            "05-亿级用户如何分库分表",
+                            "06-商品秒杀库存超卖问题",
+                            "07-亿级商品数据同步至ES的高效方案",
+                            "08-订单超时未支付自动取消和库存回滚",
+                            "09-【防止重复下单】分布式系统接口幂等性实现方案",
+                            "10-百万数据量快速导入、导出MySQL",
+                            "11-分库分表平滑上线&快速回滚",
+                            "天天说架构，那CDN到底是什么？",
+                            "building-product-information-caching-system",
                         ]
-                    }],
+                    },
 
-                    "/md/ffmpeg/": [{
-                        title: "音视频基础",
+                    {
+                        title: "组件设计",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "audio-video-roadmap",
-                            "video-basic",
+                            "DDD-Mall商城的公共组件设计",
+                            "dddmall-base-spring-boot-starter",
+                            "dddmall-common-spring-boot-starter",
+                            "dddmall-cache-spring-boot-starter",
+                            "dddmall-convention-spring-boot-starter",
+                            "dddmall-idempotent-spring-boot-starter",
+                            "05-dddmall-database-spring-boot-starter",
+                            "06-dddmall-ddd-framework-core",
+                            "07-dddmall-designpattern-spring-boot-starter",
+                            "07-责任链模式",
+                            "07-建造者模式",
                         ]
-                    }],
+                    },
+                    ],
 
-                    "/md/data-analysis/basic/": [{
-                        title: "数分基础",
+                    "/md/risk-control/": [{
+                        title: "风控引擎架构设计",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "为啥要学习数据分析？",
-                            "correct-data-analysis-learning-methods",
-                            "learning-path-data-mining",
-                            "企业如何利用数据打造精准用户画像？",
-                            "如何自动化采集数据",
-                            "how-to-use-octoparse-for-data-scraping",
+                            "flink-real-time-risk-control-system-overview",
+                            "coupon-fraud-grey-market-chain",
+                            "coupon-distribution-risk-control-challenges",
+                            "risk-control-rules-thresholds-for-coupon-scenarios",
+                            "risk-control-engine-architecture-design",
+                            "reasons-for-choosing-groovy-for-risk-control-engine",
                         ]
-                    }],
+                    },],
 
-                    "/md/java/": [{
-                            title: "并发",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "00-Java并发编程.md",
-                                "01-synchronized原理.md",
-                                "02-volatile原理.md",
-                                "03-ReentrantLock与AQS.md",
-                                "04-线程池以及生产环境使用.md",
-                                "05-京东并行框架asyncTool如何针对高并发场景进行优化？.md",
-                                "java21-virtual-threads-where-did-my-lock-go",
-                            ]
-                        },
-                        {
-                            title: "JDK新特性",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "java-se-support-roadmap",
-                                "Java9新特性概述",
-                                "jdk14-new-features-complete-guide",
-                                "JDK16新特性",
-                                "understanding-java17-new-features-sealed-classes",
-                                "JDK21新特性",
-                                "JDK22新特性",
-                                "JDK23新特性",
-                                "java2024",
-                            ]
-                        },
-
-                        {
-                            title: "IDEA新功能",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "IntelliJ IDEA 2024.1 最新变化",
-                                "What’s-New-in-IntelliJ-IDEA-2024.2",
-                                "What’s-New-in-IntelliJ-IDEA-2024.3",
-                            ]
-                        },
-                    ],
-
-                    "/md/jvm/": [{
-                            title: "JVM基础",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "JVM专栏概述",
-                                "01-JVM虚拟机-上篇",
-                                "02-JVM虚拟机-下篇",
-                                "00-JDK为何自己首先破坏双亲委派模型",
-                                "00-G1垃圾收集器的日志格式",
-                                "Metadata GC Threshold in Java",
-                                "对象内存分配及Minor GC和Full GC全过程",
-                                "Java 性能调优：优化 GC 线程设置",
-                                "JDK性能调优神器",
-                            ]
-                        },
-
-                        {
-                            title: "JVM调优",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "高并发BI系统避免频繁Y-GC",
-                                "线上频繁Full GC，原来是外包同学不合理设置JVM参数！",
-                                "Java NIO为何导致堆外内存OOM了？",
-                                "一次由热部署导致的OOM排查经历",
-                                "队列积压了百万条消息，线上直接OOM了！",
-                            ]
-                        },
-                    ],
-
-                    "/md/algorithm/leetcode/": [{
-                        title: "大厂算法面试",
+                    "/md/go-gateway/": [{
+                        title: "Go微服务网关",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "00-阿里秋招高频算法题汇总-基础篇",
-                            "01-阿里秋招高频算法题汇总-中级篇",
-                            "02-阿里秋招高频算法题汇总-进阶篇",
-                            "03-字节秋招高频算法题汇总-基础篇",
-                            "04-字节秋招高频算法题汇总-中级篇",
-                            "05-字节秋招高频算法题汇总-进阶篇",
+                            "00-Go微服务网关专栏概述",
+                            "open-systems-interconnection-model",
+                        ]
+                    },],
+
+                    "/md/career/": [{
+                        title: "职业规划",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "为什么中国的程序员有35岁危机",
+                            "03-新人程序员入行忠告",
+                            "04-外企也半夜发布上线吗？",
+                            "05-中外程序员到底有啥区别？",
+                            "06-全球顶级架构师推荐的书单",
+                            "08-程序员为何一直被唱衰？",
+                            "09-程序员的“三步走”发展战略",
+                            "10-为何我建议你学会抄代码",
+                            "11-计师能去哪些央国企？",
+                            "mastering-architecture-diagrams",
+                            "how-i-tricked-my-brain-to-be-addicted-to-coding",
+                            "转型传统行业避坑指南",
+                            "workplace-jargon",
+                            "workplace-rule",
+                            "big-company-work-style",
+                            "研发的立足之本到底是啥？",
+                            "must-have-soft-skills-for-rd",
+                            "no-tech-no-future-for-rd",
+                            "moat-of-rd",
+                            "life-beyond-career-growth",
                         ]
-                    }, ],
+                    },
 
-                    "/md/algorithm/basic/": [{
-                        title: "数据结构与算法",
+                    {
+                        title: "晋升",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "00-数据结构与算法专栏大纲",
-                            "【图解数据结构与算法】LRU缓存淘汰算法面试时到底该怎么写",
-                            "【图解数据结构】外行人也能看懂的哈希表",
-                            "dag-directed-acyclic-graph",
+                            "p6-promotion-guide",
+                            "why-hard-work-didnt-get-you-promoted-the-overlooked-truth",
+                            "performance-review-guideline",
                         ]
-                    }],
+                    },
 
-                    "/md/algorithm/practise/": [{
-                        title: "工程应用",
+                    {
+                        title: "职场",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "哈希算法原来有这么多应用场景！",
+                            "经常被压缩开发时间，延期还要背锅，如何破局？",
                         ]
-                    }],
-
-                    "/md/spring/": [{
-                            title: "Spring",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "Spring之BeanNameAware和BeanFactoryAware接口",
-                                "这次彻底搞懂IoC容器依赖注入的源码",
-                                "别小看Spring过滤器,这些知识点你必须得掌握",
-                                "Spring框架使用了哪些设计模式",
-                                "阿里四面：你知道Spring AOP创建Proxy的过程吗？",
-                            ]
-                        },
+                    },
 
-                        {
-                            title: "SpringMVC",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "01-SpringMVC的AsyncHandlerInterceptor异步的处理器拦截器",
-                                "02-实现http请求的异步长轮询",
-                                "03-SpringMVC拦截处理器",
-                                "SpringMVC-service-doDispatch",
-                                "SpringMVC-DispatcherServlet-doDispatch",
-                            ]
-                        },
 
-                        {
-                            title: "SpringBoot",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "00-可能是全网最全的SpringBoot启动流程源码分析",
-                                "01-HelloSpringBoot应用程序",
-                                "SpringBoot默认线程池",
-                            ]
-                        },
+                    {
+                        title: "书单",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "Java-reading-list",
+                            "efficient-professional-reading-list",
+                        ]
+                    },
 
-                        {
-                            title: "SpringBoot新特性",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "SpringBoot3.4-release",
-                            ]
-                        },
                     ],
 
-
-                    "/md/tomcat/": [{
-                        title: "Tomcat",
+                    "/md/vue/": [{
+                        title: "Vue",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "00-不知道这些Servlet规范、容器，还敢说自己是Java程序员",
-                            "01-Jetty架构设计之Connector、Handler组件",
-                            "03-Tomcat的生命周期管理",
-                            "04-Tomcat实现热部署、热加载原理解析",
-                            "05-Tomcat如何打破双亲委派机制实现隔离Web应用的？",
-                            "Tomcat进程占用CPU过高怎么办？",
+                            "01-Vue开发实战",
+                            "vue2-to-vue3",
+                            "05-教你快速搭建Vue3工程化项目",
+                            "Vuex设计Vue3项目的数据流",
+                            "router",
+                            "table",
                         ]
                     }],
 
-
-                    "/md/seata/": [{
-                        title: "Seata",
+                    "/md/sideline/": [{
+                        title: "副业",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "01-Seata客户端依赖坐标引入与踩坑排雷",
-                            "02-Seata客户端全局事务配置与实现",
-                            "03-Seata柔性事务",
-                            "04-Seata是什么?",
-                            "05-开始",
-                            "docker-install-configure-seata-server",
+                            "16-精益独立开发实践",
+                            "17-用户画像都是怎么产生的？",
+                            "20-个人支付解决方案",
+                            "21-处理用户反馈和增长优化",
+                            "22-大纲的注意点",
                         ]
                     }],
 
-                    "/md/spring/spring-cloud/": [{
-                            title: "SpringCloudAlibaba",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "SpringCloudAlibaba介绍.md",
-                            ]
-                        },
-
-                        {
-                            title: "SpringCloudGateway组件",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "SpringCloudGateway工作原理与链路图.md",
-                                "SpringCloudGateway核心之Predicate.md",
-                                "SpringCloudGateway之Filter多过程介绍.md",
-                                "SpringCloudGateway之熔断集成篇.md",
-                                "SpringCloudGateway之限流集成篇.md",
-                                "SpringCloudGateway之统一鉴权篇.md",
-                                "SpringCloudGateway之高性能篇.md"
-                            ]
-                        }
-                    ],
-
-                    "/md/spring/spring-cloud/practise": [{
-                        title: "大厂实践",
+                    "/md/chain/": [{
+                        title: "区块链核心概念",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "01-Segment为何永别微服务了？",
+                            "00-区块链专栏概述",
+                            "三分钟，快速了解区块链技术",
+                            "01-联盟链入门",
+                            "05-账本模型",
+                            "06-智能合约",
+                            "07-网络与共识",
+                            "08-工作量证明",
+                            "09-一文看懂以太坊智能合约！",
+                            "blockchain-smart-contract-helloworld-project",
                         ]
-                    }, ],
-
-                    "/md/DDD/": [{
-                            title: "DDD基础知识",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "00-DDD专栏规划",
-                                "基于电商履约场景的DDD实战",
-                                "11-上下文映射",
-                                "13-DDD分层架构及代码目录结构",
-                                "domain-service",
-                                "23-理解领域事件（Domain Event）",
-                            ]
-                        },
-
-                        {
-                            title: "事件驱动",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "integrating-event-driven-microservices-with-request-response-APIs",
-                                "decouple-event-retrieval-from-processing",
-                                "use-circuit-breaker-to-pause-event-retrieval",
-                                "rate-limit-event-processing",
-                                "event-versioning",
-                            ]
-                        },
-                        {
-                            title: "DDD大厂实践",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "02-领域驱动设计DDD在B端营销系统的实践",
-                                "04-DDD设计流程，以业务案例解读",
-                                "09-DDD在大厂交易系统演进的应用",
-                            ]
-                        },
-                    ],
-
-                    "/md/mysql/": [{
-                            title: "MySQL基础",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "00-MySQL专栏大纲",
-                                "how-to-use-indexes-when-grouping-in-sql",
-                                "mysql-architecture-design",
-                                "InnoDB架构设计",
-                                "mysql-read-write-splitting",
-                                "为什么临时表可以重名？",
-                                "为什么阿里不推荐使用MySQL分区表？",
-                                "一文看懂这篇MySQL的锁机制",
-                            ]
-                        },
-
-                        {
-                            title: "MySQL实战",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "Java生态中性能最强数据库连接池HikariCP",
-                                "Java业务系统是怎么和MySQL交互的？",
-                                "亿级数据量商品系统的SQL调优实战",
-                                "MySQL查询优化",
-                                "MySQL深分页调优实战",
-                                "online-sql-deadlock-incident-how-to-prevent-deadlocks",
-                            ]
-                        },
-
-                        {
-                            title: "MySQL新特性",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "MySQL新特性",
-                                "what-is-new-in-mysql9",
-                            ]
-                        },
-                    ],
-
-                    "/md/reactive/": [{
-                        title: "响应式编程",
+                    },
+                    {
+                        title: "百度联盟链XuperChain",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "00-Spring响应式编程",
-                            "响应式编程的适用场景",
-                            "01-想让系统更具有弹性？了解背压机制和响应式流的秘密！",
-                            "04-Spring为何偏爱Reactor响应式编程框架",
-                            "05-流式操作：如何使用 Flux 和 Mono 高效构建响应式数据流？",
+                            "03-百度联盟链Xuperchain核心概念",
+                            "04-XuperChain核心流程",
                         ]
-                    }],
+                    },
 
-                    "/md/go/": [{
-                        title: "Go",
+                    {
+                        title: "Flow平台实战",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "00-Go概述",
-                            "01-macOS 安装go配置GOROOT GOPATH",
-                            "02-Go基本语法",
-                            "03-Go的数组array和切片slice语法详解",
+                            "02-认识Flow Cadence",
+                            "03-Cadence基础语法",
                         ]
-                    }],
+                    },
 
-                    "/md/docker/": [{
-                        title: "Docker",
+                    {
+                        title: "以太坊区块链",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "Docker环境搭建",
-                            "00-Docker基础命令大全",
-                            "01-标准化打包技术",
-                            "通俗易懂的图文解密Docker容器网络",
+                            "01-以太坊智能合约与高级语言",
+                            "02-DAPP",
+                            "03-以太坊的EVM",
+                            "04-Solidity基础语法",
+                            "05-Solidity开发智能合约",
+                            "06-通过web3.js与以太坊客户端进行交互",
+                            "07-Truffle",
                         ]
-                    }],
-                    "/md/k8s/": [{
-                            title: "Kubernetes安装和使用",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "01-一键部署神器kubeadm",
-                                "快速搭建Kubernetes集群",
-                                "kubectl命令",
-                                "Kubernetes容器日志处理方案",
-                            ]
-                        },
-
-                        {
-                            title: "Kubernetes核心组件",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "00-Kubernetes的基本架构",
-                                "nature-of-kubernetes",
-                                "02-Kubernetes核心组件之kube-proxy实现原理",
-                                "pod-in-kubernetes",
-                                "kubernetes-workloads-controllers-deployment",
-                                "23-0-声明式API",
-                                "23-1-Envoy",
-                            ]
-                        },
-
-                        {
-                            title: "Kubernetes部署应用",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "使用 Kubernetes 部署 Nginx 应用",
-                            ]
-                        },
-
-                        {
-                            title: "Kubernetes云平台KubeSphere",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "00-为啥选择 kubesphere",
-                            ]
-                        },
-                    ],
-
-                    "/md/monitor/": [{
-                            title: "监控",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "00-你居然还去服务器上捞日志，搭个日志收集系统难道不香么！",
-                                "03-Loki 日志监控",
-                            ]
-                        },
-
-                        {
-                            title: "性能分析",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "并发用户、RPS、TPS的解读",
-                                "01-性能分析思路",
-                                "performance-optimization-guide",
-                            ]
-                        },
-                    ],
-
-                    "/md/netty/": [{
-                            title: "Netty基础",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "01-Netty源码面试实战+原理(一)-鸿蒙篇",
-                                "netty-basic-components",
-                                "ChannelPipeline接口",
-                                "(06-1)-ChannelHandler 家族",
-                                "(08)-学习Netty BootStrap的核心知识，成为网络编程高手！",
-                                "11-4-解码基于分隔符的协议和基于长度的协议",
-                                "18-检测新连接",
-                            ]
-                        },
+                    },
 
-                        {
-                            title: "Netty实战",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "netty-off-heap-memory-leak-detection",
-                            ]
-                        },
                     ],
 
-                    "/md/kafka/": [{
-                        title: "kafka",
+                    "/md/python/": [{
+                        title: "Python基础",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "00-Kafka专栏大纲",
-                            "01-为何大厂都选择Kafka作为消息队列",
-                            "Kafka门派知多少",
-                            "08-全网最全图解Kafka适用场景",
-                            "09-消息队列的消息大量积压怎么办？",
-                            "13-KafkaAdminClient",
-                            "15-基于kafka实现延迟队列",
-                            "kafka-transaction-implementation",
-                            "kafka-versions",
+                            "00-macOS和Linux安装和管理多个Python版本",
                         ]
-                    }, ],
+                    },],
 
-                    "/md/serverless/": [{
-                        title: "serverLess",
+                    "/md/AI/llm/": [{
+                        title: "大模型发展",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "serverless-is-a-scam",
+                            "llm-api-platform",
+                            "GPTs",
+                            "ChatGPT为啥不用Websocket而是EventSource",
+                            "携手阿里云：JetBrains AI Assistant 正式发布！",
+                            "中国大陆用户如何使用Jetbrains内置的AI插件AI Assistant",
+                            "contextual-retrieval",
+                            "lm-studio-transform-mac-into-ai-tool",
+                            "navigating-llm-deployment-tips-tricks-and-techniques",
+                            "qwen-QwQ",
+                            "only-ai-flow-can-do",
+                            "chatgpt-canva",
+                            "llm-reasoning-limitations",
+                            "making-an-llm-that-sees-and-reasons",
                         ]
-                    }, ],
-
-                    "/md/RocketMQ/": [{
-                            title: "消息队列基础",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "消息队列面试必问解析",
-                                "消息队列的事务消息",
-                                "避免无法克服的队列积压",
-                                "消息恰好被消费一次",
-                            ]
-                        },
+                    },
+                    {
+                        title: "DeepSeek",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "deepseek-r1-detail",
+                        ]
+                    },
 
-                        {
-                            title: "RocketMQ基础",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "01-RocketMQ核心内容",
-                                "RocketMQ各版本新特性",
-                                "01-基本概念",
-                                "02-下载安装",
-                                "03-消息的有序性",
-                                "04 - 订阅机制",
-                                "RocketMQ的延时消息",
-                                "RocketMQ 5.x任意时间延时消息原理",
-                                "05 - 批量消息和事务消息",
-                                "RocketMQ如何实现事务？",
-                            ]
-                        },
+                    {
+                        title: "Claude",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "Claude3到底多强",
+                            "计算机使用功能",
+                            "claude-3-7-sonnet",
+                        ]
+                    },
 
-                        {
-                            title: "RocketMQ存储设计",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "核心概念",
-                            ]
-                        },
+                    {
+                        title: "llama",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "llama-4-multimodal-intelligence",
+                        ]
+                    },
+                    {
+                        title: "Prompt工程",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "01-Prompt网站",
+                            "02-常用Prompt",
+                        ]
+                    },
 
-                        {
-                            title: "RocketMQ业务实战",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "02-基于电商场景的高并发RocketMQ实战",
-                                "RocketMQ在基金大厂的分布式事务实践",
-                            ]
-                        },
+                    {
+                        title: "Dify",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "what-is-llmops",
+                            "Build-App-with-Dify",
+                            "integrate-dify-and-aws-services-to-enable-more-flexible-translation-workflows",
+                            "llm-knowledge-base-segmentation-data-cleaning",
+                        ]
+                    },
                     ],
 
-                    "/md/rabbitmq/": [{
-                        title: "RabbitMQ",
+                    "/md/AI/ml/": [{
+                        title: "机器学习",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "00-RabbitMQ实战下载与安装",
-                            "04-RabbitMQ & Spring整合开发",
-                            "RabbitMQ消费端幂等性概念及解决方案",
-                            "用了这么久的RabbitMQ异步编程竟然都是错的",
-                            "08-RabbitMQ的七种队列模式",
-                            "RabbitMQ的 RPC 消息模式你会了吗？",
-                            "12-RabbitMQ实战-消费端ACK、NACK及重回队列机制",
+                            "软件工程师转型AI的全攻略",
+                            "01-人工智能概要",
+                            "02-MR 算法分类",
+                            "what-is-neural-network",
+                            "MapReduce分治思想",
+                            "05-开发环境安装",
+                            "一文看懂AI的Transformer架构",
+                            "what-is-tensor",
                         ]
-                    }, ],
+                    },
 
-                    "/md/redis/": [{
-                            title: "数据结构",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "Redis的整数数组和压缩列表",
-                                "Sorted sets、zset数据结构详解",
-                                "Redis Quicklist",
-                            ]
-                        },
-                        {
-                            title: "持久化",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "Redis的RDB源码解析",
-                            ]
-                        },
-                        {
-                            title: "基础",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "01-Redis和ZK分布式锁优缺点对比以及生产环境使用建议",
-                                "05-缓存读写策略模式详解",
-                                "06-如何快速定位 Redis 热 key",
-                                "Redis异步子线程原理详解",
-                                "12-Redis 闭源？",
-                            ]
-                        },
-                        {
-                            title: "源码",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "02-Redisson可重入锁加锁源码分析",
-                                "03-Redisson公平锁加锁源码分析",
-                                "04-Redisson读写锁加锁机制分析",
-                            ]
-                        },
-                        {
-                            title: "业务",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "00-数据结构的最佳实践",
-                            ]
-                        },
-                    ],
-                    "/md/es/": [{
-                        title: "ElasticSearch",
+                    {
+                        title: "PyTorch",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "ES专栏大纲",
-                            "ES基本概念",
-                            "02-MacOS下载安装启动ES和Kibana",
-                            "03-核心概念之NRT Document Index 分片 副本",
-                            "04-Kibana常见RESTful API操作",
-                            "05-倒排索引与分词",
-                            "07-整合进 SpringBoot 项目",
+                            "building-neural-networks-with-pytorch",
+                            "pytorch-cifar10-image-classifier-tutorial",
                         ]
-                    }],
-                    "/md/ck/": [{
-                        title: "ClickHouse",
+                    },
+
+                    {
+                        title: "NLP",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "clickhouse概述",
-                            "单机安装部署",
-                            "客户端基本操作",
-                            "为啥要学习ClickHouse",
-                            "为啥适合OLAP？",
-                            "clickhouse-jdbc",
+                            "basic-of-nlp",
+                            "text-preprocessing-overview",
+                            "text-vectorization-guide",
+                            "text-data-analysis-practical-guide",
+                            "key-path-from-feature-enhancement-to-dimensional-norm",
+                            "text-data-augmentation-back-translation-guide",
                         ]
-                    }],
-
-                    "/md/neo4j/": [{
-                        title: "Neo4j",
+                    },
+
+                    {
+                        title: "RNN",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "neo4j-revolutionary-power-of-graph-databases",
+                            "what-is-rnn",
+                            "neural-memory-engine-for-sequence-modeling",
+                            "long-short-term-memory",
+                            "gated-recurrent-unit-model",
                         ]
-                    }],
+                    },
 
-                    "/md/distdb/": [{
-                        title: "分布式数据库",
+                    {
+                        title: "Transformer",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "01-爆火的分布式数据库到底是个啥？",
-                            "03-BASE 还能撑多久？强一致性才是事务处理的终极奥义！",
-                            "18-分布式数据库的HTAP能统一OLTP和 OLAP吗？",
-                            "21-查询执行引擎：加速聚合计算加速",
-
+                            "mask-tensor",
                         ]
-                    }],
-
-                    "/md/12306/": [{
-                            title: "项目介绍",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "12306-basic-info",
-                            ]
-                        },
-                        {
-                            title: "快速开始",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "环境搭建.md",
-                            ]
-                        },
-                        {
-                            title: "核心技术文档",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "如何生成分布式ID.md",
-                                "详解雪花算法.md",
-                                "责任链模式重构复杂业务场景.md",
-                                "死磕设计模式之抽象责任链模式.md",
-                                "策略模式在项目设计中的应用.md",
-                                "死磕设计模式之抽象策略模式.md",
-                                // "Builder模式在项目设计中的应用.md",
-                                "单例+简单工厂模式在项目设计中的应用.md",
-                                "选择合适的缓存过期策略",
-                                "Redis缓存雪崩、缓存穿透、缓存击穿解决方案详解",
-                                "redisson分布式锁使用",
-                                "redis-cache-expiry-strategy",
-                                "MySQL深分页调优实战",
-                                "ES深分页问题解决方案",
-                                "SpringBoot统一异常处理流程",
-                                "如何处理消息丢失问题？",
-                                "12306架构设计难点"
-                            ]
-                        }
-                    ],
-
-
-                    "/md/ddd-mall/": [{
-                            title: "项目介绍",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "什么是DDD商城",
-                            ]
-                        },
-
-                        {
-                            title: "电商业务",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "04-BFF 架构简介",
-                                "05-亿级用户如何分库分表",
-                                "06-商品秒杀库存超卖问题",
-                                "07-亿级商品数据同步至ES的高效方案",
-                                "08-订单超时未支付自动取消和库存回滚",
-                                "09-【防止重复下单】分布式系统接口幂等性实现方案",
-                                "10-百万数据量快速导入、导出MySQL",
-                                "11-分库分表平滑上线&快速回滚",
-                                "天天说架构，那CDN到底是什么？",
-                                "building-product-information-caching-system",
-                            ]
-                        },
+                    },
 
-                        {
-                            title: "组件设计",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "DDD-Mall商城的公共组件设计",
-                                "dddmall-base-spring-boot-starter",
-                                "dddmall-common-spring-boot-starter",
-                                "dddmall-cache-spring-boot-starter",
-                                "dddmall-convention-spring-boot-starter",
-                                "dddmall-idempotent-spring-boot-starter",
-                                "05-dddmall-database-spring-boot-starter",
-                                "06-dddmall-ddd-framework-core",
-                                "07-dddmall-designpattern-spring-boot-starter",
-                                "07-责任链模式",
-                                "07-建造者模式",
-                            ]
-                        },
                     ],
 
-                    "/md/risk-control/": [{
-                        title: "风控引擎架构设计",
+                    "/md/AI/langchain4j/": [{
+                        title: "LangChain4j基础",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "flink-real-time-risk-control-system-overview",
-                            "coupon-fraud-grey-market-chain",
-                            "coupon-distribution-risk-control-challenges",
-                            "risk-control-rules-thresholds-for-coupon-scenarios",
-                            "risk-control-engine-architecture-design",
-                            "reasons-for-choosing-groovy-for-risk-control-engine",
+                            "01-intro",
+                            "get-started",
+                            "spring-boot-integration",
+                            "chat-and-language-models",
+                            "chat-memory",
+                            "response-streaming",
+                            "ai-services",
+                            "tools",
+                            "rag",
+                            "observability",
                         ]
-                    }, ],
+                    },
 
-                    "/md/go-gateway/": [{
-                        title: "Go微服务网关",
+                    {
+                        title: "LangChain4j新特性",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "00-Go微服务网关专栏概述",
-                            "open-systems-interconnection-model",
+                            "04-0-最新发布功能",
+                            "04-1-最新发布功能",
+                            "04-2-最新发布功能",
+                            "04-3-最新发布功能",
                         ]
-                    }, ],
-
-                    "/md/career/": [{
-                            title: "职业规划",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "为什么中国的程序员有35岁危机",
-                                "03-新人程序员入行忠告",
-                                "04-外企也半夜发布上线吗？",
-                                "05-中外程序员到底有啥区别？",
-                                "06-全球顶级架构师推荐的书单",
-                                "08-程序员为何一直被唱衰？",
-                                "09-程序员的“三步走”发展战略",
-                                "10-为何我建议你学会抄代码",
-                                "11-计师能去哪些央国企？",
-                                "mastering-architecture-diagrams",
-                                "how-i-tricked-my-brain-to-be-addicted-to-coding",
-                                "转型传统行业避坑指南",
-                                "workplace-jargon",
-                                "workplace-rule",
-                                "big-company-work-style",
-                                "研发的立足之本到底是啥？",
-                                "must-have-soft-skills-for-rd",
-                                "no-tech-no-future-for-rd",
-                                "moat-of-rd",
-                                "life-beyond-career-growth",
-                            ]
-                        },
-
-                        {
-                            title: "晋升",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "p6-promotion-guide",
-                                "why-hard-work-didnt-get-you-promoted-the-overlooked-truth",
-                                "performance-review-guideline",
-                            ]
-                        },
-
-                        {
-                            title: "职场",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "经常被压缩开发时间，延期还要背锅，如何破局？",
-                            ]
-                        },
-
-
-                        {
-                            title: "书单",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "Java-reading-list",
-                                "efficient-professional-reading-list",
-                            ]
-                        },
-
+                    },
                     ],
 
-                    "/md/vue/": [{
-                        title: "Vue",
+                    "/md/AI/agent/": [{
+                        title: "辅助编程",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "01-Vue开发实战",
-                            "vue2-to-vue3",
-                            "05-教你快速搭建Vue3工程化项目",
-                            "Vuex设计Vue3项目的数据流",
-                            "router",
-                            "table",
+                            "changelog-cursor",
+                            "goodbye-cursor-hello-windsurf",
                         ]
-                    }],
+                    },
+                    ],
 
-                    "/md/sideline/": [{
-                        title: "副业",
+                    "/md/AI/mcp/": [{
+                        title: "MCP",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "16-精益独立开发实践",
-                            "17-用户画像都是怎么产生的？",
-                            "20-个人支付解决方案",
-                            "21-处理用户反馈和增长优化",
-                            "22-大纲的注意点",
+                            "mcp-fad-or-fixture",
+                            "mcp-and-the-future-of-ai-tooling",
                         ]
-                    }],
-
-                    "/md/chain/": [{
-                            title: "区块链核心概念",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "00-区块链专栏概述",
-                                "三分钟，快速了解区块链技术",
-                                "01-联盟链入门",
-                                "05-账本模型",
-                                "06-智能合约",
-                                "07-网络与共识",
-                                "08-工作量证明",
-                                "09-一文看懂以太坊智能合约！",
-                                "blockchain-smart-contract-helloworld-project",
-                            ]
-                        },
-                        {
-                            title: "百度联盟链XuperChain",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "03-百度联盟链Xuperchain核心概念",
-                                "04-XuperChain核心流程",
-                            ]
-                        },
-
-                        {
-                            title: "Flow平台实战",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "02-认识Flow Cadence",
-                                "03-Cadence基础语法",
-                            ]
-                        },
-
-                        {
-                            title: "以太坊区块链",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "01-以太坊智能合约与高级语言",
-                                "02-DAPP",
-                                "03-以太坊的EVM",
-                                "04-Solidity基础语法",
-                                "05-Solidity开发智能合约",
-                                "06-通过web3.js与以太坊客户端进行交互",
-                                "07-Truffle",
-                            ]
-                        },
-
-                    ],
-
-                    "/md/python/": [{
-                        title: "Python基础",
+                    },
+                    {
+                        title: "MCP核心概念",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "00-macOS和Linux安装和管理多个Python版本",
+                            "resources",
                         ]
-                    }, ],
-
-                    "/md/AI/llm/": [{
-                            title: "大模型发展",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "llm-api-platform",
-                                "GPTs",
-                                "ChatGPT为啥不用Websocket而是EventSource",
-                                "携手阿里云：JetBrains AI Assistant 正式发布！",
-                                "中国大陆用户如何使用Jetbrains内置的AI插件AI Assistant",
-                                "contextual-retrieval",
-                                "lm-studio-transform-mac-into-ai-tool",
-                                "navigating-llm-deployment-tips-tricks-and-techniques",
-                                "qwen-QwQ",
-                                "only-ai-flow-can-do",
-                                "chatgpt-canva",
-                                "mcp-fad-or-fixture",
-                                "mcp-and-the-future-of-ai-tooling",
-                                "llm-reasoning-limitations",
-                                "making-an-llm-that-sees-and-reasons",
-                            ]
-                        },
-                        {
-                            title: "DeepSeek",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "deepseek-r1-detail",
-                            ]
-                        },
-
-                        {
-                            title: "Claude",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "Claude3到底多强",
-                                "计算机使用功能",
-                                "claude-3-7-sonnet",
-                            ]
-                        },
-
-                        {
-                            title: "llama",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "llama-4-multimodal-intelligence",
-                            ]
-                        },
-                        {
-                            title: "Prompt工程",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "01-Prompt网站",
-                                "02-常用Prompt",
-                            ]
-                        },
-
-                        {
-                            title: "Dify",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "what-is-llmops",
-                                "Build-App-with-Dify",
-                                "integrate-dify-and-aws-services-to-enable-more-flexible-translation-workflows",
-                                "llm-knowledge-base-segmentation-data-cleaning",
-                            ]
-                        },
-                    ],
-
-                    "/md/AI/ml/": [{
-                            title: "机器学习",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "软件工程师转型AI的全攻略",
-                                "01-人工智能概要",
-                                "02-MR 算法分类",
-                                "what-is-neural-network",
-                                "MapReduce分治思想",
-                                "05-开发环境安装",
-                                "一文看懂AI的Transformer架构",
-                                "what-is-tensor",
-                            ]
-                        },
-
-                        {
-                            title: "PyTorch",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "building-neural-networks-with-pytorch",
-                                "pytorch-cifar10-image-classifier-tutorial",
-                            ]
-                        },
-
-                        {
-                            title: "NLP",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "basic-of-nlp",
-                                "text-preprocessing-overview",
-                                "text-vectorization-guide",
-                                "text-data-analysis-practical-guide",
-                                "key-path-from-feature-enhancement-to-dimensional-norm",
-                                "text-data-augmentation-back-translation-guide",
-                            ]
-                        },
-
-                        {
-                            title: "RNN",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "what-is-rnn",
-                                "neural-memory-engine-for-sequence-modeling",
-                                "long-short-term-memory",
-                                "gated-recurrent-unit-model",
-                            ]
-                        },
-
-                        {
-                            title: "Transformer",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "mask-tensor",
-                            ]
-                        },
-
-                    ],
-
-                    "/md/AI/langchain4j/": [{
-                            title: "LangChain4j基础",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "01-intro",
-                                "get-started",
-                                "spring-boot-integration",
-                                "chat-and-language-models",
-                                "chat-memory",
-                                "response-streaming",
-                                "ai-services",
-                                "tools",
-                                "rag",
-                                "observability",
-                            ]
-                        },
-
-                        {
-                            title: "LangChain4j新特性",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "04-0-最新发布功能",
-                                "04-1-最新发布功能",
-                                "04-2-最新发布功能",
-                                "04-3-最新发布功能",
-                            ]
-                        },
-                    ],
-                    
-                    "/md/AI/agent/": [{
-                            title: "辅助编程",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "changelog-cursor",
-                                "goodbye-cursor-hello-windsurf",
-                            ]
-                        },
+                    },
                     ],
 
                     "/md/AI/spring-ai-alibaba/": [{
@@ -2276,198 +2301,198 @@ module.exports = {
                         children: [
                             "why-choose-spring-ai-alibaba-for-smart-customer-service",
                         ]
-                    }, ],
+                    },],
 
                     "/md/AI/": [{
-                            title: "LangChain",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "00-introduction-to-langchain",
-                                "01-langchain-hello-world-project",
-                                "02-LangChain实战：用prompts模板调教LLM的输入出",
-                                "03-示例选择器",
-                                "04-LLMs和Chat Models",
-                                "05-Loader机制",
-                                "06-文档转换实战",
-                            ]
-                        },
-                        {
-                            title: "RAG",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "00-rag-introduction-tool-to-eliminate-llm-hallucinations",
-                                "01-RAG应用框架和解析器",
-                                "02-相似性检索的关键 - Embedding",
-                                "03-core-of-rag-result-retrieval-and-reordering",
-                                "04-prompt-helping-llm-understand-knowledge",
-                            ]
-                        },
-                        {
-                            title: "LLM应用开发",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "AI大模型企业应用实战",
-                                "00-为什么要学习大模型",
-                                "01-大语言模型发展",
-                                "02-domestic-and-international-llm-multi-model-strong-applications",
-                                "03-large-language-model-flaws",
-                                "04-ai-ecosystem-industry-analysis",
-                                "05-ai-era-turning-point-for-app-developers",
-                                "06-智能体项目案例",
-                            ]
-                        },
-                        {
-                            title: "Agent基础",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "01-what-are-agents",
-                                "02-how-langchain-agents-are-implemented",
-                                "03-what-is-zero-shot-one-shot-few-shot-learning",
-                                "04-how-to-add-memory-in-langchain-agents",
-                                "05-how-to-enable-memory-sharing-between-agent-and-tool",
-                                "06-how-to-use-langchain-built-in-tools",
-                                "07-lcel-langchain-expression-language",
-                                "08-ali-tongyi-qianwen-openai-compatible-solution",
-                                "09-lcel-chain-and-prompt-implementation",
-                                "10-ali-tongyi-qianwen-status-codes-explanation",
-                                "11-lcel-memory-addition-method",
-                                "12-lcel-agent-core-components",
-                                "13-best-development-practices",
-                                "local-large-model-deployment",
-                            ]
-                        },
+                        title: "LangChain",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-introduction-to-langchain",
+                            "01-langchain-hello-world-project",
+                            "02-LangChain实战：用prompts模板调教LLM的输入出",
+                            "03-示例选择器",
+                            "04-LLMs和Chat Models",
+                            "05-Loader机制",
+                            "06-文档转换实战",
+                        ]
+                    },
+                    {
+                        title: "RAG",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-rag-introduction-tool-to-eliminate-llm-hallucinations",
+                            "01-RAG应用框架和解析器",
+                            "02-相似性检索的关键 - Embedding",
+                            "03-core-of-rag-result-retrieval-and-reordering",
+                            "04-prompt-helping-llm-understand-knowledge",
+                        ]
+                    },
+                    {
+                        title: "LLM应用开发",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "AI大模型企业应用实战",
+                            "00-为什么要学习大模型",
+                            "01-大语言模型发展",
+                            "02-domestic-and-international-llm-multi-model-strong-applications",
+                            "03-large-language-model-flaws",
+                            "04-ai-ecosystem-industry-analysis",
+                            "05-ai-era-turning-point-for-app-developers",
+                            "06-智能体项目案例",
+                        ]
+                    },
+                    {
+                        title: "Agent基础",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "01-what-are-agents",
+                            "02-how-langchain-agents-are-implemented",
+                            "03-what-is-zero-shot-one-shot-few-shot-learning",
+                            "04-how-to-add-memory-in-langchain-agents",
+                            "05-how-to-enable-memory-sharing-between-agent-and-tool",
+                            "06-how-to-use-langchain-built-in-tools",
+                            "07-lcel-langchain-expression-language",
+                            "08-ali-tongyi-qianwen-openai-compatible-solution",
+                            "09-lcel-chain-and-prompt-implementation",
+                            "10-ali-tongyi-qianwen-status-codes-explanation",
+                            "11-lcel-memory-addition-method",
+                            "12-lcel-agent-core-components",
+                            "13-best-development-practices",
+                            "local-large-model-deployment",
+                        ]
+                    },
 
-                        {
-                            title: "Agent应用",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "01-three-minute-fastapi-ai-agent-setup",
-                                "02-Agent应用对话情感优化",
-                                "03-use-tts-to-make-your-ai-agent-speak",
-                                "langserve-revolutionizes-llm-app-deployment",
-                                "customizing-a-tool-for-your-ai-agent",
-                                "Complex-SQL-Joins-with-LangGraph-and-Waii",
-                                "AI Agent应用出路到底在哪？",
-                                "building-effective-agents",
-                                "ai-agent-is-coming",
-                                "software-development-in-AI2",
-                                "overcoming-fear-uncertainty-and-doubt-in-the-era-of-ai-transformation",
-                                "aigc-app-in-e-commerce-review",
-                                "ai-trends-disrupting-software-teams",
-                            ]
-                        },
+                    {
+                        title: "Agent应用",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "01-three-minute-fastapi-ai-agent-setup",
+                            "02-Agent应用对话情感优化",
+                            "03-use-tts-to-make-your-ai-agent-speak",
+                            "langserve-revolutionizes-llm-app-deployment",
+                            "customizing-a-tool-for-your-ai-agent",
+                            "Complex-SQL-Joins-with-LangGraph-and-Waii",
+                            "AI Agent应用出路到底在哪？",
+                            "building-effective-agents",
+                            "ai-agent-is-coming",
+                            "software-development-in-AI2",
+                            "overcoming-fear-uncertainty-and-doubt-in-the-era-of-ai-transformation",
+                            "aigc-app-in-e-commerce-review",
+                            "ai-trends-disrupting-software-teams",
+                        ]
+                    },
 
-                        {
-                            title: "LangGraph",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "00-introduce-to-LangGraph",
-                                "langgraph-studio",
-                                "multi_agent",
-                                "methods-adapting-large-language-models",
-                                "to-fine-tune-or-not-to-fine-tune-llm",
-                                "effective-datasets-fine-tuning",
-                            ]
-                        },
+                    {
+                        title: "LangGraph",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-introduce-to-LangGraph",
+                            "langgraph-studio",
+                            "multi_agent",
+                            "methods-adapting-large-language-models",
+                            "to-fine-tune-or-not-to-fine-tune-llm",
+                            "effective-datasets-fine-tuning",
+                        ]
+                    },
                     ],
 
                     "/md/design/": [{
-                            title: "重构",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "00-软件架构权衡-我们为什么以及如何进行权衡？",
-                                "01-软件架构权衡-无意识决策的问题",
-                                "02-软件架构权衡-架构特性",
-                                "代码的坏味道",
-                                "分离关注点的意义",
-                                "如何了解一个软件的设计？",
-                                "架构之美：教你如何分析一个接口？",
-                                "业务代码如何才能不再写出大串的if else？",
-                                "阿里P8架构师都是怎么分析软件模型的？",
-                                "evolution-software-architecture-mainframes-to-distributed-computing",
-                                "cell-based-architecture-distributed-systems",
-                                "cell-based-architecture-resilient-fault-tolerant-systems",
-                                "cell-based-architecture-adoption-guidelines",
-                                "架构师教你kill祖传石山代码重复&大量ifelse",
-                                "measuring-technical-debt",
-                            ]
-                        },
-                        {
-                            title: "设计原则",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "01-单一职责原则",
-                                "rest-api-design-resource-modeling",
-                            ]
-                        },
+                        title: "重构",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-软件架构权衡-我们为什么以及如何进行权衡？",
+                            "01-软件架构权衡-无意识决策的问题",
+                            "02-软件架构权衡-架构特性",
+                            "代码的坏味道",
+                            "分离关注点的意义",
+                            "如何了解一个软件的设计？",
+                            "架构之美：教你如何分析一个接口？",
+                            "业务代码如何才能不再写出大串的if else？",
+                            "阿里P8架构师都是怎么分析软件模型的？",
+                            "evolution-software-architecture-mainframes-to-distributed-computing",
+                            "cell-based-architecture-distributed-systems",
+                            "cell-based-architecture-resilient-fault-tolerant-systems",
+                            "cell-based-architecture-adoption-guidelines",
+                            "架构师教你kill祖传石山代码重复&大量ifelse",
+                            "measuring-technical-debt",
+                        ]
+                    },
+                    {
+                        title: "设计原则",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "01-单一职责原则",
+                            "rest-api-design-resource-modeling",
+                        ]
+                    },
 
-                        {
-                            title: "设计模式",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "【Java设计模式实战】单例模式",
-                                "模板方法设计模式（Template Pattern）",
-                                "策略模式Strategy Pattern",
-                                "建造者模式",
-                                "代理模式Proxy Pattern",
-                                "适配器模式",
-                                "门面模式",
-                            ]
-                        },
+                    {
+                        title: "设计模式",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "【Java设计模式实战】单例模式",
+                            "模板方法设计模式（Template Pattern）",
+                            "策略模式Strategy Pattern",
+                            "建造者模式",
+                            "代理模式Proxy Pattern",
+                            "适配器模式",
+                            "门面模式",
+                        ]
+                    },
                     ],
 
                     "/md/spark/": [{
-                            title: "Spark",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "Spark架构",
-                            ]
-                        },
-                        {
-                            title: "Spark SQL",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "为啥要学习Spark？",
-                                "00-Spark安装及启动",
-                                "01-Spark的Local模式与应用开发入门",
-                                "03-SparkSQL入门",
-                                "04-SparkSQL的API编程之DataFrame",
-                                "05-快速理解SparkSQL的DataSet",
-                                "06-RDD与DataFrame的互操作",
-                                "07-Spark的Data Sources",
-                                "08-Spark SQL整合Hive",
-                            ]
-                        },
-                        {
-                            title: "Spark Streaming",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "00-为啥要学习Spark Streaming",
-                                "01-Spark Streaming专栏概述",
-                                "02-Spark Streaming小试流式处理",
-                            ]
-                        },
-                        {
-                            title: "Spark MLlib",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "spark-ml-basic-statistics",
-                                "07-回归算法",
-                            ]
-                        },
+                        title: "Spark",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "Spark架构",
+                        ]
+                    },
+                    {
+                        title: "Spark SQL",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "为啥要学习Spark？",
+                            "00-Spark安装及启动",
+                            "01-Spark的Local模式与应用开发入门",
+                            "03-SparkSQL入门",
+                            "04-SparkSQL的API编程之DataFrame",
+                            "05-快速理解SparkSQL的DataSet",
+                            "06-RDD与DataFrame的互操作",
+                            "07-Spark的Data Sources",
+                            "08-Spark SQL整合Hive",
+                        ]
+                    },
+                    {
+                        title: "Spark Streaming",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "00-为啥要学习Spark Streaming",
+                            "01-Spark Streaming专栏概述",
+                            "02-Spark Streaming小试流式处理",
+                        ]
+                    },
+                    {
+                        title: "Spark MLlib",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "spark-ml-basic-statistics",
+                            "07-回归算法",
+                        ]
+                    },
                     ],
 
                     "/md/flink/": [{
@@ -2489,26 +2514,26 @@ module.exports = {
                             "flink-cep",
                             "flink-checkpoint",
                         ]
-                    }, ],
+                    },],
 
                     "/md/security/": [{
-                            title: "常见攻击手段",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
+                        title: "常见攻击手段",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
 
-                            ]
-                        },
-                        {
-                            title: "OAuth 2.0实战",
-                            collapsable: false,
-                            sidebarDepth: 0,
-                            children: [
-                                "OAuth 2.0实战-为什么要先获取授权码code.md",
-                                "03-OAuth2.0实战-轻松学会使用JWT，让你的OAuth2.0实现更加安全高效！",
-                                "07-你确定懂OAuth 2.0的三方软件和受保护资源服务？",
-                            ]
-                        },
+                        ]
+                    },
+                    {
+                        title: "OAuth 2.0实战",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "OAuth 2.0实战-为什么要先获取授权码code.md",
+                            "03-OAuth2.0实战-轻松学会使用JWT，让你的OAuth2.0实现更加安全高效！",
+                            "07-你确定懂OAuth 2.0的三方软件和受保护资源服务？",
+                        ]
+                    },
                     ],
                 }
             }
diff --git a/docs/md/AI/llm/mcp-and-the-future-of-ai-tooling.md b/docs/md/AI/mcp/mcp-and-the-future-of-ai-tooling.md
similarity index 100%
rename from docs/md/AI/llm/mcp-and-the-future-of-ai-tooling.md
rename to docs/md/AI/mcp/mcp-and-the-future-of-ai-tooling.md
diff --git a/docs/md/AI/llm/mcp-fad-or-fixture.md b/docs/md/AI/mcp/mcp-fad-or-fixture.md
similarity index 100%
rename from docs/md/AI/llm/mcp-fad-or-fixture.md
rename to docs/md/AI/mcp/mcp-fad-or-fixture.md
diff --git a/docs/md/AI/mcp/resources.md b/docs/md/AI/mcp/resources.md
new file mode 100644
index 000000000..83346f610
--- /dev/null
+++ b/docs/md/AI/mcp/resources.md
@@ -0,0 +1,236 @@
+# 释放数据潜力：利用 MCP 资源让大模型读懂你的服务器
+
+## 0 前言
+
+> 向LLM暴露服务器上的数据和内容
+
+资源（Resources）是MCP核心概念，允许服务器将数据和内容暴露，供客户端读取，并作为大模型交互的上下文使用。
+
+### 注意
+
+资源是**由应用控制**的，即客户端应用可自行决定资源的使用方式和时机。不同 MCP 客户端可能不同方式处理资源，如：
+
+- Claude Desktop 要求用户手动选择资源后才能用
+- 其他客户端可能会基于启发式方法自动选择资源
+- 有些实现甚至允许 AI 模型自行决定使用哪些资源。
+
+因此，服务器开发者在实现资源支持时，应考虑各种交互方式。如希望自动将数据暴露给模型，应使用**由模型控制**的工具。
+
+## 1 概述
+
+资源可代表 MCP 服务器希望提供给客户端的任何类型的数据，包括但不限于：
+
+- 文件内容
+- 数据库记录
+- API 响应
+- 实时系统数据
+- 截图和图像
+- 日志文件
+- 其他各种数据
+
+每个资源都有一个唯一 URI 标识，内容可以是文本或二进制数据。
+
+## 2 URI
+
+资源通过 URI 唯一标识，格式如下：
+
+```
+[protocol]://[host]/[path]
+```
+
+示例：
+
+- `file:///home/user/documents/report.pdf`
+- `postgres://database/customers/schema`
+- `screen://localhost/display1`
+
+URI 的协议和路径结构由 MCP 服务器自行定义，服务器可定制自己的 URI 方案。
+
+## 3 类型
+
+资源内容可分为两种类型：
+
+### 3.1 文本
+
+包含 UTF-8 编码的文本数据，适合以下内容：
+
+- 源代码
+- 配置文件
+- 日志文件
+- JSON/XML 数据
+- 纯文本
+
+### 3.2 二进制
+
+包含使用 base64 编码的原始二进制数据，适合以下内容：
+
+- 图像
+- PDF
+- 音频文件
+- 视频文件
+- 其他非文本格式
+
+## 4 发现方式
+
+客户端可通过两种方式发现可用资源：
+
+### 4.1 直接资源列表
+
+服务器通过 `resources/list` 接口提供明确的资源清单，每个资源包含以下信息：
+
+```typescript
+{
+  uri: string;           // 资源唯一标识
+  name: string;          // 可读名称
+  description?: string;  // 可选描述信息
+  mimeType?: string;     // 可选 MIME 类型
+}
+```
+
+### 4.2 资源模板
+
+对于动态资源，服务器可暴露 [URI 模板](https://datatracker.ietf.org/doc/html/rfc6570)，客户端可根据模板生成合法的资源 URI：
+
+```typescript
+{
+  uriTemplate: string;   // 遵循 RFC 6570 的 URI 模板
+  name: string;          // 可读名称
+  description?: string;  // 可选描述
+  mimeType?: string;     // 可选 MIME 类型
+}
+```
+
+## 5 读取资源内容
+
+客户端使用资源 URI 通过 `resources/read` 请求读取资源，服务器返回资源内容列表：
+
+```typescript
+{
+  contents: [
+    {
+      uri: string;        // 资源 URI
+      mimeType?: string;  // 可选 MIME 类型
+
+      // 二选一：
+      text?: string;      // 文本内容
+      blob?: string;      // 二进制内容（base64 编码）
+    }
+  ]
+}
+```
+
+服务器可在一次 `resources/read` 请求中返回多个资源，如读取目录时可返回其中的所有文件。
+
+## 6 更新
+
+MCP 支持实时资源更新，主要有两种机制：
+
+### 6.1 列表变更
+
+当服务器的资源列表发生变化时，通过 `notifications/resources/list_changed` 通知客户端。
+
+### 6.2 内容变更
+
+客户端可以订阅某个资源的变更：
+
+1. 客户端发送 `resources/subscribe` 请求并附带资源 URI；
+2. 服务器在资源内容变更时，发送 `notifications/resources/updated` 通知；
+3. 客户端通过 `resources/read` 获取最新内容；
+4. 客户端可以发送 `resources/unsubscribe` 取消订阅。
+
+## 7 示例
+
+简单的 MCP 服务器实现资源支持的例子：
+
+```js
+// 提供资源列表
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  return {
+    resources: [
+      {
+        uri: "file:///logs/app.log",
+        name: "应用日志",
+        mimeType: "text/plain"
+      }
+    ]
+  };
+});
+
+// 读取资源内容
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  const uri = request.params.uri;
+
+  if (uri === "file:///logs/app.log") {
+    const logContents = await readLogFile();
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "text/plain",
+          text: logContents
+        }
+      ]
+    };
+  }
+
+  throw new Error("未找到资源");
+});
+```
+
+```python
+@app.list_resources()
+async def list_resources() -> list[types.Resource]:
+    return [
+        types.Resource(
+            uri="file:///logs/app.log",
+            name="应用日志",
+            mimeType="text/plain"
+        )
+    ]
+
+@app.read_resource()
+async def read_resource(uri: AnyUrl) -> str:
+    if str(uri) == "file:///logs/app.log":
+        log_contents = await read_log_file()
+        return log_contents
+
+    raise ValueError("未找到资源")
+
+# 启动服务器
+async with stdio_server() as streams:
+    await app.run(
+        streams[0],
+        streams[1],
+        app.create_initialization_options()
+    )
+```
+
+## 8 最佳实践
+
+实现资源支持时，建议：
+
+1. 使用清晰、具描述性的资源名称和 URI；
+2. 添加有用的描述，帮助大模型理解资源；
+3. 在已知的情况下设置合适的 MIME 类型；
+4. 为动态内容实现资源模板；
+5. 对频繁变更的资源使用订阅机制；
+6. 出错时返回清晰明了的错误信息；
+7. 对资源列表进行分页处理（如有必要）；
+8. 在适当情况下缓存资源内容；
+9. 处理资源前先验证 URI；
+10. 文档中注明自定义的 URI 方案。
+
+## 9 安全
+
+在暴露资源时，请注意以下安全措施：
+
+- 验证所有资源 URI 的合法性；
+- 实施适当的访问控制策略；
+- 清理文件路径，防止目录遍历攻击；
+- 谨慎处理二进制数据；
+- 对资源读取设置速率限制；
+- 审计资源访问记录；
+- 传输过程中加密敏感数据；
+- 验证 MIME 类型是否符合预期；
+- 为耗时较长的读取操作设置超时机制；
+- 适时清理过期或无效资源。
\ No newline at end of file
diff --git "a/docs/md/spring/02-\345\256\236\347\216\260http\350\257\267\346\261\202\347\232\204\345\274\202\346\255\245\351\225\277\350\275\256\350\257\242.md" "b/docs/md/spring/02-\345\256\236\347\216\260http\350\257\267\346\261\202\347\232\204\345\274\202\346\255\245\351\225\277\350\275\256\350\257\242.md"
index 5bdf73650..7f7aae3f1 100644
--- "a/docs/md/spring/02-\345\256\236\347\216\260http\350\257\267\346\261\202\347\232\204\345\274\202\346\255\245\351\225\277\350\275\256\350\257\242.md"
+++ "b/docs/md/spring/02-\345\256\236\347\216\260http\350\257\267\346\261\202\347\232\204\345\274\202\346\255\245\351\225\277\350\275\256\350\257\242.md"
@@ -2,32 +2,36 @@
 
 ## 1 场景
 
-客户端调用服务端接口，服务端这个接口比较耗时。为了优化服务端的性能。
+客户端调用服务端接口，服务端这接口较耗时。为优化服务端性能，服务端收到servlet请求后，释放掉servlet占用的线程资源。
 
-服务端收到servlet请求后，释放掉servlet占用的线程资源。
+### 1.1 传统servlet
 
-> 传统的 servlet 请求处理是同步的，即每个请求占用一个线程，直到请求处理完毕。如果处理时间较长，会阻塞线程，导致性能下降。
+请求处理是同步的，即每个请求占用一个线程，直到请求处理完毕。若处理时间较长，会阻塞线程，导致性能下降。
 
-开启一个异步线程去处理耗时的操作。当耗时操作处理完成后，将结果返回给客户端。
+开启一个异步线程去处理耗时操作，处理完成后，将结果返给客户端。
 
-**注意：在此期间，客户端和服务端的http链接并不会断开，客户端依旧苦苦等待响应数据；**
+> 注意：期间，客户端和服务端的http链接并不会断开，客户端依旧苦苦等待响应数据。
 
 ## 2 技术选型
 
-可用接口AsyncHandlerInterceptor实现拦截涉及异步处理的请求，注意不是HandlerInterceptor。
-
-HandlerInterceptorAdapter适配器，适配了AsyncHandlerInterceptor和HandlerInterceptor，推荐用其来实现：
-
-![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/2be35325b10b83b9ae159e91d7b4bf17.png)
+可用接口AsyncHandlerInterceptor拦截涉及异步处理的请求。HandlerInterceptorAdapter适配器，适配了AsyncHandlerInterceptor和HandlerInterceptor，推荐用其来实现：
 
 ```java
-void afterConcurrentHandlingStarted(HttpServletRequest request,
+package org.springframework.web.servlet.handler;
+
+/**
+ * Abstract adapter class for the {@link AsyncHandlerInterceptor} interface,
+ * for simplified implementation of pre-only/post-only interceptors.
+ */
+public abstract class HandlerInterceptorAdapter implements AsyncHandlerInterceptor {
+  
+  void afterConcurrentHandlingStarted(HttpServletRequest request,
                                     HttpServletResponse response,
                                     Object handler)
                              throws Exception
 ```
 
-不过在 springboot3.x 中已废除，故本文使用AsyncHandlerInterceptor。
+但 SpringBoot3.x 中已废除，故本文用AsyncHandlerInterceptor。
 
 ## 3 实现
 
@@ -35,26 +39,85 @@ void afterConcurrentHandlingStarted(HttpServletRequest request,
 
 释放Servlet线程，交由指定的线程池去处理，咋定义指定线程池？
 
-![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/8912a45334dbd2cb696da4902e9b9e84.png)
+```java
+@Configuration
+public class InterceptorConfig implements WebMvcConfigurer {
+  	
+  	public void addInterceptors(InterceptorRegistry registry) {
+    	registry.addInterceptor(myAsyncHandlerInterceptor).addPathPatterns("/**");
+		}
+  	
+  
+  	@Override
+    public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
+        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
+        threadPoolTaskExecutor.setCorePoolSize(5);
+        threadPoolTaskExecutor.setAllowCoreThreadTimeOut(true);
+        threadPoolTaskExecutor.setMaxPoolSize(5);
+        threadPoolTaskExecutor.setQueueCapacity(50);
+        threadPoolTaskExecutor.setThreadNamePrefix("async-service-");
+        threadPoolTaskExecutor.initialize();
+
+        configurer.setTaskExecutor(threadPoolTaskExecutor);
+    }
+```
 
 ### 2.1.2 实现拦截器
 
-
-
-![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/99977920f0357862bbb59cb85d3acc6f.png)
+```java
+public class MyAsyncHandlerInterceptor implements AsyncHandlerInterceptor {
+
+    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
+        log.info("interceptor#preHandle called.");
+        return true;
+    }
+
+    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
+        log.info("interceptor#postHandle called. ");
+    }
+
+    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
+        log.info("interceptor#afterCompletion called.");
+    }
+
+    /**
+     * 该方法执行后，会执行Controller方法返回的callable方法
+     * 这个方法的目的时，当servlet线程被释放后，执行清除例如ThreadLocal、MDC等资源的操作。
+     */
+    public void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response, Object handler) {
+        log.info("interceptor#afterConcurrentHandlingStarted. ");
+    }
+}
+```
 
 ### 2.1.3 Controller代码
 
 方法返回的Callable：
 
-![](/Users/javaedge/Downloads/IDEAProjects/java-edge-master/assets/image-20240609233534463.png)
+```java
+public class AsyncController {
+
+    @RequestMapping(value = "/t2")
+    public Callable<String> t2() {
+        log.info("controller#handler called. Thread: " + Thread.currentThread().getName());
+
+        Callable<String> callable = () -> {
+            log.info("controller-callable#async task started. Thread: " + Thread.currentThread().getName());
+            Thread.sleep(300);
+            log.info("controller-callable#async task finished");
+            return "async result";
+        };
+
+        log.info("controller#handler finished");
+        return callable;
+    }
+}
+```
 
 ## 4 流程
 
 ### 4.1 流程图
 
-
-
 ![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/d51d633137767848ce57ad0bb7f41e93.webp)
 
 执行效果：

From 33e34714187572411a22e1c041d243837a8956ba Mon Sep 17 00:00:00 2001
From: JavaEdge <sss2855845850@gmail.com>
Date: Sun, 27 Apr 2025 17:59:37 +0800
Subject: [PATCH 16/20] docs:update

---
 docs/.vuepress/config.js                      |  16 +-
 docs/md/AI/agent/Junie.md                     |  69 ++
 .../langchain4j/customizable-http-client.md   |  54 ++
 docs/md/AI/langchain4j/mcp.md                 | 244 +++++++
 docs/md/AI/langchain4j/structured-outputs.md  | 646 ++++++++++++++++++
 docs/md/AI/llm/lmstudio-local-llm-call.md     |  76 +++
 docs/md/AI/mcp/mcp-java-sdk.md                |  92 +++
 docs/md/design/iterator-pattern.md            | 581 ++++++++++++++++
 .../md/design/proxy-pattern.md                |   2 +-
 .../md/design/strategy-pattern.md             |   2 +-
 .../md/design/template-pattern.md             |   0
 docs/md/java/java24-new-features.md           | 240 +++++++
 12 files changed, 2016 insertions(+), 6 deletions(-)
 create mode 100644 docs/md/AI/agent/Junie.md
 create mode 100644 docs/md/AI/langchain4j/customizable-http-client.md
 create mode 100644 docs/md/AI/langchain4j/mcp.md
 create mode 100644 docs/md/AI/langchain4j/structured-outputs.md
 create mode 100644 docs/md/AI/llm/lmstudio-local-llm-call.md
 create mode 100644 docs/md/AI/mcp/mcp-java-sdk.md
 create mode 100644 docs/md/design/iterator-pattern.md
 rename "docs/md/design/\344\273\243\347\220\206\346\250\241\345\274\217Proxy Pattern.md" => docs/md/design/proxy-pattern.md (99%)
 rename "docs/md/design/\347\255\226\347\225\245\346\250\241\345\274\217Strategy Pattern.md" => docs/md/design/strategy-pattern.md (99%)
 rename "docs/md/design/\346\250\241\346\235\277\346\226\271\346\263\225\350\256\276\350\256\241\346\250\241\345\274\217\357\274\210Template Pattern\357\274\211.md" => docs/md/design/template-pattern.md (100%)
 create mode 100644 docs/md/java/java24-new-features.md

diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index 93868eb4c..274c99337 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -155,7 +155,7 @@ module.exports = {
                         text: '设计模式',
                         items: [{
                             text: '模板方法设计模式（Template Pattern）',
-                            link: '/md/design/模板方法设计模式（Template Pattern）.md'
+                            link: '/md/design/template-pattern'
                         },]
                     },
                     {
@@ -1244,6 +1244,7 @@ module.exports = {
                             "JDK21新特性",
                             "JDK22新特性",
                             "JDK23新特性",
+                            "java24-new-features",
                             "java2024",
                         ]
                     },
@@ -2117,6 +2118,7 @@ module.exports = {
                             "chatgpt-canva",
                             "llm-reasoning-limitations",
                             "making-an-llm-that-sees-and-reasons",
+                            "lmstudio-local-llm-call",
                         ]
                     },
                     {
@@ -2247,7 +2249,10 @@ module.exports = {
                             "ai-services",
                             "tools",
                             "rag",
+                            "structured-outputs",
                             "observability",
+                            "customizable-http-client",
+                            "mcp",
                         ]
                     },
 
@@ -2271,6 +2276,7 @@ module.exports = {
                         children: [
                             "changelog-cursor",
                             "goodbye-cursor-hello-windsurf",
+                            "Junie",
                         ]
                     },
                     ],
@@ -2282,6 +2288,7 @@ module.exports = {
                         children: [
                             "mcp-fad-or-fixture",
                             "mcp-and-the-future-of-ai-tooling",
+                            "mcp-java-sdk",
                         ]
                     },
                     {
@@ -2440,12 +2447,13 @@ module.exports = {
                         sidebarDepth: 0,
                         children: [
                             "【Java设计模式实战】单例模式",
-                            "模板方法设计模式（Template Pattern）",
-                            "策略模式Strategy Pattern",
+                            "template-pattern",
+                            "strategy-pattern",
                             "建造者模式",
-                            "代理模式Proxy Pattern",
+                            "proxy-pattern",
                             "适配器模式",
                             "门面模式",
+                            "iterator-pattern",
                         ]
                     },
                     ],
diff --git a/docs/md/AI/agent/Junie.md b/docs/md/AI/agent/Junie.md
new file mode 100644
index 000000000..0fbd097e9
--- /dev/null
+++ b/docs/md/AI/agent/Junie.md
@@ -0,0 +1,69 @@
+# 对标cursor，JetBrains官方推出Junie！
+
+![](https://blog.jetbrains.com/wp-content/uploads/2025/01/Blog_1280x720.png)
+
+## 0 前言
+
+Junie 能根据开发者在 IDE 中提供的项目上下文信息，执行所分配的编码任务。
+
+可让 Junie “实现用于管理书签的增删改查操作，并带有用户界面”。Junie 会收集所有相关的上下文信息，然后规划出完成任务的各个步骤，包括分析项目结构、检查依赖项、确认是否存在需要通过的测试、创建所需的源文件、运行测试等。
+
+![](https://imgopt.infoq.com/fit-in/3000x4000/filters:quality(85)/filters:no_upscale()/news/2025/01/jetbrains-junie-agent/en/resources/1jetbrains-junie-1738338914161.jpg)
+
+任务完成后，Junie 会指出当前方案可能存在的已知限制，用户可以进行查看、修改，最终决定是否接受。Junie 还能为现有程序编写测试用例、运行代码检查等。
+
+## 1 基准测试
+
+![](https://blog.jetbrains.com/wp-content/uploads/2025/01/Blog_body_1280x604.png)
+
+Junie 在 [SWEBench Verified 基准测试](https://www.swebench.com/#verified) 中完成 53.6% 任务，该测试涵盖 500 多个编程任务。
+
+根据 SWEBench Verified —— 一个涵盖 500 个开发任务的权威基准测试，Junie 在单次运行中可完成 53.6% 的任务。这一成绩展示了它强大的潜力，也证明了 Junie 能适应现代软件开发中各种复杂程度不同的任务，为全球数百万开发者和企业解锁 AI 编码代理的力量。
+
+## 2 AI 编码代理 V.S AI 编码助手
+
+AI 编码代理可以看作是 AI 编码助手的进化版：
+
+- 后者主要是在编辑器中根据用户提示提供代码补全或重构建议，比如根据方法签名或注释建议实现方式、生成文档等
+- 而 AI 代理则更强调自主完成整个任务，从“辅助开发者”向“与开发者协作”的模式转变
+
+已有许多大厂和初创公司加入这一领域，如：
+
+- AWS 最近为其 [Q Developer](https://www.infoq.com/news/2024/12/new-amazon-q-developer-agent/) 助手增加代理功能
+- Google 发布基于 Gemini 2.0 的 [Jules 代理](https://www.infoq.com/news/2024/12/google-jules-agent/)
+- GitHub 推出基于 GPT-4 Turbo 的 [Copilot Workspace](https://www.infoq.com/news/2024/05/github-copilot-workspace-preview/)
+- 许多表现突出的代理工具跻身 SWEBench Verified 排行榜前十，如 [W&B Programmer O1 crosscheck5](https://wandb.ai/)、[Blackbox AI Agent](https://www.blackbox.ai/)、[CodeStory Midwit Agent + swe-search](https://aide.dev/)、[Emergent.ai](https://emergent.sh/) 等
+
+JetBrains  2023 年就推出[AI Assistant](https://www.infoq.com/news/2023/12/jetbrains-ai-assistant-ga/)，但市场反馈褒贬不一，[有开发者称其功能强大，也有人提出批评](https://plugins.jetbrains.com/plugin/22282-jetbrains-ai-assistant/reviews)。目前市场上还有其他编码助手可选，如 [GitHub Copilot](https://www.infoq.com/news/2024/12/github-copilot-free-vscode/)、[Google Code Assist](https://www.infoq.com/news/2025/01/gemini-code-assist-tools/)、[AWS CodeWhisperer](https://www.infoq.com/news/2022/07/aws-codewhisperer-coding/)。
+
+## 3 JetBrains使命
+
+推动新一代技术的发展，让软件开发变得更高效、更有趣。为了赋能开发者，我们打造了众多专业开发工具，包括强大的 AI 功能，已经显著提升了开发效率，并为创意打开了新的可能。那么，我们能否更进一步：提升代码质量、激发创新、完成复杂任务、彻底改变编程方式？
+
+答案是：**当然可以！**
+
+随着 Junie 的推出，JetBrains 正在重新定义编码方式。借助 Junie 的“代理智能”能力，你可以在 IDE 中将繁琐的任务完全交由它处理，也可以与它协作完成复杂任务。得益于 JetBrains IDE 的强大能力与可靠的大型语言模型（LLM），Junie 能解决原本需要几个小时的工作。
+
+<iframe title="See Junie in Action: Your Coding Agent in IntelliJ IDEA, a JetBrains IDE" width="500" height="281" src="https://www.youtube.com/embed/ufPGsZtqrac?feature=oembed" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen="" style="box-sizing: inherit; max-height: 100%; max-width: 100%; top: 0px; left: 0px; width: 849px; height: 477.138px;"></iframe>
+
+## 4 重塑开发者体验
+
+### 4.1 无缝集成到你熟悉IDE
+
+Junie不会打乱你的工作节奏，而是帮助你更高效地创造与实现。只需在 IDE 中安装 Junie，即可开始使用。你可以先将简单任务交给它处理，逐步适应这种协作方式，无需改变现有的开发流程。
+
+等你熟悉之后，可以让 Junie 处理更复杂的任务，融入团队协作流程，重新定义任务分配方式，从而提升生产效率，激发创造力，释放 AI 编码代理带来的全新开发体验。
+
+<iframe title="Meet Junie: Your Coding Agent in PyCharm, a JetBrains IDE" width="500" height="281" src="https://www.youtube.com/embed/wpz_0MgNZ5w?feature=oembed" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen="" style="box-sizing: inherit; max-height: 100%; max-width: 100%; top: 0px; left: 0px; width: 849px; height: 477.138px;"></iframe>
+
+### 4.2 始终掌控你的代码
+
+开发者可以快速查看 Junie 提出的更改、保持对项目上下文的把握，并主导关键决策。即使将任务交给 Junie，你也始终掌握主导权，可以审阅代码更动以及它执行命令的方式。
+
+### 4.3 提升代码质量
+
+AI 生成的代码同样可能存在缺陷。Junie 的目标不仅是加快开发速度，更是提升代码质量标准。借助 JetBrains IDE 与 LLM 的结合，Junie 能生成代码、运行检查、编写测试并验证测试是否通过。
+
+### 4.4 让 Junie 成为值得信赖的队友
+
+Junie 设计上能够理解每个项目的上下文，也能适应你的编程风格。它还能遵循特定的编码规范，让 Junie 更好地与你的工作方式保持一致。这不仅提升了代码质量，也让 Junie 在执行任务时更可靠，成为你团队中值得信赖的协作伙伴。
\ No newline at end of file
diff --git a/docs/md/AI/langchain4j/customizable-http-client.md b/docs/md/AI/langchain4j/customizable-http-client.md
new file mode 100644
index 000000000..59e2bb221
--- /dev/null
+++ b/docs/md/AI/langchain4j/customizable-http-client.md
@@ -0,0 +1,54 @@
+# HTTP 客户端
+
+>LangChain4j HTTP 客户端定制：解锁 LLM API 交互的更多可能性
+
+## 0 前言
+
+一些 LangChain4j 模块（目前是 OpenAI 和 Ollama）支持自定义用于调用 LLM 提供程序 API 的 HTTP 客户端。
+
+`langchain4j-http-client` 模块实现了一个 `HttpClient` SPI，这些模块用它来调用 LLM 提供程序的 REST API。即底层 HTTP 客户端可自定义，并通过实现 `HttpClient` SPI 来集成任何其他 HTTP 客户端。
+
+## 1 实现方案
+
+目前，有两种开箱即用的实现：
+
+### 1.1 JdkHttpClient
+
+`langchain4j-http-client-jdk` 模块中的 `JdkHttpClient` 。当使用受支持的模块（如 `langchain4j-open-ai` ）时，默认使用它。
+
+### 1.2 SpringRestClient
+
+`langchain4j-http-client-spring-restclient` 中的 `SpringRestClient` 。当使用受支持的模块的 Spring Boot 启动器（例如 `langchain4j-open-ai-spring-boot-starter` ）时，默认使用它。
+
+## 2 自定义JDK的HttpClient
+
+```java
+HttpClient.Builder httpClientBuilder = HttpClient.newBuilder()
+        .sslContext(...);
+
+JdkHttpClientBuilder jdkHttpClientBuilder = JdkHttpClient.builder()
+        .httpClientBuilder(httpClientBuilder);
+
+OpenAiChatModel model = OpenAiChatModel.builder()
+        .httpClientBuilder(jdkHttpClientBuilder)
+        .apiKey(System.getenv("OPENAI_API_KEY"))
+        .modelName("gpt-4o-mini")
+        .build();
+```
+
+## 3 定制 Spring 的RestClient
+
+```java
+RestClient.Builder restClientBuilder = RestClient.builder()
+        .requestFactory(new HttpComponentsClientHttpRequestFactory());
+
+SpringRestClientBuilder springRestClientBuilder = SpringRestClient.builder()
+        .restClientBuilder(restClientBuilder)
+        .streamingRequestExecutor(new VirtualThreadTaskExecutor());
+
+OpenAiChatModel model = OpenAiChatModel.builder()
+        .httpClientBuilder(springRestClientBuilder)
+        .apiKey(System.getenv("OPENAI_API_KEY"))
+        .modelName("gpt-4o-mini")
+        .build();
+```
\ No newline at end of file
diff --git a/docs/md/AI/langchain4j/mcp.md b/docs/md/AI/langchain4j/mcp.md
new file mode 100644
index 000000000..c102195d1
--- /dev/null
+++ b/docs/md/AI/langchain4j/mcp.md
@@ -0,0 +1,244 @@
+# LangChain4j + MCP：让你的 AI 轻松调用外部工具（内附GitHub-MCP实战）
+
+## 0 前言
+
+LangChain4j 支持模型上下文协议（MCP），用于与符合 MCP 标准的服务器通信，从而调用并执行工具。
+
+该协议支持两种通信方式，LangChain4j 均已支持：
+
+- HTTP 模式：客户端通过 SSE 通道接收服务端事件，并通过 HTTP POST 请求发指令
+- stdio 模式：客户端可将 MCP 服务器作为本地子进程运行，并通过标准输入/输出与其通信
+
+想让聊天模型或 AI 服务使用 MCP 服务器提供的工具，先得创建一个 MCP 工具提供者实例。
+
+## 1 创建 MCP 工具提供者（MCP tool provider）
+
+### 1.1 MCP通信方式
+
+先要构建一个 MCP 通信方式的实例。
+
+#### ① stdio
+
+以本地启动 NPM 包为例：
+
+```java
+McpTransport transport = new StdioMcpTransport.Builder()
+    .command(List.of("/usr/bin/npm", "exec", "@modelcontextprotocol/server-everything@0.6.2"))
+    .logEvents(true) // 开启日志记录（可选）
+    .build();
+```
+
+#### ② HTTP
+
+需要两个 URL：
+
+- 一个用于启动 SSE channel
+- 另一个用于通过 POST 提交命令：
+
+```java
+McpTransport transport = new HttpMcpTransport.Builder()
+    .sseUrl("http://localhost:3001/sse") // SSE 事件channel地址
+    .logRequests(true) // 开启请求日志
+    .logResponses(true) // 开启响应日志
+    .build();
+```
+
+### 1.2 创建 MCP 客户端
+
+代表可以通过给定的传输协议，使用服务器检索和执行工具的客户端，该客户端可以与MCP服务器通信。
+
+使用 transport 实例创建 MCP 客户端：
+
+```java
+McpClient mcpClient = new DefaultMcpClient.Builder()
+    .transport(transport)
+    .build();
+```
+
+### 1.3 创建 MCP 工具提供者
+
+工具提供者。每次调用AI服务并为该特定调用提供工具时，都会调用它。 toolproviderresult中返回的工具将包含在对LLM的请求中。
+
+使用 MCP 客户端创建工具提供者：
+
+```java
+ToolProvider toolProvider = McpToolProvider.builder()
+    .mcpClients(List.of(mcpClient))
+    .build();
+```
+
+一个 MCP 工具提供者可同时用多个 MCP 客户端。如需自定义在连接某个服务器失败时行为，可 `builder.failIfOneServerFails(boolean)` 设置：
+
+- 默认 `false`：忽略单个服务器失败，继续使用其他服务器
+- 若置 `true`：任一服务器失败都会导致整个工具提供者抛异常
+
+将工具提供者绑定到 AI 服务中，只需在构建 AI 服务时传入：
+
+```java
+Bot bot = AiServices.builder(Bot.class)
+    .chatModel(model)
+    .toolProvider(toolProvider)
+    .build();
+```
+
+## 2 日志功能
+
+MCP 协议支持服务端向客户端发送日志消息。默认，客户端会将这些日志转为 SLF4J 格式输出。如想自定义日志处理逻辑，可实现 `dev.langchain4j.mcp.client.logging.McpLogMessageHandler` 接口，并传入客户端构造器：
+
+```java
+McpClient mcpClient = new DefaultMcpClient.Builder()
+    .transport(transport)
+    .logMessageHandler(new MyLogMessageHandler()) // 自定义日志处理器
+    .build();
+```
+
+## 3 资源操作
+
+获取服务器上的 [MCP 资源](http://www.javaedge.cn/md/AI/mcp/resources.html)，使用：
+
+- client.listResources()：返回 `McpResource` 列表，包含资源元数据及 URI
+- client.listResourceTemplates()：获取资源模板
+
+获取资源具体内容时，用client.readResource(uri)，传入资源 URI，返回 `McpReadResourceResult`，其中包含一个或多个 `McpResourceContents`：
+
+- `McpBlobResourceContents`：二进制资源
+- `McpTextResourceContents`：文本资源
+
+## 4 提示词操作（Prompts）
+
+获取服务器上定义的[MCP 提示词](https://modelcontextprotocol.io/docs/concepts/prompts)，用：
+
+- `client.listPrompts()`：返回提示词 `McpPrompt` 列表，包含名称和参数信息
+- `client.getPrompt(name, arguments)`：渲染具体提示词内容，返回一组 `McpPromptMessage`，包含角色（如 `user`、`assistant`）和消息内容
+
+当前支持的消息内容类型包括：
+
+- `McpTextContent`：文本
+- `McpImageContent`：图像
+- `McpEmbeddedResource`：嵌入资源
+
+提示词消息可用 `McpPromptMessage.toChatMessage()` 转为通用的 LangChain4j 消息类型 `ChatMessage`，但需满足：
+
+- `role` 为 `assistant` 时，内容须是文本，否则会抛异常
+- 包含二进制内容的消息无法转换
+
+## 5 使用 Docker 运行 GitHub MCP 服务器
+
+看一个通过 MCP 协议连接 GitHub 的示例。目标是用 LangChain4j 和 MCP 客户端获取并总结 GitHub 上公开仓库的最新提交信息。
+
+通过 MCP 提供的 GitHub 服务器实现（见 [MCP GitHub 仓库](https://github.com/github/github-mcp-server)），通过 Docker 本地运行。
+
+### 构建 Docker 镜像
+
+先克隆或下载 MCP GitHub 服务器源码，进入根目录，执行以下命令构建镜像：
+
+```bash
+docker build -t mcp/github -f Dockerfile .
+```
+
+构建完成后，本地会生成 `mcp/github` 镜像：
+
+```bash
+docker image ls
+
+REPOSITORY   TAG         IMAGE ID        SIZE
+mcp/github   latest      b141704170b1    173MB
+```
+
+## 6 开发工具提供者代码示例
+
+创建 Java 类 `McpGithubToolsExample`，使用 LangChain4j 连接 GitHub MCP 服务器，执行以下操作：
+
+- 启动 Docker 容器运行 GitHub MCP 服务器
+- 使用 stdio 通信方式连接 MCP 服务器
+- 使用语言模型总结 LangChain4j 仓库最近 3 次提交信息
+
+> ⚠️ 提示：下面代码中通过环境变量 `GITHUB_PERSONAL_ACCESS_TOKEN` 传入 GitHub Token，访问公共仓库时可选。
+
+### 获取GITHUB_PERSONAL_ACCESS_TOKEN
+
+直达：https://github.com/settings/personal-access-tokens/new：
+
+![](https://p.ipic.vip/1qknlc.png)
+
+自己保存好：
+
+![](https://p.ipic.vip/ir198y.png)
+
+构建好的镜像：
+
+![](https://p.ipic.vip/m7cgzz.png)
+
+
+```bash
+docker run --rm -d \
+  --name mcp-github-server \
+  -e GITHUB_PERSONAL_ACCESS_TOKEN=token \
+  mcp/github
+```
+
+启动成功：
+
+![](https://p.ipic.vip/isdabp.png)
+
+```java
+public static void main(String[] args) throws Exception {
+
+    ChatLanguageModel model = OllamaChatModel.builder()
+        .baseUrl("http://localhost:11434") // Ollama 默认本地服务地址
+        .modelName("llama3-groq-tool-use:8b") // 你本地 Ollama 拉取的模型名称
+        .logRequests(true)
+        .logResponses(true)
+        .build();
+
+    McpTransport transport = new StdioMcpTransport.Builder()
+        .command(List.of("/usr/local/bin/docker", "run", "-e", "GITHUB_PERSONAL_ACCESS_TOKEN", "-i", "mcp/github"))
+        .logEvents(true)
+        .build();
+
+    McpClient mcpClient = new DefaultMcpClient.Builder()
+        .transport(transport)
+        .build();
+
+    ToolProvider toolProvider = McpToolProvider.builder()
+        .mcpClients(List.of(mcpClient))
+        .build();
+
+    Bot bot = AiServices.builder(Bot.class)
+        .chatModel(model)
+        .toolProvider(toolProvider)
+        .build();
+
+    try {
+        String response = bot.chat("Summarize the last 3 commits of the LangChain4j GitHub repository");
+        System.out.println("RESPONSE: " + response);
+    } finally {
+        mcpClient.close();
+    }
+}
+```
+
+## 7 执行示例代码
+
+运行 Java 应用后，收到类似输出，总结 LangChain4j 仓库最近 3 次提交内容：
+
+```
+以下是 LangChain4j GitHub 仓库最近三次提交的摘要：
+
+1. **提交 [36951f9](https://github.com/langchain4j/langchain4j/commit/36951f9649c1beacd8b9fc2d910a2e23223e0d93)**（时间：2025-02-05）
+   - **作者：** Dmytro Liubarskyi
+   - **信息：** 更新至 `upload-pages-artifact@v3`
+   - **详情：** 此提交将上传页面资源的 GitHub Action 升级至版本 3。
+
+2. **提交 [6fcd19f](https://github.com/langchain4j/langchain4j/commit/6fcd19f50c8393729a0878d6125b0bb1967ac055)**（时间：2025-02-05）
+   - **作者：** Dmytro Liubarskyi
+   - **信息：** 更新至 `checkout@v4`、`deploy-pages@v4` 和 `upload-pages-artifact@v4`
+   - **详情：** 此提交升级了多个 GitHub Action 到版本 4。
+
+3. **提交 [2e74049](https://github.com/langchain4j/langchain4j/commit/2e740495d2aa0f16ef1c05cfcc76f91aef6f6599)**（时间：2025-02-05）
+   - **作者：** Dmytro Liubarskyi
+   - **信息：** 更新至 `setup-node@v4` 和 `configure-pages@v4`
+   - **详情：** 此提交将相关 GitHub Action 升级至版本 4。
+
+这三次提交都由 Dmytro Liubarskyi 完成，时间相同，主要内容为将 GitHub Actions 升级至新版。
+```
\ No newline at end of file
diff --git a/docs/md/AI/langchain4j/structured-outputs.md b/docs/md/AI/langchain4j/structured-outputs.md
new file mode 100644
index 000000000..3e541a2a1
--- /dev/null
+++ b/docs/md/AI/langchain4j/structured-outputs.md
@@ -0,0 +1,646 @@
+# 结构化输出
+
+## 0 前言
+
+“结构化输出”含义广，可指两件事：
+
+- LLM 以结构化格式生成输出的一般能力（本文内容）
+- OpenAI 的[结构化输出](https://platform.openai.com/docs/guides/structured-outputs)功能，适用于响应格式和工具（函数调用）
+
+许多 LLM 和 LLM provider支持生成结构化格式（通常是JSON）的输出。这些输出可轻松映射到 Java 对象，并用于应用程序的其他部分。
+
+如有个 `Person` 类：
+
+```java
+record Person(String name, int age, double height, boolean married) {
+}
+```
+
+目标：从非结构化文本中提取一个 `Person` 对象，如：
+
+```text
+John is 42 years old and lives an independent life.
+He stands 1.75 meters tall and carries himself with confidence.
+Currently unmarried, he enjoys the freedom to focus on his personal goals and interests.
+```
+
+目前，根据 LLM 和 LLM provider的不同，有如下三种方法实现此目标（从最可靠到最不可靠）：
+
+## 1 JSON Schema JSON 模式
+
+一些 LLM 提供商（目前包括 Azure OpenAI、Google AI Gemini、Mistral、Ollama 和 OpenAI）允许为所需输出指定 [JSON 模式 ](https://json-schema.org/overview/what-is-jsonschema)。可在[此处的 ](https://docs.langchain4j.dev/integrations/language-models)“JSON 模式”列中查看所有受支持的 LLM 提供商。
+
+当请求中指定 JSON 模式时，LLM 预计会生成符合该模式的输出。
+
+> JSON 模式是在对 LLM 提供商 API 的请求中的专用属性中指定的，不需要在prompt中包含任何自由格式的指令（如在系统或用户消息中）。
+
+LangChain4j 在低级 `ChatLanguageModel` API 和高级 AI Service API 中都支持 JSON Schema 功能。
+
+### 1.1 使用 JSON Schema 和 ChatLanguageModel
+
+在低级 `ChatLanguageModel` API 中，可以在创建 `ChatRequest` 时使用 LLM-provider-agnostic `ResponseFormat` 和 `JsonSchema` 指定 JSON 模式：
+
+```java
+ResponseFormat responseFormat = ResponseFormat.builder()
+        .type(JSON) // type can be either TEXT (default) or JSON
+        .jsonSchema(JsonSchema.builder()
+                .name("Person") // OpenAI requires specifying the name for the schema
+                .rootElement(JsonObjectSchema.builder() // see [1] below
+                        .addStringProperty("name")
+                        .addIntegerProperty("age")
+                        .addNumberProperty("height")
+                        .addBooleanProperty("married")
+                        .required("name", "age", "height", "married") // see [2] below
+                        .build())
+                .build())
+        .build();
+
+UserMessage userMessage = UserMessage.from("""
+        John is 42 years old and lives an independent life.
+        He stands 1.75 meters tall and carries himself with confidence.
+        Currently unmarried, he enjoys the freedom to focus on his personal goals and interests.
+        """);
+
+ChatRequest chatRequest = ChatRequest.builder()
+        .responseFormat(responseFormat)
+        .messages(userMessage)
+        .build();
+
+ChatLanguageModel chatModel = OpenAiChatModel.builder()
+        .apiKey(System.getenv("OPENAI_API_KEY"))
+        .modelName("gpt-4o-mini")
+        .logRequests(true)
+        .logResponses(true)
+        .build();
+// OR
+ChatLanguageModel chatModel = AzureOpenAiChatModel.builder()
+        .endpoint(System.getenv("AZURE_OPENAI_URL"))
+        .apiKey(System.getenv("AZURE_OPENAI_API_KEY"))
+        .deploymentName("gpt-4o-mini")
+        .logRequestsAndResponses(true)
+        .build();
+// OR
+ChatLanguageModel chatModel = GoogleAiGeminiChatModel.builder()
+        .apiKey(System.getenv("GOOGLE_AI_GEMINI_API_KEY"))
+        .modelName("gemini-1.5-flash")
+        .logRequestsAndResponses(true)
+        .build();
+// OR
+ChatLanguageModel chatModel = OllamaChatModel.builder()
+        .baseUrl("http://localhost:11434")
+        .modelName("llama3.1")
+        .logRequests(true)
+        .logResponses(true)
+        .build();
+// OR
+ChatLanguageModel chatModel = MistralAiChatModel.builder()
+        .apiKey(System.getenv("MISTRAL_AI_API_KEY"))
+        .modelName("mistral-small-latest")
+        .logRequests(true)
+        .logResponses(true)
+        .build();
+
+ChatResponse chatResponse = chatModel.chat(chatRequest);
+
+String output = chatResponse.aiMessage().text();
+System.out.println(output); // {"name":"John","age":42,"height":1.75,"married":false}
+
+Person person = new ObjectMapper().readValue(output, Person.class);
+System.out.println(person); // Person[name=John, age=42, height=1.75, married=false]
+```
+
+大多情况下，根元素必须是 `JsonObjectSchema` 类型，但 Gemini 也允许 `JsonEnumSchema` 和 `JsonArraySchema` 。
+
+必须明确指定必需属性；否则，它们将被视为可选。JSON 模式的结构使用 `JsonSchemaElement` 接口定义，具有以下子类型：
+
+- `JsonObjectSchema` - for object types.
+- `JsonStringSchema` - for `String`, `char`/`Character` types.
+- `JsonIntegerSchema` - for `int`/`Integer`, `long`/`Long`, `BigInteger` types.
+- `JsonNumberSchema` - for `float`/`Float`, `double`/`Double`, `BigDecimal` types.
+- `JsonBooleanSchema` - for `boolean`/`Boolean` types.
+- `JsonEnumSchema` - for `enum` types.
+- `JsonArraySchema` - for arrays and collections (e.g., `List`, `Set`).
+- `JsonReferenceSchema` - to support recursion (e.g., `Person` has a `Set<Person> children` field).
+- `JsonAnyOfSchema` - to support polymorphism (e.g., `Shape` can be either `Circle` or `Rectangle`).
+- `JsonNullSchema` - to support nullable type.
+
+#### JsonObjectSchema
+
+`JsonObjectSchema` 表示具有嵌套属性的对象。它通常是 `JsonSchema` 的根元素。
+
+有几种方法可向 `JsonObjectSchema` 添加属性：
+
+可用 `properties(Map<String, JsonSchemaElement> properties)` 一次性添加所有属性：
+
+```java
+JsonSchemaElement citySchema = JsonStringSchema.builder()
+        .description("The city for which the weather forecast should be returned")
+        .build();
+
+JsonSchemaElement temperatureUnitSchema = JsonEnumSchema.builder()
+        .enumValues("CELSIUS", "FAHRENHEIT")
+        .build();
+
+Map<String, JsonSchemaElement> properties = Map.of(
+        "city", citySchema,
+        "temperatureUnit", temperatureUnitSchema
+);
+
+JsonSchemaElement rootElement = JsonObjectSchema.builder()
+        .addProperties(properties)
+        .required("city") // required properties should be specified explicitly
+        .build();
+```
+
+可用 `addProperty(String name, JsonSchemaElement jsonSchemaElement)` 单独添加属性：
+
+```java
+JsonSchemaElement rootElement = JsonObjectSchema.builder()
+        .addProperty("city", citySchema)
+        .addProperty("temperatureUnit", temperatureUnitSchema)
+        .required("city")
+        .build();
+```
+
+可用 `add{Type}Property(String name)` 或 `add{Type}Property(String name, String description)` 方法之一单独添加属性：
+
+```java
+JsonSchemaElement rootElement = JsonObjectSchema.builder()
+        .addStringProperty("city", "The city for which the weather forecast should be returned")
+        .addEnumProperty("temperatureUnit", List.of("CELSIUS", "FAHRENHEIT"))
+        .required("city")
+        .build();
+```
+
+参阅 [JsonObjectSchema](https://github.com/langchain4j/langchain4j/blob/main/langchain4j-core/src/main/java/dev/langchain4j/model/chat/request/json/JsonObjectSchema.java) 了解更多详情。
+
+#### JsonStringSchema
+
+An example of creating `JsonStringSchema`:
+创建 `JsonStringSchema` 的示例：
+
+```java
+JsonSchemaElement stringSchema = JsonStringSchema.builder()
+        .description("The name of the person")
+        .build();
+```
+
+
+
+#### `JsonIntegerSchema`[](https://docs.langchain4j.dev/tutorials/structured-outputs#jsonintegerschema)
+
+An example of creating `JsonIntegerSchema`:
+创建 `JsonIntegerSchema` 的示例：
+
+```java
+JsonSchemaElement integerSchema = JsonIntegerSchema.builder()
+        .description("The age of the person")
+        .build();
+```
+
+
+
+#### `JsonNumberSchema`[](https://docs.langchain4j.dev/tutorials/structured-outputs#jsonnumberschema)
+
+An example of creating `JsonNumberSchema`:
+创建 `JsonNumberSchema` 的示例：
+
+```java
+JsonSchemaElement numberSchema = JsonNumberSchema.builder()
+        .description("The height of the person")
+        .build();
+```
+
+
+
+#### `JsonBooleanSchema`[](https://docs.langchain4j.dev/tutorials/structured-outputs#jsonbooleanschema)
+
+An example of creating `JsonBooleanSchema`:
+创建 `JsonBooleanSchema` 的示例：
+
+```java
+JsonSchemaElement booleanSchema = JsonBooleanSchema.builder()
+        .description("Is the person married?")
+        .build();
+```
+
+
+
+#### `JsonEnumSchema`[](https://docs.langchain4j.dev/tutorials/structured-outputs#jsonenumschema)
+
+An example of creating `JsonEnumSchema`:
+创建 `JsonEnumSchema` 的示例：
+
+```java
+JsonSchemaElement enumSchema = JsonEnumSchema.builder()
+        .description("Marital status of the person")
+        .enumValues(List.of("SINGLE", "MARRIED", "DIVORCED"))
+        .build();
+```
+
+
+
+#### `JsonArraySchema`[](https://docs.langchain4j.dev/tutorials/structured-outputs#jsonarrayschema)
+
+An example of creating `JsonArraySchema` to define an array of strings:
+创建 `JsonArraySchema` 来定义字符串数组的示例：
+
+```java
+JsonSchemaElement itemSchema = JsonStringSchema.builder()
+        .description("The name of the person")
+        .build();
+
+JsonSchemaElement arraySchema = JsonArraySchema.builder()
+        .description("All names of the people found in the text")
+        .items(itemSchema)
+        .build();
+```
+
+
+
+#### `JsonReferenceSchema`[](https://docs.langchain4j.dev/tutorials/structured-outputs#jsonreferenceschema)
+
+The `JsonReferenceSchema` can be used to support recursion:
+`JsonReferenceSchema` 可用于支持递归：
+
+```java
+String reference = "person"; // reference should be unique withing the schema
+
+JsonObjectSchema jsonObjectSchema = JsonObjectSchema.builder()
+        .addStringProperty("name")
+        .addProperty("children", JsonArraySchema.builder()
+                .items(JsonReferenceSchema.builder()
+                        .reference(reference)
+                        .build())
+                .build())
+        .required("name", "children")
+        .definitions(Map.of(reference, JsonObjectSchema.builder()
+                .addStringProperty("name")
+                .addProperty("children", JsonArraySchema.builder()
+                        .items(JsonReferenceSchema.builder()
+                                .reference(reference)
+                                .build())
+                        .build())
+                .required("name", "children")
+                .build()))
+        .build();
+```
+
+
+
+note 笔记
+
+The `JsonReferenceSchema` is currently supported only by Azure OpenAI, Mistral and OpenAI.
+`JsonReferenceSchema` 目前仅受 Azure OpenAI、Mistral 和 OpenAI 支持。
+
+#### `JsonAnyOfSchema`[](https://docs.langchain4j.dev/tutorials/structured-outputs#jsonanyofschema)
+
+The `JsonAnyOfSchema` can be used to support polymorphism:
+`JsonAnyOfSchema` 可用于支持多态性：
+
+```java
+JsonSchemaElement circleSchema = JsonObjectSchema.builder()
+        .addNumberProperty("radius")
+        .build();
+
+JsonSchemaElement rectangleSchema = JsonObjectSchema.builder()
+        .addNumberProperty("width")
+        .addNumberProperty("height")
+        .build();
+
+JsonSchemaElement shapeSchema = JsonAnyOfSchema.builder()
+        .anyOf(circleSchema, rectangleSchema)
+        .build();
+
+JsonSchema jsonSchema = JsonSchema.builder()
+        .name("Shapes")
+        .rootElement(JsonObjectSchema.builder()
+                .addProperty("shapes", JsonArraySchema.builder()
+                        .items(shapeSchema)
+                        .build())
+                .required(List.of("shapes"))
+                .build())
+        .build();
+
+ResponseFormat responseFormat = ResponseFormat.builder()
+        .type(ResponseFormatType.JSON)
+        .jsonSchema(jsonSchema)
+        .build();
+
+UserMessage userMessage = UserMessage.from("""
+        Extract information from the following text:
+        1. A circle with a radius of 5
+        2. A rectangle with a width of 10 and a height of 20
+        """);
+
+ChatRequest chatRequest = ChatRequest.builder()
+        .messages(userMessage)
+        .responseFormat(responseFormat)
+        .build();
+
+ChatResponse chatResponse = model.chat(chatRequest);
+
+System.out.println(chatResponse.aiMessage().text()); // {"shapes":[{"radius":5},{"width":10,"height":20}]}
+```
+
+
+
+note 笔记
+
+The `JsonAnyOfSchema` is currently supported only by OpenAI and Azure OpenAI.
+`JsonAnyOfSchema` 目前仅受 OpenAI 和 Azure OpenAI 支持。
+
+#### Adding Description 添加描述[](https://docs.langchain4j.dev/tutorials/structured-outputs#adding-description)
+
+All of the `JsonSchemaElement` subtypes, except for `JsonReferenceSchema`, have a `description` property. If an LLM does not provide the desired output, descriptions can be provided to give more instructions and examples of correct outputs to the LLM, for example:
+除了 `JsonReferenceSchema` 之外，所有 `JsonSchemaElement` 子类型都具有 `description` 属性。如果 LLM 未提供所需的输出，则可以提供 description 属性，以便为 LLM 提供更多说明和正确输出的示例，例如：
+
+```java
+JsonSchemaElement stringSchema = JsonStringSchema.builder()
+        .description("The name of the person, for example: John Doe")
+        .build();
+```
+
+
+
+#### Limitations 限制[](https://docs.langchain4j.dev/tutorials/structured-outputs#limitations)
+
+When using JSON Schema with `ChatLanguageModel`, there are some limitations:
+当使用 JSON Schema 与 `ChatLanguageModel` 时，存在一些限制：
+
+- It works only with supported Azure OpenAI, Google AI Gemini, Mistral, Ollama and OpenAI models.
+  它仅适用于受支持的 Azure OpenAI、Google AI Gemini、Mistral、Ollama 和 OpenAI 模型。
+- It does not work in the [streaming mode](https://docs.langchain4j.dev/tutorials/ai-services#streaming) for OpenAI yet. For Google AI Gemini, Mistral and Ollama, JSON Schema can be specified via `responseSchema(...)` when creating/building the model.
+  它目前还不支持 OpenAI 的[流式传输模式 ](https://docs.langchain4j.dev/tutorials/ai-services#streaming)。对于 Google AI Gemini、Mistral 和 Ollama，可以在创建/构建模型时通过 `responseSchema(...)` 指定 JSON Schema。
+- `JsonReferenceSchema` and `JsonAnyOfSchema` are currently supported only by Azure OpenAI, Mistral and OpenAI.
+  `JsonReferenceSchema` 和 `JsonAnyOfSchema` 目前仅受 Azure OpenAI、Mistral 和 OpenAI 支持。
+
+### 1.2 将 JSON 模式与 AI 服务结合使用
+
+使用 [AI 服务](https://docs.langchain4j.dev/tutorials/ai-services)时，可以更轻松地实现相同的功能，并用更少代码：
+
+```java
+interface PersonExtractor {
+    
+    Person extractPersonFrom(String text);
+}
+
+ChatLanguageModel chatModel = OpenAiChatModel.builder() // see [1] below
+        .apiKey(System.getenv("OPENAI_API_KEY"))
+        .modelName("gpt-4o-mini")
+        .supportedCapabilities(Set.of(RESPONSE_FORMAT_JSON_SCHEMA)) // see [2] below
+        .strictJsonSchema(true) // see [2] below
+        .logRequests(true)
+        .logResponses(true)
+        .build();
+// OR
+ChatLanguageModel chatModel = AzureOpenAiChatModel.builder() // see [1] below
+        .endpoint(System.getenv("AZURE_OPENAI_URL"))
+        .apiKey(System.getenv("AZURE_OPENAI_API_KEY"))
+        .deploymentName("gpt-4o-mini")
+        .strictJsonSchema(true)
+        .supportedCapabilities(Set.of(RESPONSE_FORMAT_JSON_SCHEMA)) // see [3] below
+        .logRequestsAndResponses(true)
+        .build();
+// OR
+ChatLanguageModel chatModel = GoogleAiGeminiChatModel.builder() // see [1] below
+        .apiKey(System.getenv("GOOGLE_AI_GEMINI_API_KEY"))
+        .modelName("gemini-1.5-flash")
+        .responseFormat(ResponseFormat.JSON) // see [4] below
+        .logRequestsAndResponses(true)
+        .build();
+// OR
+ChatLanguageModel chatModel = OllamaChatModel.builder() // see [1] below
+        .baseUrl("http://localhost:11434")
+        .modelName("llama3.1")
+        .supportedCapabilities(RESPONSE_FORMAT_JSON_SCHEMA) // see [5] below
+        .logRequests(true)
+        .logResponses(true)
+        .build();
+// OR
+ChatLanguageModel chatModel = MistralAiChatModel.builder()
+         .apiKey(System.getenv("MISTRAL_AI_API_KEY"))
+         .modelName("mistral-small-latest")
+         .supportedCapabilities(RESPONSE_FORMAT_JSON_SCHEMA) // see [6] below
+         .logRequests(true)
+         .logResponses(true)
+         .build();
+
+PersonExtractor personExtractor = AiServices.create(PersonExtractor.class, chatModel); // see [1] below
+
+String text = """
+        John is 42 years old and lives an independent life.
+        He stands 1.75 meters tall and carries himself with confidence.
+        Currently unmarried, he enjoys the freedom to focus on his personal goals and interests.
+        """;
+
+Person person = personExtractor.extractPersonFrom(text);
+
+System.out.println(person); // Person[name=John, age=42, height=1.75, married=false]
+```
+
+- [1] - In a Quarkus or a Spring Boot application, there is no need to explicitly create the `ChatLanguageModel` and the AI Service, as these beans are created automatically. More info on this: [for Quarkus](https://docs.quarkiverse.io/quarkus-langchain4j/dev/ai-services.html), [for Spring Boot](https://docs.langchain4j.dev/tutorials/spring-boot-integration#spring-boot-starter-for-declarative-ai-services).
+  [1] - 在 Quarkus 或 Spring Boot 应用程序中，无需显式创建 `ChatLanguageModel` 和 AI 服务， 因为这些 bean 是自动创建的。更多信息请见： [对于 Quarkus 来说 ](https://docs.quarkiverse.io/quarkus-langchain4j/dev/ai-services.html)， [适用于 Spring Boot](https://docs.langchain4j.dev/tutorials/spring-boot-integration#spring-boot-starter-for-declarative-ai-services) 。
+- [2] - This is required to enable the JSON Schema feature for OpenAI, see more details [here](https://docs.langchain4j.dev/integrations/language-models/open-ai#structured-outputs-for-response-format).
+  [2] - 这是为 OpenAI 启用 JSON Schema 功能所必需的，请[在此处](https://docs.langchain4j.dev/integrations/language-models/open-ai#structured-outputs-for-response-format)查看更多详细信息。
+- [3] - This is required to enable the JSON Schema feature for [Azure OpenAI](https://docs.langchain4j.dev/integrations/language-models/azure-open-ai).
+  [3] - 这是为 [Azure OpenAI](https://docs.langchain4j.dev/integrations/language-models/azure-open-ai) 启用 JSON 架构功能所必需的。
+- [4] - This is required to enable the JSON Schema feature for [Google AI Gemini](https://docs.langchain4j.dev/integrations/language-models/google-ai-gemini).
+  [4] - 这是启用 [Google AI Gemini](https://docs.langchain4j.dev/integrations/language-models/google-ai-gemini) 的 JSON Schema 功能所必需的。
+- [5] - This is required to enable the JSON Schema feature for [Ollama](https://docs.langchain4j.dev/integrations/language-models/ollama).
+  [5] - 这对于启用 [Ollama](https://docs.langchain4j.dev/integrations/language-models/ollama) 的 JSON Schema 功能是必需的。
+- [6] - This is required to enable the JSON Schema feature for [Mistral](https://docs.langchain4j.dev/integrations/language-models/mistral-ai).
+  [6] - 这对于启用 [Mistral 的 ](https://docs.langchain4j.dev/integrations/language-models/mistral-ai)JSON Schema 功能是必需的。
+
+When all the following conditions are met:
+当满足以下所有条件时：
+
+- AI Service method returns a POJO
+  AI 服务方法返回一个 POJO
+- The used `ChatLanguageModel` [supports](https://docs.langchain4j.dev/integrations/language-models/) the JSON Schema feature
+  使用的 `ChatLanguageModel`[ 支持 ](https://docs.langchain4j.dev/integrations/language-models/)JSON Schema 功能
+- The JSON Schema feature is enabled on the used `ChatLanguageModel`
+  在所使用的 `ChatLanguageModel` 上启用了 JSON Schema 功能
+
+then the `ResponseFormat` with `JsonSchema` will be generated automatically based on the specified return type.
+然后将根据指定的返回类型自动生成具有 `JsonSchema` 的 `ResponseFormat` 。
+
+note 笔记
+
+Make sure to explicitly enable JSON Schema feature when configuring `ChatLanguageModel`, as it is disabled by default.
+确保在配置 `ChatLanguageModel` 时明确启用 JSON Schema 功能，因为默认情况下该功能是禁用的。
+
+The `name` of the generated `JsonSchema` is a simple name of the return type (`getClass().getSimpleName()`), in this case: "Person".
+生成的 `JsonSchema` 的 `name` 是返回类型的简单名称（ `getClass().getSimpleName()` ），在本例中为：“Person”。
+
+Once LLM responds, the output is parsed into an object and returned from the AI Service method.
+一旦 LLM 响应，输出就会被解析为一个对象并从 AI 服务方法返回。
+
+You can find many examples of supported use cases [here](https://github.com/langchain4j/langchain4j/blob/main/langchain4j/src/test/java/dev/langchain4j/service/AiServicesWithJsonSchemaIT.java) and [here](https://github.com/langchain4j/langchain4j/blob/main/langchain4j/src/test/java/dev/langchain4j/service/AiServicesWithJsonSchemaWithDescriptionsIT.java).
+您可以找到许多受支持的用例示例 [这里](https://github.com/langchain4j/langchain4j/blob/main/langchain4j/src/test/java/dev/langchain4j/service/AiServicesWithJsonSchemaIT.java) 还有[这里 ](https://github.com/langchain4j/langchain4j/blob/main/langchain4j/src/test/java/dev/langchain4j/service/AiServicesWithJsonSchemaWithDescriptionsIT.java)。
+
+#### Required and Optional 必需和可选[](https://docs.langchain4j.dev/tutorials/structured-outputs#required-and-optional)
+
+By default, all fields and sub-fields in the generated `JsonSchema` are considered ***optional\***. This is because LLMs tend to hallucinate and populate fields with synthetic data when they lack sufficient information (e.g., using "John Doe" when then name is missing)".
+默认情况下，生成的 `JsonSchema` 中的所有字段和子字段都被视为***可选的\*** 。这是因为 LLM 在缺乏足够信息时，往往会产生幻觉，用合成数据填充字段（例如，在缺少姓名的情况下使用“John Doe”）。
+
+note 笔记
+
+Please note that optional fields with primitive types (e.g., `int`, `boolean`, etc.) will be initialized with default values (e.g., `0` for `int`, `false` for `boolean`, etc.) if the LLM does not provide a value for them.
+请注意，如果 LLM 没有为原始类型（例如， `int` 、 `boolean` 等）的可选字段提供值，则将使用默认值进行初始化（例如， `int` 为 `0` 、 `boolean` 为 `false` 等）。
+
+note 笔记
+
+Please note that optional `enum` fields can still be populated with hallucinated values when strict mode is on (`strictJsonSchema(true)`).
+请注意，当严格模式开启（ `strictJsonSchema(true)` ）时，可选 `enum` 字段仍然可以填充幻觉值。
+
+To make the field required, you can annotate it with `@JsonProperty(required = true)`:
+要使该字段成为必填字段，您可以使用 `@JsonProperty(required = true)` 对其进行注释：
+
+```java
+record Person(@JsonProperty(required = true) String name, String surname) {
+}
+
+interface PersonExtractor {
+    
+    Person extractPersonFrom(String text);
+}
+```
+
+
+
+note 笔记
+
+Please note that when used with [tools](https://docs.langchain4j.dev/tutorials/tools), all fields and sub-fields are considered ***required\*** by default.
+请注意，与[工具](https://docs.langchain4j.dev/tutorials/tools)一起使用时，所有字段和子字段默认***被视为必填\*** 。
+
+#### Adding Description 添加描述[](https://docs.langchain4j.dev/tutorials/structured-outputs#adding-description-1)
+
+If an LLM does not provide the desired output, classes and fields can be annotated with `@Description` to give more instructions and examples of correct outputs to the LLM, for example:
+如果 LLM 未提供所需的输出，则可以使用 `@Description` 注释类和字段 为 LLM 提供更多指导和正确输出的示例，例如：
+
+```java
+@Description("a person")
+record Person(@Description("person's first and last name, for example: John Doe") String name,
+              @Description("person's age, for example: 42") int age,
+              @Description("person's height in meters, for example: 1.78") double height,
+              @Description("is person married or not, for example: false") boolean married) {
+}
+```
+
+
+
+note 笔记
+
+Please note that `@Description` placed on an `enum` value has ***no effect\*** and ***is not\*** included in the generated JSON schema:
+请注意，放置在 `enum` 值上的 `@Description` ***没有任何效果\*** ，并且***不\***包含在生成的 JSON 模式中：
+
+```java
+enum Priority {
+
+    @Description("Critical issues such as payment gateway failures or security breaches.") // this is ignored
+    CRITICAL,
+    
+    @Description("High-priority issues like major feature malfunctions or widespread outages.") // this is ignored
+    HIGH,
+    
+    @Description("Low-priority issues such as minor bugs or cosmetic problems.") // this is ignored
+    LOW
+}
+```
+
+#### 限制
+
+在 AI 服务中使用 JSON Schema 时的限制：
+
+- 仅适用于受支持的 Azure OpenAI、Google AI Gemini、Mistral、Ollama 和 OpenAI 模型。
+
+- 配置 `ChatLanguageModel` 时需要明确启用对 JSON Schema 的支持
+
+- [流模式](https://docs.langchain4j.dev/tutorials/ai-services#streaming)下不​​起作用。
+
+- 并非所有类型都受支持。请参阅[此处的](https://docs.langchain4j.dev/tutorials/structured-outputs#supported-types)支持类型列表
+
+- POJO 可包含：
+
+  - Scalar/simple types (e.g., `String`, `int`/`Integer`, `double`/`Double`, `boolean`/`Boolean`, etc.)
+    标量/简单类型（例如 `String` 、 `int` / `Integer` 、 `double` / `Double` 、 `boolean` / `Boolean` 等）
+  - `enum`s `enum`
+  - Nested POJOs 嵌套 POJO
+  - `List<T>`, `Set<T>` and `T[]`, where `T` is a scalar, an `enum` or a POJO
+    `List<T>` 、 `Set<T>` 和 `T[]` ，其中 `T` 是标量、 `enum` 或 POJO
+
+- 目前只有 Azure OpenAI、Mistral 和 OpenAI 支持递归
+
+- 尚不支持多态。返回的 POJO 及其嵌套的 POJO 必须是具体类；不支持接口或抽象类。
+
+- 当 LLM 不支持 JSON Schema 功能、未启用该功能或​​不支持类型时，AI Service 将回退到[提示 ](https://docs.langchain4j.dev/tutorials/structured-outputs#prompting)
+
+## 2 Prompting + JSON Mode 提示符 + JSON 模式
+
+更多信息即将发布。先阅读[本节](https://docs.langchain4j.dev/tutorials/ai-services#json-mode) 和[这篇文章 ](https://glaforge.dev/posts/2024/11/18/data-extraction-the-many-ways-to-get-llms-to-spit-json-content/)。
+
+## 3 Prompting 提示
+
+使用prompting时（默认选择，除非启用对 JSON 模式支持），AI 服务将自动生成格式说明并将其附加到 `UserMessage` 末尾，指明LLM应采用的响应格式。 方法返回前，AI 服务会将 LLM 的输出解析为所需的类型。
+
+可通过[启用日志记录](https://docs.langchain4j.dev/tutorials/logging)来观察附加的说明。
+
+> 这种方法不太可靠。如果 LLM 课程和 LLM 提供商支持上述方法，最好使用这些方法。
+
+## 4 Supported Types 支持的类型
+
+| Type 类型                                                    | JSON Schema JSON 模式 | Prompting 提示 |
+| ------------------------------------------------------------ | --------------------- | -------------- |
+| `POJO`                                                       | ✅                     | ✅              |
+| `List<POJO>`, `Set<POJO>` `List<POJO>` ， `Set<POJO>`        | ✅                     | ❌              |
+| `Enum`                                                       | ✅                     | ✅              |
+| `List<Enum>`, `Set<Enum>` `List<Enum>` ， `Set<Enum>`        | ✅                     | ✅              |
+| `List<String>`, `Set<String>` `List<String>` ， `Set<String>` | ✅                     | ✅              |
+| `boolean`, `Boolean` `boolean` , `Boolean`                   | ✅                     | ✅              |
+| `int`, `Integer` `int` `Integer`                             | ✅                     | ✅              |
+| `long`, `Long` `long` ， `Long`                              | ✅                     | ✅              |
+| `float`, `Float` `float` ， `Float`                          | ✅                     | ✅              |
+| `double`, `Double` `double` ， `Double`                      | ✅                     | ✅              |
+| `byte`, `Byte` `byte` ， `Byte`                              | ❌                     | ✅              |
+| `short`, `Short` `short` ， `Short`                          | ❌                     | ✅              |
+| `BigInteger`                                                 | ❌                     | ✅              |
+| `BigDecimal`                                                 | ❌                     | ✅              |
+| `Date`                                                       | ❌                     | ✅              |
+| `LocalDate`                                                  | ❌                     | ✅              |
+| `LocalTime`                                                  | ❌                     | ✅              |
+| `LocalDateTime`                                              | ❌                     | ✅              |
+| `Map<?, ?>`                                                  | ❌                     | ✅              |
+
+A few examples: 举几个例子：
+
+```java
+record Person(String firstName, String lastName) {}
+
+enum Sentiment {
+    POSITIVE, NEGATIVE, NEUTRAL
+}
+
+interface Assistant {
+
+    Person extractPersonFrom(String text);
+
+    Set<Person> extractPeopleFrom(String text);
+
+    Sentiment extractSentimentFrom(String text);
+
+    List<Sentiment> extractSentimentsFrom(String text);
+
+    List<String> generateOutline(String topic);
+
+    boolean isSentimentPositive(String text);
+
+    Integer extractNumberOfPeopleMentionedIn(String text);
+}
+```
+
+## 5 相关教程
+
+- [Data extraction: The many ways to get LLMs to spit JSON content](https://glaforge.dev/posts/2024/11/18/data-extraction-the-many-ways-to-get-llms-to-spit-json-content/) by [Guillaume Laforge](https://glaforge.dev/about/)
+  [数据提取：让 LLM 输出 JSON 内容的多种方法，](https://glaforge.dev/posts/2024/11/18/data-extraction-the-many-ways-to-get-llms-to-spit-json-content/) 
+
diff --git a/docs/md/AI/llm/lmstudio-local-llm-call.md b/docs/md/AI/llm/lmstudio-local-llm-call.md
new file mode 100644
index 000000000..866630529
--- /dev/null
+++ b/docs/md/AI/llm/lmstudio-local-llm-call.md
@@ -0,0 +1,76 @@
+# Ollama平替！LM Studio本地大模型调用实战
+
+## 0 前言
+
+可像 Ollama 通过暴露本地端口，实现本地客户端调用。
+
+## 1 选择模型
+
+在 LM Studio 的 “开发者” 选项卡中选择模型：
+
+![](https://p.ipic.vip/e81rln.png)
+
+
+
+## 2 端口暴露
+
+设置暴露的端口（默认1234）：
+
+![](https://p.ipic.vip/pz7q9q.png)
+
+启用 CORS 后，可对接网页应用或其他客户端工具。
+
+## 3 启动服务
+
+点击状态选项卡：
+
+![](https://p.ipic.vip/1b27ep.png)
+
+控制台会显示运行日志和访问地址：
+
+![](https://p.ipic.vip/mre6nr.png)
+
+## 4 快速上手
+
+### 4.1 快速ping
+
+列出已加载并就绪的模型：
+
+```bash
+curl http://127.0.0.1:1234/v1/models/
+```
+
+![](https://p.ipic.vip/prjgve.png)
+
+这也是验证服务器是否可访问的一种有效方法！
+
+### 4.2 聊天
+
+这是一个类似调用OpenAI的操作，通过`curl`工具访问`/v1/chat/completion`端点：
+
+- 在Mac或Linux系统，可用任意终端运行
+- Windows系统用Git Bash 
+
+```bash
+curl http://127.0.0.1:1234/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "llama-4-maverick-17b-128e-instruct",
+    "messages": [ 
+      { "role": "system", "content": "Always answer in rhymes." },
+      { "role": "user", "content": "Introduce yourself." }
+    ], 
+    "temperature": 0.7, 
+    "max_tokens": -1,
+    "stream": true
+  }'
+```
+
+该调用是“无状态的”，即服务器不会保留对话历史记录。调用方有责任在每次调用时提供完整的对话历史记录。 
+
+#### 流式传输 V.S 累积完整响应
+
+注意`"stream": true`（流式传输：开启）参数:
+
+- `true`（开启）时，LM Studio会在预测出标记（token）的同时将其逐一流式返回
+- 如将此参数设置为`false`（关闭），在调用返回之前，完整的预测结果会被先累积起来。对于较长的内容生成或者运行速度较慢的模型，这可能需要花费一些时间！
\ No newline at end of file
diff --git a/docs/md/AI/mcp/mcp-java-sdk.md b/docs/md/AI/mcp/mcp-java-sdk.md
new file mode 100644
index 000000000..7fd508c55
--- /dev/null
+++ b/docs/md/AI/mcp/mcp-java-sdk.md
@@ -0,0 +1,92 @@
+# MCP Java SDK 与 Spring AI 强强联手：简化 Java AI 开发流程
+
+## 0 前言
+
+MCP Java SDK 为 AI 模型与工具和数据源的集成提供了强大基础，文章介绍了 SDK 中的核心功能。
+
+## 1 MCP Java SDK 简介
+
+这个 SDK 最初在去年十一月是一个实验性项目，如今已经发展为与 Spring AI 团队和 Anthropic 的正式合作成果。如今这个实验项目已经正式成为 MCP Java SDK。
+
+MCP Java SDK 是继 Python、TypeScript 和 Kotlin SDK 之后，协议支持的最新语言绑定，可在MCP 官网找到：
+
+![](https://p.ipic.vip/l1y7zb.png)
+
+Java 一直是企业级开发的主流语言，而 MCP Java SDK 的出现，使企业更容易开发前沿的 AI 应用。该 SDK 为 AI 模型与外部工具和数据源的集成提供了全面的基础功能。
+
+## 2 核心特性
+
+### 客户端与服务端实现
+
+- 支持同步和异步的 MCP 通信。
+- 支持协议版本兼容性协商，实现良好的互操作性。
+
+### 工具与资源管理
+
+- 可动态发现、注册并执行工具。
+- 实时接收工具和资源列表的变更通知。
+- 通过 URI 模板管理资源，实现结构化访问和订阅。
+
+### Prompt 处理与 AI 采样支持
+
+- 获取并管理 Prompt，以定制 AI 模型的行为。
+- 支持多种采样策略，优化 AI 交互效果。
+
+### 多种传输实现
+
+- 基于 Stdio 的传输，用于直接进程通信
+- 基于 Java HttpClient 的 SSE 客户端传输，用于基于 HTTP 的流式通信
+- 基于 Servlet 的 SSE 服务端传输，适用于传统服务器环境的 HTTP 流式传输
+- 基于 Spring 的传输方式，便于与 Spring Boot 集成：
+  - 基于 Spring WebFlux 的 SSE 传输，适用于响应式应用
+  - 基于 Spring WebMVC 的 SSE 传输，适用于基于 servlet 的应用
+
+## 3 Spring AI 与 MCP
+
+Spring AI 项目基于 MCP Java SDK 进行了扩展，提升与 Spring Boot 应用集成的开发效率。通过Spring Boot starters，开发者可用 Spring 的依赖注入和配置管理功能，快速配置 MCP 客户端和服务端，让基于 AI 的工作流更易接入应用系统。
+
+#### 客户端Starters
+
+- `spring-ai-mcp-client-spring-boot-starter` —— 核心客户端启动器，支持 STDIO 和基于 HTTP 的 SSE 传输。
+- `spring-ai-mcp-client-webflux-spring-boot-starter` —— 支持响应式应用的 WebFlux SSE 传输实现。
+
+#### 服务端Starters
+
+- `spring-ai-mcp-server-spring-boot-starter` —— 核心服务端启动器，支持 STDIO 传输
+- `spring-ai-mcp-server-webmvc-spring-boot-starter` —— 基于 Spring MVC 的 SSE 传输实现，适用于 servlet 应用
+- `spring-ai-mcp-server-webflux-spring-boot-starter` —— 基于 WebFlux 的 SSE 传输实现，适用于响应式应用
+
+### 示例
+
+通过声明方式配置 STDIO 传输客户端应用。在 `application.yml` 中添加如下配置：
+
+```yaml
+spring:
+  ai:
+    mcp:
+      client:
+        stdio:
+          servers-configuration: classpath:mcp-servers.json
+```
+
+而所引用的 JSON 文件，采用 Claude Desktop 格式定义要连接的 MCP 服务端：
+
+```json
+{
+  "mcpServers": {
+    "filesystem": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-filesystem",
+        "/Users/username/Desktop",
+        "/Users/username/Downloads"
+      ]
+    }
+  }
+}
+```
+
+当客户端应用启动时，它会自动启动 MCP 服务端，建立 STDIO 通信通道，并负责管理服务端生命周期。
+
+Spring AI M6 版本引入 `@Tool` ，简化 MCP 服务端创建过程。
\ No newline at end of file
diff --git a/docs/md/design/iterator-pattern.md b/docs/md/design/iterator-pattern.md
new file mode 100644
index 000000000..2009da270
--- /dev/null
+++ b/docs/md/design/iterator-pattern.md
@@ -0,0 +1,581 @@
+# 迭代器模式
+
+## 1 概念
+
+### 1.1 定义
+
+行为型，Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.（它提供一种方法访问一个容器对象中各个元素，而又不需暴露该对象的内部细节。）
+
+基本不会有人业务开发使用的模式，没人会单独写一个迭代器，除非是产品性质的开发。迭代器是为容器服务的，如Collection、Map，迭代器模式就是为解决遍历这些容器中的元素。
+
+迭代器模式的通用类图：
+
+![](https://p.ipic.vip/73x0w7.png)
+
+容器只要负责新增、移除元素即可，遍历由迭代器进行。
+
+### 1.2 角色
+
+#### Iterator抽象迭代器
+
+定义访问和遍历元素的接口，基本固定的3个方法：
+
+  - hasNext()，是否已访问到底部
+  - next()，访问下一个元素
+  - remove，从基础集合中删除该迭代器返回的最后一个元素（可选操作）。此方法只能调用一次，每个next一次。
+
+```java
+public interface Iterator<E> {
+
+  boolean hasNext();
+
+  E next();
+
+  default void remove() {
+      throw new UnsupportedOperationException("remove");
+  }
+
+  default void forEachRemaining(Consumer<? super E> action) {
+      Objects.requireNonNull(action);
+      while (hasNext())
+          action.accept(next());
+  }
+}
+```
+
+#### ConcreteIterator具体迭代器
+
+实现迭代器接口，完成容器元素的遍历。
+
+```java
+public class ConcreteIterator implements Iterator {
+     private Vector vector = new Vector();
+     // 定义当前游标
+     public int cursor = 0;
+     @SuppressWarnings("unchecked")
+     public ConcreteIterator(Vector _vector){
+             this.vector = _vector;
+     }
+
+     // 判断是否到达尾部
+     public boolean hasNext() {
+             if(this.cursor == this.vector.size()){
+                    return false;
+             }else{
+                    return true;
+             }
+     }
+
+     // 返回下一个元素
+     public Object next() {
+             Object result = null;
+             if(this.hasNext()){
+                    result = this.vector.get(this.cursor++);
+             }else{
+                    result = null;
+             }
+             return result;
+     }
+
+     // 删除当前元素
+     public boolean remove() {
+             this.vector.remove(this.cursor);
+             return true;
+     }
+}
+```
+
+#### Aggregate抽象容器
+
+提供创建具体迭代器角色的接口，必然提供一个类似createIterator()这样的方法，在Java中一般是iterator()方法。
+
+```java
+public interface Aggregate {
+     //是容器必然有元素的增加
+     public void add(Object object);
+     //减少元素
+     public void remove(Object object);
+     //由迭代器来遍历所有的元素
+     public Iterator iterator();
+}
+```
+
+#### Concrete Aggregate具体容器
+
+实现容器接口定义的方法，创建出容纳迭代器的对象。
+
+```java
+public class ConcreteAggregate implements Aggregate {
+     //容纳对象的容器
+     private Vector vector = new Vector();
+     //增加一个元素
+     public void add(Object object) {
+             this.vector.add(object);
+     }
+     //返回迭代器对象
+     public Iterator iterator() {
+             return new ConcreteIterator(this.vector);
+     }
+     //删除一个元素
+     public void remove(Object object) {
+             this.remove(object);
+     }
+}
+```
+
+开发系统时，迭代器的删除方法应该完成两个逻辑：
+
+- 删除当前元素
+- 当前游标指向下一个元素
+
+### 1.3 场景类
+
+```java
+public class Client {
+     public static void main(String[] args) {
+             //声明出容器
+             Aggregate agg = new ConcreteAggregate();
+             //产生对象数据放进去
+             agg.add("abc");
+             agg.add("aaa");
+             agg.add("1234");     
+             //遍历一下
+             Iterator iterator = agg.iterator();
+             while(iterator.hasNext()){
+                     System.out.println(iterator.next());
+             }
+     }
+}
+```
+
+简单地说，迭代器就类似于一个数据库中的游标，可以在一个容器内上下翻滚，遍历所有它需要查看的元素。
+
+## 2 适用场景
+
+- 访问一个集合对象的内容而无需暴露它的内部表示
+- 为遍历不同的集合结构提供一个统一的接口
+
+案例使用了迭代器模式，为啥使原本简单应用变复杂？因为我们在简单的应用中使用迭代器，注意到：
+
+```java
+for(IProject project:projectList)
+```
+
+它为啥能运行？不是因为ArrayList已实现iterator()方法，我们才能如此简单应用。
+
+JDK 1.2新增
+
+### 2.1 java.util.Iterator接口
+
+并逐步把Iterator应用到各集合类（Collection），JDK 1.5有个java.util.Iterable接口，多少接口继承了它？
+
+BlockingQueue、Collection、List、Queue、Set和SortedSet
+
+它多少个实现类？
+
+AbstractCollection,AbstractList,AbstractQueue,AbstractSequentialList,AbstractSet,ArrayBlockingQueue,ArrayList,AttributeList,BeanContextServicesSupport,BeanContextSupport,ConcurrentLinkedQueue,CopyOnWriteArrayList,CopyOnWriteArraySet,DelayQueue,EnumSet,HashSet,JobStateReasons,LinkedBlockingQueue,LinkedHashSet,LinkedList,PriorityBlockingQueue,PriorityQueue,RoleList,RoleUnresolvedList,Stack,SynchronousQueue,TreeSet,Vector
+
+基本常用类都在这个表，正因迭代器模式已内置到基本API，才能如此轻松、便捷使用。
+
+### 2.2 Iterable接口
+
+java.util.Iterable接口1.8前只有一个方法：
+
+```java
+public interface Iterable<T> {
+    /**
+     * Returns an iterator over elements of type {@code T}.
+     *
+     * @return an Iterator.
+     */
+    Iterator<T> iterator();
+  
+ 		...
+}
+```
+
+即通过iterator()去遍历聚集类中的所有方法或属性，Java已将迭代器备好，我们再去写迭代器，就多余了，少有项目独立写迭代器。
+
+## 3 优点
+
+分离了集合对象的遍历行为
+
+## 4 缺点
+
+类的个数成对增加
+
+### 实例
+
+现在还在开发或者维护的几百个项目，信息很乱，能否先把这些项目最新情况重新打印一份给我？
+
+项目信息类图：
+
+![](https://i-blog.csdnimg.cn/blog_migrate/d410cad7bac8a06a9baf4929e41ba82a.png)
+
+- 项目信息接口
+
+```java
+public interface IProject {
+     // 从老板这里看到的就是项目信息
+     public String getProjectInfo();
+}
+```
+
+- 项目信息的实现
+
+```java
+public class Project implements IProject {
+     //项目名称
+     private String name = "";
+     //项目成员数量
+     private int num = 0;
+     //项目费用
+     private int cost = 0;
+     //定义一个构造函数，把所有老板需要看到的信息存储起来
+     public Project(String name,int num,int cost){
+             //赋值到类的成员变量中
+             this.name = name;
+             this.num = num;
+             this.cost=cost;
+     }
+     //得到项目的信息
+     public String getProjectInfo() {
+             String info = "";
+             //获得项目的名称
+             info = info+ "项目名称是：" + [this.name](http://this.name/);
+             //获得项目人数
+             info = info + "\t项目人数: "+ this.num;
+             //项目费用
+             info = info+ "\t 项目费用："+ this.cost;
+             return info;
+     }
+}
+```
+
+通过构造函数把要显示的数据传递过来，然后放到getProjectInfo中显示
+
+- 报表的场景
+
+```java
+public class Boss {
+             public static void main(String[] args) {
+                     //定义一个List，存放所有的项目对象
+                     ArrayList projectList = new ArrayList();
+                     //增加星球大战项目
+                     projectList.add(new Project("星球大战项目",10,100000));
+                     //增加扭转时空项目
+                     projectList.add(new Project("扭转时空项目",100,10000000));
+                     //增加超人改造项目
+                     projectList.add(new Project("超人改造项目",10000,1000000000));
+                     //这边100个项目
+                     for(int i=4;i<104;i++){
+                             projectList.add(new Project("第"+i+"个项目",i*5,i*1000000));
+                     }
+                     //遍历一下ArrayList，把所有的数据都取出
+                     for(IProject project:projectList){
+             System.out.println(project.getProjectInfo());
+                                        }
+             }
+}
+```
+
+然后看一下我们的运行结果，如下所示：
+![](https://i-blog.csdnimg.cn/blog_migrate/2c6a45e64ddb14f2b32b954d3cc30c31.png)
+
+又看了一遍程序,应该还有另外一种实现方式，因为是遍历嘛，让我想到的就是Java的迭代器接口java.util.iterator，它的作用就是遍历Collection集合下的元素，那我们的程序还可以有另外一种实现，通过实现iterator接口来实现遍历
+
+![增加迭代接口的类图](https://i-blog.csdnimg.cn/blog_migrate/52be9b4902619bcb12219c0efe7e864c.png)
+
+看着是不是复杂了很多？是的，是有点复杂了，是不是我们把简单的事情复杂化了？
+我们先分析一下我们的类图java.util.Iterator接口中声明了三个方法，这是JDK定义的， ProjectIterator 实现该接口，并且聚合了Project对象，也就是把Project对象作为本对象的成员变量使用。看类图还不是很清晰，我们一起看一下代码，先看IProject接口的改变
+
+- 项目信息接口
+
+```java
+public interface IProject {
+     //增加项目
+     public void add(String name,int num,int cost);
+     //从老板这里看到的就是项目信息
+     public String getProjectInfo();
+     //获得一个可以被遍历的对象
+     public IProjectIterator iterator();
+}
+```
+
+这里多了两个方法，一个是add方法，这个方法是增加项目，也就是说产生了一个对象后，直接使用add方法增加项目信息。我们再来看其实现类
+
+- 项目信息
+
+```java
+public class Project implements IProject {
+     //定义一个项目列表，说有的项目都放在这里
+     private ArrayList projectList = new ArrayList();
+     //项目名称
+     private String name = "";
+     //项目成员数量
+     private int num = 0;
+     //项目费用
+     private int cost = 0;
+     public Project(){
+
+     }
+     //定义一个构造函数，把所有老板需要看到的信息存储起来
+     private Project(String name,int num,int cost){
+             //赋值到类的成员变量中
+             [this.name](http://this.name/) = name;
+             this.num = num;
+             this.cost=cost;
+     }
+     //增加项目
+     public void add(String name,int num,int cost){
+             this.projectList.add(new Project(name,num,cost));
+     }
+     //得到项目的信息
+     public String getProjectInfo() {
+             String info = "";
+             //获得项目的名称
+             info = info+ "项目名称是：" + [this.name](http://this.name/);
+             //获得项目人数
+             info = info + "\t项目人数: "+ this.num;
+             //项目费用
+             info = info+ "\t 项目费用："+ this.cost;
+             return info;
+     }
+     //产生一个遍历对象
+     public IProjectIterator iterator(){
+             return new ProjectIterator(this.projectList);
+     }
+}
+```
+
+通过构造函数，传递了一个项目所必需的信息，然后通过iterator()方法，把所有项目都返回到一个迭代器中。Iterator()方法看不懂不要紧，继续向下阅读。再看IProjectIterator接口
+
+- 项目迭代器接口
+
+```java
+public interface IProjectIterator extends Iterator {
+}
+```
+
+大家可能对该接口感觉很奇怪，你定义的这个接口方法、变量都没有，有什么意义呢？有意义，所有的Java书上都会说要面向接口编程，你的接口是对一个事物的描述，也就是说我通过接口就知道这个事物有哪些方法，哪些属性，我们这里的IProjectIterator是要建立一个指向Project类的迭代器，目前暂时定义的就是一个通用的迭代器，可能以后会增加IProjectIterator的一些属性或者方法。当然了，你也可以在实现类上实现两个接口，一个是Iterator,一个是IProjectIterator（这时候，这个接口就不用继承Iterator），杀猪杀尾巴，各有各的杀法。
+`如果我要实现一个容器或者其他API提供接口时，我一般都自己先写一个接口继承，然后再继承自己写的接口，保证自己的实现类只用实现自己写的接口（接口传递，当然也要实现顶层的接口）`
+我们继续看迭代器的实现类
+
+- 项目迭代器
+
+```java
+public class ProjectIterator implements IProjectIterator {
+     //所有的项目都放在ArrayList中
+     private ArrayList projectList = new ArrayList();
+     private int currentItem = 0; 
+     //构造函数传入projectList
+     public ProjectIterator(ArrayList projectList){
+             this.projectList = projectList;
+     }
+     //判断是否还有元素，必须实现
+     public boolean hasNext() {
+             //定义一个返回值
+             boolean b = true;
+             if(this.currentItem>=projectList.size()||this.projectList.get(this.currentItem)==null){
+                  b =false;
+          }
+             return b;
+     }
+     //取得下一个值
+     public IProject next() {
+             return (IProject)this.projectList.get(this.currentItem++);
+     }
+     //删除一个对象
+     public void remove() {
+             //暂时没有使用到
+     }
+}
+```
+
+细心的读者可能会从代码中发现一个问题，java.util.iterator接口中定义next()方法的返回值类型是E，而你在ProjectIterator中返回值却是IProject，E和IProject有什么关系？
+
+E是JDK 1.5中定义的新类型：元素（Element），是一个泛型符号，表示一个类型，具体什么类型是在实现或运行时决定，总之它代表的是一种类型，你在这个实现类中把它定义为ProjectIterator，在另外一个实现类可以把它定义为String，都没有问题。它与Object这个类可是不同的，Object是所有类的父类，随便一个类你都可以把它向上转型到Object类，也只是因为它是所有类的父类，它才是一个通用类，而E是一个符号，代表所有的类，当然也代表Object了。
+
+都写完毕了，看看我们的Boss类有多少改动
+
+- 老板看报表
+
+```java
+public class Boss {
+             public static void main(String[] args) {
+                     //定义一个List，存放所有的项目对象
+                     IProject project = new Project();
+                     //增加星球大战项目
+                     project.add("星球大战项目ddddd",10,100000);
+                     //增加扭转时空项目
+                     project.add("扭转时空项目",100,10000000);
+                     //增加超人改造项目
+                     project.add("超人改造项目",10000,1000000000);
+                     //这边100个项目
+                     for(int i=4;i<104;i++){
+                             project.add("第"+i+"个项目",i*5,i*1000000);
+                     }
+                     //遍历一下ArrayList，把所有的数据都取出
+                     IProjectIterator projectIterator = project.iterator();
+                     while(projectIterator.hasNext()){
+                             IProject p = (IProject)projectIterator.next();
+                             System.out.println(p.getProjectInfo());
+                     }
+             }
+}
+```
+
+运行结果如下所示：
+
+![](https://p.ipic.vip/vrrgkx.png)
+
+## 5 Coding
+
+
+
+![](https://p.ipic.vip/ab3wl8.png)
+
+```java
+@Data
+public class Course {
+
+    private String name;
+}
+
+```
+
+```    java
+public interface CourseIterator {
+
+    Course nextCourse();
+
+    boolean isLastCourse();
+}
+```
+
+```java
+public class CourseIteratorImpl implements CourseIterator {
+    private List courseList;
+    private int position;
+    Course course;
+
+    public CourseIteratorImpl(List courseList) {
+        this.courseList = courseList;
+    }
+
+    @Override
+    public Course nextCourse() {
+        System.out.println("返回课程,位置是: " + position);
+        course = (Course) courseList.get(position);
+        position++;
+        return course;
+    }
+
+    @Override
+    public boolean isLastCourse() {
+        if (position < courseList.size()) {
+            return false;
+        }
+        return true;
+    }
+}
+```
+
+```java
+public interface CourseAggregate {
+
+    void addCourse(Course course);
+
+    void removeCourse(Course course);
+
+    CourseIterator getCourseIterator();
+}
+```
+
+```java
+public class CourseAggregateImpl implements CourseAggregate {
+
+    private List courseList;
+
+    public CourseAggregateImpl() {
+        this.courseList = new ArrayList();
+    }
+
+    @Override
+    public void addCourse(Course course) {
+        courseList.add(course);
+    }
+
+    @Override
+    public void removeCourse(Course course) {
+        courseList.remove(course);
+    }
+
+    @Override
+    public CourseIterator getCourseIterator() {
+        return new CourseIteratorImpl(courseList);
+    }
+}
+```
+
+```java
+public class Test {
+
+    public static void main(String[] args) {
+        Course course1 = new Course("Java课程");
+        Course course2 = new Course("Python课程");
+        Course course3 = new Course("前端课程");
+        Course course4 = new Course("大数据课程");
+        Course course5 = new Course(" AI课程");
+        Course course6 = new Course("PHP课程");
+
+        CourseAggregate courseAggregate = new CourseAggregateImpl();
+        courseAggregate.addCourse(course1);
+        courseAggregate.addCourse(course2);
+        courseAggregate.addCourse(course3);
+        courseAggregate.addCourse(course4);
+        courseAggregate.addCourse(course5);
+        courseAggregate.addCourse(course6);
+
+        System.out.println("-----课程列表-----");
+        printCourses(courseAggregate);
+        courseAggregate.removeCourse(course4);
+        courseAggregate.removeCourse(course5);
+        System.out.println("-----删除操作之后的课程列表-----");
+        printCourses(courseAggregate);
+    }
+
+    private static void printCourses(CourseAggregate courseAggregate) {
+        CourseIterator courseIterator = courseAggregate.getCourseIterator();
+        while (!courseIterator.isLastCourse()) {
+            Course course = courseIterator.nextCourse();
+            System.out.println(course.getName());
+        }
+    }
+}
+```
+
+## 6 MyBatis中的应用
+
+```java
+package org.apache.ibatis.cursor.defaults;
+
+public class DefaultCursor<T> implements Cursor<T> {
+
+    private final CursorIterator cursorIterator = new CursorIterator();
+  
+    @Override
+    public Iterator<T> iterator() {
+        if (iteratorRetrieved) {
+            throw new IllegalStateException("Cannot open more than one iterator on a Cursor");
+        }
+        iteratorRetrieved = true;
+        return cursorIterator;
+    }
+  	...
+}
+```
+
+## 7 最佳实践
+
+别自己实现迭代器模式！
\ No newline at end of file
diff --git "a/docs/md/design/\344\273\243\347\220\206\346\250\241\345\274\217Proxy Pattern.md" b/docs/md/design/proxy-pattern.md
similarity index 99%
rename from "docs/md/design/\344\273\243\347\220\206\346\250\241\345\274\217Proxy Pattern.md"
rename to docs/md/design/proxy-pattern.md
index bb99c73eb..0faad9c2f 100644
--- "a/docs/md/design/\344\273\243\347\220\206\346\250\241\345\274\217Proxy Pattern.md"	
+++ b/docs/md/design/proxy-pattern.md
@@ -1,4 +1,4 @@
-# 代理模式Proxy Pattern
+# 代理模式（Proxy Pattern）
 
 ## 1 定义
 
diff --git "a/docs/md/design/\347\255\226\347\225\245\346\250\241\345\274\217Strategy Pattern.md" b/docs/md/design/strategy-pattern.md
similarity index 99%
rename from "docs/md/design/\347\255\226\347\225\245\346\250\241\345\274\217Strategy Pattern.md"
rename to docs/md/design/strategy-pattern.md
index 65801211f..85c5d8e78 100644
--- "a/docs/md/design/\347\255\226\347\225\245\346\250\241\345\274\217Strategy Pattern.md"	
+++ b/docs/md/design/strategy-pattern.md
@@ -1,4 +1,4 @@
-# 策略模式Strategy Pattern
+# 策略模式（Strategy Pattern）
 
 ## 1 简介
 
diff --git "a/docs/md/design/\346\250\241\346\235\277\346\226\271\346\263\225\350\256\276\350\256\241\346\250\241\345\274\217\357\274\210Template Pattern\357\274\211.md" b/docs/md/design/template-pattern.md
similarity index 100%
rename from "docs/md/design/\346\250\241\346\235\277\346\226\271\346\263\225\350\256\276\350\256\241\346\250\241\345\274\217\357\274\210Template Pattern\357\274\211.md"
rename to docs/md/design/template-pattern.md
diff --git a/docs/md/java/java24-new-features.md b/docs/md/java/java24-new-features.md
new file mode 100644
index 000000000..fe489d499
--- /dev/null
+++ b/docs/md/java/java24-new-features.md
@@ -0,0 +1,240 @@
+# JDK24新特性
+
+![](https://www.oracle.com/a/pr/img/rc24-java24.jpg)
+
+Java 24有 20 多项新功能，包括新的 AI 和后量子密码功能，为开发人员提供构建 AI 应用所需的工具。
+
+## 1 语言特性
+
+- **[JEP 488](https://openjdk.org/jeps/488):** Primitive Types in Patterns, instanceof, and switch（第二预览版）— 使语言更统一且更具表达能力，帮助开发消除在使用模式匹配、instanceof 和 switch 时遇到的基元类型的限制，从而增强模式匹配。在所有模式上下文中支持基元类型模式，并扩展 instanceof 和 switch，使其能够与所有基元类型一起使用。集成 AI 推理的开发将能从原始类型支持大大受益
+- **[JEP 492](https://openjdk.org/jeps/492):** Flexible Constructor Bodies（第三预览版）— 在构造函数主体中引入两个不同的序言和表述阶段，提高代码可靠性。开发能更自然将他们当前必须考虑的逻辑融入辅助静态方法、辅助中间构造函数或构造函数参数。保留了现有的保证，即子类构造函数中的代码不能干扰超类实例化，能够在重写方法时使类更加可靠。这个方法不必创建私人助手，仅需一行代码就可以调用 this/super，非常好用。流收集器功能也很有趣，期待库能想出许多可供借鉴的新的中间操作
+- **[JEP 494](https://openjdk.org/jeps/494):** Module Import Declarations（第二预览版）— 开发可轻松导入由模块导出的所有程序包，无需将导入代码放到模块中，提高工作效率。简化所有开发对模块化库的重用，让初学者轻松用第三方库和基本 Java 类，无需了解它们在程序包层次结构中的位置。帮助开发快速将业务逻辑与原生 AI 推理、库或服务调用集成
+- **[JEP 495](https://openjdk.org/jeps/495):** Simple Source Files and Instance Main Methods（第四预览版）— 帮助学生无需了解为大型程序而设计的语言功能，即可顺利编写第一个程序，加快了上手 Java 编程的速度。有鉴于此，教育工作者和导师可以循序渐进地介绍概念，学生也可以编写简化的单类程序声明，并随着个人技能的提升，无缝扩展程序并使用更高级的功能。此外，经验丰富的 Java 开发人员也可以以简洁而高效的方式编写小程序，无需使用为大型项目设计的工具。
+
+## 2 库
+
+- **[JEP 485](https://openjdk.org/jeps/485):** Stream Gatherers — 通过增强 Stream API 来支持自定义中间操作，让流管道以现有内置中间操作无法轻松实现的方式转换数据，从而帮助开发人员提高阅读、编写和维护 Java 代码的效率。
+- **[JEP 484](https://openjdk.org/jeps/484):** Class-File API — 通过提供用于解析、生成和转换 Java 类文件的标准 API，以及跟踪 Java Virtual Machine 规范定义的类文件格式，帮助开发人员提高工作效率。
+- **[JEP 487](https://openjdk.org/jeps/487):** Scoped Values（第四预览版）— 支持开发人员在线程内和线程之间共享不可变数据，从而提高项目的易用性、可理解性、性能和稳健性。
+- **[JEP 489](https://openjdk.org/jeps/489):** Vector API （九次孵化阶段）— 新推出的 API 允许以一种在运行时，可靠地编译为支持的 CPU 架构上的向量指令方式表达向量计算，帮助开发人员提高生产力。因此，开发人员可以实现优于等效标量计算的表现，这些计算通常用于 AI 推理和计算场景。
+- **[JEP 499](https://openjdk.org/jeps/499):** Structured Concurrency（第四预览版）— 通过面向结构化并发的新 API 简化并发编程，帮助开发人员提高多线程代码的可维护性、可靠性和可观察性。通过将在不同线程中运行的相关任务组视为单个工作单元，结构化并发可以减少因取消和关闭而产生的常见风险，例如线程泄漏和取消延迟。
+
+## 3 安全库
+
+- **[JEP 478](https://openjdk.org/jeps/478):** Key Derivation Function API（预览版）— 通过为传输中的数据提供加密安全，帮助开发人员为新兴的量子计算环境做好准备。这有助于提高保密性和通信完整性。
+- **[JEP 496](https://openjdk.org/jeps/496):** Quantum-Resistant Module-Lattice-Based Key Encapsulation Mechanism — 支持实施抗量子的基于模块晶格的密钥封装机制 (ML-KEM)，帮助提高 Java 应用的安全性。此功能是 Java 平台朝着后量子就绪以及最终交付后量子加密 (PQC) 技术支持迈出的重要一步，因为密钥封装机制用于通过公钥加密技术通过不安全的通信通道保护对称密钥。
+- **[JEP 497](https://openjdk.org/jeps/497):** Quantum-Resistant Module-Lattice-Based Digital Signature Algorithm — 支持实施抗量子的基于模块晶格的数字签名算法 (ML-DSA)，帮助提高 Java 应用的安全性。与 JEP 496 一样，此功能是 Java 平台迈向后量子就绪以及最终交付 PQC 技术支持的重要举措，因为数字签名主要用于检测未经授权的数据修改和验证签字人的身份。ML-DSA 旨在防止未来的量子计算攻击，目前已被美国国家标准与技术研究所 (NIST) 列为 FIPS 204 中的标准化项目。
+
+## 4 工具
+
+- **[JEP 493](https://openjdk.org/jeps/493):** Linking Run-Time Images without JMODs — jlink 工具无需使用 JDK 的 JMOD 文件，即可创建定制运行时映像，能够将 JDK 的大小缩减约 25%，进而帮助开发人员提高效率。有鉴于此，开发人员可以从模块链接运行时映像，无论这些模块是独立的 JMOD 文件、模块化 JAR 文件还是以前链接的运行时映像的一部分。构建 JDK 时必须启用此功能；此功能不会默认启用，某些 JDK 供应商可以选择不启用此功能。
+
+## 5 性能和运行时更新
+
+- **[JEP 450](https://openjdk.org/jeps/450):** Compact Object Headers（实验版） — 在 64 位架构上，将 HotSpot JVM 中的对象标头大小从 96 位和 128 位缩减至 64 位，帮助开发人员提高工作效率。有助减少堆大小、提高部署密度和增加数据局部性
+- **[JEP 475](https://openjdk.org/jeps/475):** Late Barrier Extension for G1 — 通过将 G1 垃圾收集器屏障从早期的 C2 JIT 编译管道扩展切换到后期屏障扩展，这意味着如果该项操作在独立于平台的优化和寄存器分配之后发生，就可以降低开销，还可以帮助开发人员提高效率。通过简化 G1 垃圾收集器屏障的实施，此功能有助于提高 C2 生成的代码的效率、可理解性、可恢复性和质量
+- **[JEP 483](https://openjdk.org/jeps/483):** Ahead-of-Time Class Loading & Linking — 在 HotSpot Java Virtual Machine 启动时，使应用的类在加载和链接状态下立即可用，从而帮助开发人员提高工作效率并缩短启动时间。此功能不需要使用 jlink 或 jpackage 工具，不需要对从命令行启动应用的方式进行任何更改，也不需要对应用、库或框架的代码进行任何更改。因此，该功能有助于为启动和预热时间的持续进步奠定基础。
+- **[JEP 490](https://openjdk.org/jeps/490):** ZGC: Remove the Non-Generational Mode — 通过删除 Z Garbage Collector (ZGC) 的非分代模式，帮助开发人员降低支持两种不同模式的维护成本
+- **[JEP 491](https://openjdk.org/jeps/491):** Synchronize Virtual Threads without Pinning — 提高使用同步方法和语句的 Java 代码和库的可扩展性，帮助开发人员提高工作效率。该功能允许虚拟线程释放其底层平台线程，让开发人员能够访问更多的虚拟线程来管理其应用的工作负载
+
+## 6 源代码
+
+- **[JEP 404](https://openjdk.org/jeps/404):** Generational Shenandoah（实验版） — 通过实验性的分代收集功能增强 Shenandoah 垃圾收集器，以提高可持续吞吐量、负载峰值抵抗力和内存利用率，帮助开发人员提高工作效率。
+- **[JEP 479](https://openjdk.org/jeps/479):** Remove the Windows 32-bit x86 Port — 删除对 Windows 32 位 x86 端口的源代码和构建支持，简化了 JDK 的构建和测试架构，帮助开发人员提高效率。
+- **[JEP 501](https://openjdk.org/jeps/501):** Deprecate the 32-bit x86 Port for Removal — 弃用 32 位 x86 端口，以便能够在接下来的版本中删除该端口，帮助开发人员提高工作效率。开发人员无需实施 32 位 x86 回退，即可访问需要特定平台支持的新功能。
+
+通过引入安全的现代化特性，同时逐渐弃用和删除不安全的特性，Oracle 强调致力于保持 Java 的完整性并遵循软件开发优秀实践。
+
+Oracle 即将在接下来的 Java 版本中删除这三个特性：
+
+-  [JEP 472](https://openjdk.org/jeps/472): Prepare to Restrict the Use of JNI;
+-  [JEP 486](https://openjdk.org/jeps/486): Permanently Disable the Security Manager;
+-  [JEP 498](https://openjdk.org/jeps/498): Warn upon Use of Memory-Access Methods in sun.misc.Unsafe
+
+## 7 大佬们的观点
+
+NYJavaSIG 董事长 Frank Greco 表示：“我期待能够使用 Java 24 中进一步完善的 Java Vector API，进一步增强预测和生成式 AI 应用。直接在 Java 中启用高效的 AI 算法，有助于确保 AI 应用在各种现代硬件平台中高效运行和可扩展。”
+
+XDEV Software GmbH 首席执行官 Richard Fichtner 表示：“Java 24 推出了 Stream Gatherers，这是一个强大的增强功能，可帮助开发人员对流中的元素分组和处理方式进行细粒度控制。这使得复杂的数据转换更具表现力和效率。我喜欢这个功能，它支持更可读和可维护的流管道，我们再也无需使用自定义收集器或 flatMap 体操等解决方法。”
+
+[Java 24](https://openjdk.org/projects/jdk/24/)通过改进，如[简单源文件和实例主方法](https://openjdk.org/jeps/495)、[模式、instanceof和switch中的原始类型](https://openjdk.org/jeps/488)、[模块导入声明](https://openjdk.org/jeps/494)、[灵活的构造函数体](https://openjdk.org/jeps/492)以及API增强，如[流收集器](https://openjdk.org/jeps/485)等，继续增强语言功能——还有很多其他功能。
+
+## 8 简单源文件和实例主方法（JEP 495）
+
+隐式类和导入语句、更短的`main()`方法、“`println()`”用于输出值——这些功能使初学者更容易开始使用Java。如果你是一位经验丰富的开发人员，这些功能可以帮助你用更少的代码行创建脚本、游戏和实用工具。
+
+—[Java 24：“HelloWorld”和“main()”邂逅极简主义](https://blog.jetbrains.com/idea/2024/02/helloworld-and-main-meet-minimalistic/)，以及详细博文——[Java 24：构建游戏、原型、实用工具等——减少样板代码](https://blog.jetbrains.com/idea/2025/02/java-24-build-games-prototypes-utilities-and-more-with-less-boilerplate/)，其中讨论了它的实际用例。帮助新开发人员开始编写程序，如[简单计算](https://blog.jetbrains.com/idea/2024/02/helloworld-and-main-meet-minimalistic/#example-1.-variable-declarations)、[打印模式](https://blog.jetbrains.com/idea/2024/02/helloworld-and-main-meet-minimalistic/#example-2.-print-patterns)（例如，使用指定字符打印大写字母），创建[简单的控制台和基于GUI的游戏](https://blog.jetbrains.com/idea/2025/02/java-24-build-games-prototypes-utilities-and-more-with-less-boilerplate/#1.-build-games-and-create-interesting-graphics)，还可以帮助经验丰富的开发人员创建实用工具，如[处理文件](https://blog.jetbrains.com/idea/2025/02/java-24-build-games-prototypes-utilities-and-more-with-less-boilerplate/#2.-processing-log-files)或[访问网络资源](https://blog.jetbrains.com/idea/2025/02/java-24-build-games-prototypes-utilities-and-more-with-less-boilerplate/#3.-building-utilities)（例如，股票价格爬虫）。
+
+### 创建具有实例主方法的简单源文件
+
+当你使用IntelliJ IDEA创建和运行简单的文件时，你可以像运行其他可执行类一样运行它（省去了你必须使用的编译或运行时命令行参数）。如果你忘记了将语言级别设置为24，IntelliJ IDEA可以检测到这一点，并提示你进行设置（如下所示）：
+
+![](https://blog.jetbrains.com/wp-content/uploads/2025/02/new-proj.gif)
+
+### 将隐式类转换为常规类
+
+当你准备好升级并使用其他概念（如用户定义的类）时，你可能希望将隐式类转换为常规类。你可以使用上下文操作“*将隐式声明的类转换为常规类*”，如下所示（此操作将添加相关的导入语句）：
+
+![](https://blog.jetbrains.com/wp-content/uploads/2025/02/convert-to-reg-class.gif)
+
+### 将常规类转换为隐式类
+
+有时，一个打包的类可能更适合作为隐式类，因为它可能没有使用常规类的概念。如果是这样，你可以通过使用操作“*转换为隐式声明的类*”来实现（如下所示）。在转换过程中，IntelliJ IDEA将移除不再需要的导入语句：
+
+![](https://blog.jetbrains.com/wp-content/uploads/2025/03/explicit-to-implicit.gif)
+
+### 幕后——具有实例方法main()的隐式类
+
+幕后，Java编译器会创建一个隐式顶层类，并提供一个无参构造函数，这样这些类就不需要以与常规类不同的方式处理。
+
+通过IntelliJ IDEA的反编译器功能为源代码文件*AnimateText.java*反编译的类：
+
+![](https://blog.jetbrains.com/wp-content/uploads/2024/02/decompile.gif)
+
+### 与控制台交互——println()与System.out.println()调用
+
+为了简化新开发人员与控制台的交互，即向控制台输出消息以及从中读取输入，Java 23中创建了一个新类——`java.io.IO`。它只包含少量重载的`readln()`和`println()`方法（如下所示）：
+
+![img](https://blog.jetbrains.com/wp-content/uploads/2025/02/IO-class-struc.png)
+
+`java.io.IO`类会自动导入到隐式类中。因此，你现在可以使用`println()`向控制台输出消息（并使用`readln()`从中读取），而无需使用`System.out.println()`。有趣的是，`println()`是在Java 24中添加到这个类中的。
+
+### 隐式类中重载的main方法
+
+当你在隐式类中重载`main()`方法时，需要考虑一个优先顺序，以确定哪个是“主”`main()`方法。以下是隐式类中`main()`方法的有效签名：
+
+- `public static void main(String args[]) {}`
+- `public void main(String args[]) {}`
+- `public static void main() {}`
+- `static void main() {}`
+- `public void main() {}`
+- `void main() {}`
+
+如果你的隐式类中重载了`main()`方法，IntelliJ IDEA会在正确的或首选的“main”方法旁边显示运行图标：
+
+![img](https://blog.jetbrains.com/wp-content/uploads/2025/03/which-main.gif)
+
+### 隐式类中缺少main方法
+
+如果在隐式类中未检测到有效的`main`方法，IntelliJ IDEA可以为你添加一个，如下图所示：
+
+![img](https://blog.jetbrains.com/wp-content/uploads/2024/02/create-a-main-method.gif)
+
+## 9 模式中的原始类型、instanceof和switch（预览功能）
+
+目前正处于第二次预览中，该功能[模式中的原始类型、instanceof和switch](https://openjdk.org/jeps/488)通过在所有模式中引入原始类型，增强了Java的模式匹配能力。这允许你直接在`instanceof`和`switch`表达式中使用原始类型模式（以前仅限于对象），简化代码并减少手动类型转换的需求。
+
+### 快速示例
+
+此功能使你能够在带有守护模式的`switch`表达式中使用原始类型：
+
+```java
+public String getHTTPCodeDesc(int code) {
+    return switch (code) {
+        case 100 -> "Continue";
+        case 200 -> "OK";
+        case 301 -> "Moved Permanently";
+        case 302 -> "Found";
+        case 400 -> "Bad Request";
+        case 500 -> "Internal Server Error";
+        case 502 -> "Bad Gateway";
+        case int i when i > 100 && i < 200 -> "Informational";
+        case int i when i > 200 && i < 300 -> "Successful";
+        case int i when i > 302 && i < 400 -> "Redirection";
+        case int i when i > 400 && i < 500 -> "Client Error";
+        case int i when i > 502 && i < 600 -> "Server Error";
+        default -> "Unknown error";
+    };
+}
+```
+
+同样，你也可以在`instanceof`操作符中使用原始类型。
+
+此功能再次作为预览功能推出，没有任何变化。我在之前的博文——[Java 23和IntelliJ IDEA](https://blog.jetbrains.com/idea/2024/09/java-23-and-intellij-idea/#primitive-types-in-patterns)中介绍了此功能以及IntelliJ IDEA对它的支持。我建议你查看该博文以了解详细信息。这篇博文回答了诸如将原始类型添加到模式匹配意味着什么、多个示例以及IntelliJ IDEA中的[强大数据流分析](https://blog.jetbrains.com/idea/2024/09/java-23-and-intellij-idea/#robust-data-flow-analysis-in-intellij-idea)等问题。
+
+### 与该功能的创造者进行访谈
+
+我们还采访了该功能的所有者，[Aggelos Biboudis](https://x.com/biboudis)（Oracle的首席技术员工）、[Brian Goetz](https://x.com/BrianGoetz)（Oracle的Java语言架构师）和[Tagir Valeev](https://x.com/tagir_valeev)（JetBrains的Java团队技术主管）。
+
+<iframe title="JEP Explained. JEP 455: Primitive Types in Patterns, instanceof, and switch" width="500" height="281" src="https://www.youtube.com/embed/tqBV4MZ-qSM?feature=oembed" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen="" style="box-sizing: inherit; max-height: 100%; max-width: 100%; position: absolute; top: 0px; left: 0px; width: 849px; height: 477.138px;"></iframe>
+
+查看该视频，了解为什么将原始数据类型添加到Java语言中以及他们提议的变更细节。
+
+## 10 模块导入声明
+
+处于第二次预览阶段的[模块导入声明](https://openjdk.org/jeps/494)使你能够通过单个声明导入模块导出的所有包。它简化了模块化库的重用，而无需要求导入代码自身模块化。例如，声明`import module java.base;`会导入`java.base`模块导出的包中的所有公共顶层类和接口，消除了多个单独导入语句的需求。这提高了代码的可读性，尤其是在使用大量API时。
+
+### 快速示例
+
+假设你的代码包含多个导入语句，如下所示：
+
+```java
+import java.io.*;
+import java.util.HashMap;
+import java.util.Map;
+import java.lang.reflect.*;
+import java.nio.*;
+```
+
+这些可以被一个导入模块语句替换，如下所示：
+
+```java
+import java.base.*;
+```
+
+### 模块java.base（或其他模块）导出了哪些包？
+
+当你使用IntelliJ IDEA时，回答这个问题非常简单。点击编辑器中的模块名称或使用相关快捷键（转到声明或用法），你可以查看该模块的定义，以了解该模块导出了哪些模块。如下图所示：
+
+![img](https://blog.jetbrains.com/wp-content/uploads/2025/03/java-base-mod.gif)
+
+### 与该功能的创造者进行访谈
+
+我们还采访了该功能的所有者，[GavinBierman](https://x.com/GavinBierman)（Oracle的编程语言设计师）。
+
+<iframe loading="lazy" title="JEP Explained. JEP 476: Module Import Declarations" width="500" height="281" src="https://www.youtube.com/embed/mSYA3cZ5o6c?feature=oembed" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen="" style="box-sizing: inherit; max-height: 100%; max-width: 100%; position: absolute; top: 0px; left: 0px; width: 849px; height: 477.138px;"></iframe>
+
+Gavin介绍了单类型导入和类型导入按需声明的区别，解释了它们是什么以及为什么个人和组织更倾向于一种风格而不是另一种。他还谈到了“模块导入声明”功能如何自动从模块的传递依赖项中按需导入。他涵盖了如何处理模糊导入、名称模糊性以及如何向OpenJDK团队提交有关此功能的反馈。
+
+## 11 灵活的构造函数体
+
+处于第三次预览阶段的此功能在超类从其构造函数中调用方法时非常有用，你希望在子类中覆盖此方法，并希望在该方法中访问子类中的字段。以前，在从超类构造函数中调用方法时，子类字段尚未初始化。现在可以初始化字段并防止意外情况发生。以下示例代码展示了此功能：
+
+```java
+abstract class Action {
+    public Action() {
+        System.out.println("performing " + getText());
+    }
+    public abstract String getText();
+}
+
+class DoubleAction extends Action {
+    private final String text;
+    private DoubleAction(String text) {
+        this.text = text; // 在Java 23之前，启用预览功能时，这无法编译。
+        super();
+    }
+    @Override public String getText() {
+        return text + text;
+    }
+}
+```
+
+如果你是第一次接触这个功能，不要错过我的详细博文——[Java 22中的构造函数改造 | IntelliJ IDEA博客](https://blog.jetbrains.com/idea/2024/02/constructor-makeover-in-java-22/)，其中讨论了这个功能的来龙去脉。
+
+## 12 预览功能
+
+这篇博文中介绍的功能都是预览功能，而不是生产功能。随着Java六个月的新发布周期，新语言功能作为预览功能发布。它们可能会在后续的Java版本中以第二次或更多次预览的形式重新引入，可能会有也可能没有变化。一旦它们足够稳定，可能会作为标准语言功能添加到Java中。
+
+预览语言功能是完整的，但不是永久的，这意味着这些功能已经准备好供开发人员使用，尽管它们的细节可能会根据开发人员的反馈在未来版本的Java中发生变化。与API不同，语言功能在未来无法被弃用。因此，如果你对任何预览语言功能有反馈，请随时在JDK邮件列表上分享（需要免费注册）。
+
+由于这些功能的工作方式，IntelliJ IDEA致力于仅支持当前JDK的预览功能。预览语言功能可能会在Java版本之间发生变化，直到它们被放弃或作为标准语言功能添加。使用较旧版本的Java SE平台的预览语言功能的代码可能无法在较新的版本上编译或运行。
+
+## 13 总结
+
+Java 24引入了关键增强功能，如简单源文件、原始类型模式、模块导入声明和灵活的构造函数体。IntelliJ IDEA自较早的版本开始就支持Java 24，并且后续版本还会增加更多增强功能！
+
+参考：
+
+- https://blogs.oracle.com/java/post/the-arrival-of-java-24
+- https://blog.jetbrains.com/idea/2025/03/java-24-and-intellij-idea/
\ No newline at end of file

From 978a36d862acca9b0042f95cdd0490fe5f1f941b Mon Sep 17 00:00:00 2001
From: JavaEdge <sss2855845850@gmail.com>
Date: Sat, 3 May 2025 01:36:30 +0800
Subject: [PATCH 17/20] update

---
 docs/.vuepress/config.js                      |  47 +-
 ...025-future-rag-trends-four-technologies.md | 119 +++++
 docs/md/AI/llm/qwen3.md                       | 448 ++++++++++++++++++
 .../01-Prompt\347\275\221\347\253\231.md"     |   0
 .../02-\345\270\270\347\224\250Prompt.md"     |   0
 .../bank-distributed-database-selection.md    | 166 +++++++
 ... 3.9' requires administrator privileges.md | 104 ++++
 7 files changed, 872 insertions(+), 12 deletions(-)
 create mode 100644 docs/md/AI/2025-future-rag-trends-four-technologies.md
 create mode 100644 docs/md/AI/llm/qwen3.md
 rename "docs/md/AI/llm/01-Prompt\347\275\221\347\253\231.md" => "docs/md/AI/prompt/01-Prompt\347\275\221\347\253\231.md" (100%)
 rename "docs/md/AI/llm/02-\345\270\270\347\224\250Prompt.md" => "docs/md/AI/prompt/02-\345\270\270\347\224\250Prompt.md" (100%)
 create mode 100644 docs/md/distdb/bank-distributed-database-selection.md
 create mode 100644 docs/md/python/Installing packages into 'Python 3.9' requires administrator privileges.md

diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index 274c99337..480ba8c37 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -751,9 +751,13 @@ module.exports = {
                         link: '/md/AI/mcp/mcp-fad-or-fixture'
                     },
                     {
-                        text: '大模型平台和Prompt工程',
+                        text: '大模型发展',
                         link: '/md/AI/llm/GPTs'
                     },
+                    {
+                        text: 'Prompt工程',
+                        link: '/md/AI/prompt/01-Prompt网站'
+                    },
                     {
                         text: 'AI Agent',
                         link: '/md/AI/agent/changelog-cursor'
@@ -1832,7 +1836,7 @@ module.exports = {
                             "03-BASE 还能撑多久？强一致性才是事务处理的终极奥义！",
                             "18-分布式数据库的HTAP能统一OLTP和 OLAP吗？",
                             "21-查询执行引擎：加速聚合计算加速",
-
+                            "bank-distributed-database-selection",
                         ]
                     }],
 
@@ -2098,6 +2102,14 @@ module.exports = {
                         children: [
                             "00-macOS和Linux安装和管理多个Python版本",
                         ]
+                    },
+                    {
+                        title: "FAQ",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "Installing packages into 'Python 3.9' requires administrator privileges",
+                        ]
                     },],
 
                     "/md/AI/llm/": [{
@@ -2113,7 +2125,6 @@ module.exports = {
                             "contextual-retrieval",
                             "lm-studio-transform-mac-into-ai-tool",
                             "navigating-llm-deployment-tips-tricks-and-techniques",
-                            "qwen-QwQ",
                             "only-ai-flow-can-do",
                             "chatgpt-canva",
                             "llm-reasoning-limitations",
@@ -2121,6 +2132,16 @@ module.exports = {
                             "lmstudio-local-llm-call",
                         ]
                     },
+                    {
+                        title: "Qwen",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "qwen-QwQ",
+                            "qwen3",
+                        ]
+                    },
+
                     {
                         title: "DeepSeek",
                         collapsable: false,
@@ -2149,15 +2170,6 @@ module.exports = {
                             "llama-4-multimodal-intelligence",
                         ]
                     },
-                    {
-                        title: "Prompt工程",
-                        collapsable: false,
-                        sidebarDepth: 0,
-                        children: [
-                            "01-Prompt网站",
-                            "02-常用Prompt",
-                        ]
-                    },
 
                     {
                         title: "Dify",
@@ -2310,6 +2322,16 @@ module.exports = {
                         ]
                     },],
 
+                    "/md/AI/prompt/": [{
+                        title: "Prompt工程",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "01-Prompt网站",
+                            "02-常用Prompt",
+                        ]
+                    }, ,],
+
                     "/md/AI/": [{
                         title: "LangChain",
                         collapsable: false,
@@ -2334,6 +2356,7 @@ module.exports = {
                             "02-相似性检索的关键 - Embedding",
                             "03-core-of-rag-result-retrieval-and-reordering",
                             "04-prompt-helping-llm-understand-knowledge",
+                            "2025-future-rag-trends-four-technologies",
                         ]
                     },
                     {
diff --git a/docs/md/AI/2025-future-rag-trends-four-technologies.md b/docs/md/AI/2025-future-rag-trends-four-technologies.md
new file mode 100644
index 000000000..3840ff069
--- /dev/null
+++ b/docs/md/AI/2025-future-rag-trends-four-technologies.md
@@ -0,0 +1,119 @@
+# 2025 及未来 RAG 趋势：深入解析四大创新技术
+
+## 0 前言
+
+RAG是AIGC可靠性和准确性的一项关键技术。不过，RAG 也存在一些局限，如上下文处理、成本控制及面对超大数据集时的挑战。
+
+因此，过去一年里，业界出现了许多新方法，试图弥补 RAG 的不足。
+
+下面深入了解 2025 年RAG领域的一些最新动态。
+
+## 1 RAG工作原理及其局限性
+
+RAG是一种结合LLM与外部知识源的技术。具体做法是，把文档或数据库等外部知识源进行分块、向量化处理，生成所谓的向量嵌入（vector embeddings），并存储在向量数据库或其他存储系统中。当用户输入提示词时，系统可以实时检索这些数据，从而为 LLM 提供更准确、更新或更具上下文的信息。
+
+虽然强大，但不少局限，如：
+
+- 检索效果大程度取决于数据本身质量和更新频率
+- 面对复杂查询或超大数据集时，传统的 RAG（有时也被称为“原始 RAG”）容易出现信息混淆或检索出的内容缺乏足够的细腻度
+
+## 2 校正型 RAG（Corrective RAG）
+
+近年来非常受欢迎的一种新方法。
+
+### 2.1 核心思想
+
+在检索过程中引入评估步骤，加入所谓的“自我反思”或“自我评分”机制。评估器会检查检索结果的准确性，如果达不到设定标准，系统就会重新检索（有时还会扩展到网页搜索）。这一机制通常由一个轻量级检索评估器来实现，用来衡量检索结果的相关性。
+
+### 2.2 解决啥问题？
+
+校正型 RAG 主要是为了应对检索不准确的问题。例如，当数据集中存在语义相近的信息时，容易混淆，而加入评估步骤可以大大提高检索结果的可靠性。
+
+### 2.3 局限性
+
+不过，校正型 RAG 也存在一些弊端。首先，引入评估环节不可避免地增加了延迟，因为需要额外的计算资源，可能会影响整体性能（尤其是在面向客户的实时应用中）。其次，它会增加 AI 流水线的复杂性，降低团队的开发效率，一旦出现问题，排查和修复也更困难。
+
+此外，校正型 RAG 无法解决数据本身的问题——如果数据不准确、过时或分块不合理，仍然会影响最终效果。
+
+### 2.4 适用场景
+
+如需在准确性和实时数据集成之间取得平衡，这是不错选择。
+
+## 3 自我反思型 RAG（Self-RAG）
+
+类似校正型RAG ，也引入“自我反思”机制，但走得更远。除了评估检索结果本身之外，自我反思型 RAG 还会在是否需要检索以及如何检索方面进行更深层次的反思，并能通过反复训练不断优化。
+
+它采用三个模型协同工作：检索器、评审器和生成器。通过这种“三位一体”的架构，自我反思型 RAG 可以生成所谓的“反思 token”。这些 token 让语言模型在推理阶段可以根据不同任务要求调整行为。
+
+一句话，通过反馈循环不断强化自己的检索决策，最终提高整体性能。
+
+### 3.1 解决啥问题？
+
+和校正型 RAG 一样，自我反思型 RAG 能有效提高检索准确率。而且由于具备自我学习能力，随着时间推移，表现还能不断提升。
+
+### 3.2 局限性
+
+它的问题和校正型 RAG 类似，但也有自己的独特挑战。比如，自我反思机制有时会导致模型“想太多”，结果输出的信息与实际数据并不吻合。
+
+此外，训练过程中用于反思的 token 可能会影响最终生成内容的质量或流畅度。因此，使用时需要根据实际需求权衡利弊。
+
+### 3.3 适用场景
+
+如果你需要模型具备较强的适应性，尤其是处理开放领域问题或复杂推理任务，自我反思型 RAG 是一个非常合适的选择。
+
+## 4 RAG 融合（RAG-fusion）
+
+思路与校正型 RAG、自我反思型 RAG 不同。前两者专注于“自我反思”，而 RAG-fusion 则是将多个检索到的资源（如文档、维基条目等）融合成一个批次，通过互惠排名融合（RRF）算法处理，扩展模型能够检索到的信息范围和细节。
+
+### 4.1 解决啥问题？
+
+RAG-fusion 主要提升了模型处理复杂背景和细节问题的能力。它能让模型给出更加连贯、详细的回答，尤其是在面对困难或多层次提示时表现更好。
+
+### 4.2 局限性
+
+不过，RAG-fusion 会显著增加 LLM 架构和流水线的复杂度（以及成本）。额外的步骤还可能引发性能下降等问题。
+
+### 4.3 适用场景
+
+如果你在客服等需要细致、连贯输出的场景中工作，RAG-fusion 是非常值得考虑的方法。
+
+## 5 快速图谱 RAG（Fast GraphRAG）
+
+[Fast GraphRAG](https://www.thoughtworks.com/radar/languages-and-frameworks/fastgraphrag) 是 [GraphRAG](https://www.thoughtworks.com/radar/techniques/graphrag) 的开源实现。GraphRAG 并不是简单地检索数据块，而是将数据抽取后构建成知识图谱，使得 LLM 能够像阅读地图一样理解和检索数据，提升了检索的深度和细致程度。
+
+Fast GraphRAG 在此基础上引入了 PageRank（谷歌创始人 Larry Page 和 Sergey Brin 开发的算法），帮助系统更快速地找出知识图谱中最相关的信息。
+
+### 5.1 解决啥问题？
+
+Fast GraphRAG 特别擅长处理数据理解和细腻度问题。利用知识图谱，让 AI 系统对数据有更丰富的“理解”。此外，它比传统 RAG 更适合处理大规模动态数据集，能够更好应对数据更新或变化。
+
+而且，Fast GraphRAG 相比传统 GraphRAG 成本更低、速度更快（据说能便宜 6 倍左右）。
+
+### 5.2 局限性
+
+不过，Fast GraphRAG 相比直接基于向量数据库的 RAG 技术还是慢一些，而且系统复杂度更高，对于很多简单场景来说，可能得不偿失。
+
+### 5.3 适用场景
+
+如果你面对的是超大数据集，或者对检索准确性要求极高，Fast GraphRAG 是一个非常值得考虑的选择。
+
+## 6 RAG的未来
+
+上面提到的方法并不全面，目前还有很多新技术正在不断涌现。
+
+比如，有些团队正在探索多模态 RAG，不仅检索文本，还能处理图像、表格、甚至音频数据。
+
+还有一种更彻底的替代方案叫缓存增强生成（Cache-augmented Generation），通过预加载数据到模型上下文窗口，省去了实时检索步骤，提升模型响应速度。虽然这种方式未必能提高准确性和输出质量，但对于提高效率很有帮助。
+
+## 7 总结
+
+可见，RAG 领域正在迅速发展。虽然生成式 AI 和大型语言模型常常成为媒体关注的焦点，但真正决定 AI 产品效果的，往往是检索技术背后的创新和实验。
+
+当然，每种方法都有其优缺点，必须在复杂性、速度和成本之间权衡取舍。
+
+**最重要的是，根据你的具体应用场景明确需求，认真评估不同方案，做出理性、有效的选择。**
+
+参考：
+
+- https://selfrag.github.io/
+- https://www.thoughtworks.com/radar
\ No newline at end of file
diff --git a/docs/md/AI/llm/qwen3.md b/docs/md/AI/llm/qwen3.md
new file mode 100644
index 000000000..ca2ccc96b
--- /dev/null
+++ b/docs/md/AI/llm/qwen3.md
@@ -0,0 +1,448 @@
+# Qwen3：思深，行速
+
+![](https://qianwen-res.oss-accelerate-overseas.aliyuncs.com/qwen3-banner.png)
+
+ [Hugging Face](https://huggingface.co/collections/Qwen/qwen3-67dd247413f0e2e4f653967f) [ModelScope](https://modelscope.cn/collections/Qwen3-9743180bdc6b48)
+
+[Kaggle](https://www.kaggle.com/models/qwen-lm/qwen-3)
+
+ [DEMO](https://huggingface.co/spaces/Qwen/Qwen3-Demo)
+
+[DISCORD](https://discord.gg/yPEP2vHTu4)
+
+## 0 引言
+
+**Qwen3-235B-A22B** 在代码、数学、通用能力等基准测试中，与 DeepSeek-R1、o1、o3-mini、Grok-3 和 Gemini-2.5-Pro 等顶级模型相比，表现极具竞争力结果。
+
+小型 MoE 模型 **Qwen3-30B-A3B** 的激活参数数量是 QwQ-32B 的 10%，表现更胜一筹：
+
+![](https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen3/qwen3-235a22.jpg)
+
+甚至 Qwen3-4B 小模型也能匹敌 Qwen2.5-72B-Instruct 性能：
+
+![](https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen3/qwen3-30a3.jpg)
+
+### 开源
+
+两个 MoE 模型的权重：
+
+- **Qwen3-235B-A22B**，拥有 2350 多亿总参数和 220 多亿激活参数的大模型
+- **Qwen3-30B-A3B**，拥有约 300 亿总参数和 30 亿激活参数的小型 MoE 模型
+
+六个 Dense 模型也已开源，包括 **Qwen3-32B**、**Qwen3-14B**、**Qwen3-8B**、**Qwen3-4B**、**Qwen3-1.7B** 和 **Qwen3-0.6B**，均在 Apache 2.0 许可下开源。
+
+| Models     | Layers | Heads (Q / KV) | Tie Embedding | Context Length |
+| :--------- | :----: | :------------: | :-----------: | :------------: |
+| Qwen3-0.6B |   28   |     16 / 8     |      Yes      |      32K       |
+| Qwen3-1.7B |   28   |     16 / 8     |      Yes      |      32K       |
+| Qwen3-4B   |   36   |     32 / 8     |      Yes      |      32K       |
+| Qwen3-8B   |   36   |     32 / 8     |      No       |      128K      |
+| Qwen3-14B  |   40   |     40 / 8     |      No       |      128K      |
+| Qwen3-32B  |   64   |     64 / 8     |      No       |      128K      |
+
+| Models          | Layers | Heads (Q / KV) | # Experts (Total / Activated) | Context Length |
+| :-------------- | :----: | :------------: | :---------------------------: | :------------: |
+| Qwen3-30B-A3B   |   48   |     32 / 4     |            128 / 8            |      128K      |
+| Qwen3-235B-A22B |   94   |     64 / 4     |            128 / 8            |      128K      |
+
+经过后训练的模型，如 **Qwen3-30B-A3B**及它们的预训练基座模型（如 **Qwen3-30B-A3B-Base**），现已在 **Hugging Face**、**ModelScope** 和 **Kaggle** 等平台开放使用。
+
+### 部署
+
+推荐用 **SGLang** 和 **vLLM** 等框架
+
+### 本地使用
+
+推荐 **Ollama**、**LMStudio**、**MLX**、**llama.cpp** 和 **KTransformers**。它们已确保用户可轻松将 Qwen3 集成到他们的工作流程，无论用于研究、开发还是生产环境。
+
+Qwen3发布和开源将极大地推动大型基础模型研究与开发。为全球研究人员、开发者和组织赋能，帮助他们利用这些前沿模型构建创新解决方案。
+
+### 试用入口
+
+- Qwen Chat 网页版 ([chat.qwen.ai](https://chat.qwen.ai/)) 和
+- 手机APP
+
+## 1 亮点
+
+### 1.1 多种思考模式
+
+Qwen3支持两种思考模式：
+
+1. 思考模式：会逐步推理，经深思熟虑后给出最终答案。适合需深入思考的复杂问题
+2. 非思考模式：提供快速、近乎即时响应，适用速度要求高于深度的简单问题
+
+这种灵活性使用户能够根据具体任务控制模型进行“思考”度，如：
+
+- 复杂的问题可以通过扩展推理步骤来解决
+- 简单的问题可直接快速作答，无需延迟
+
+两种模式结合大大增强模型实现稳定且高效的“思考预算”控制能力。如上文，Qwen3 展现出可扩展且平滑的性能提升，这与分配的计算推理预算直接相关。这样的设计让用户能更轻松为不同任务配置特定预算，在成本效益和推理质量之间实现更优平衡。
+
+![](https://qianwen-res.oss-accelerate.aliyuncs.com/assets/blog/qwen3/thinking_budget.png)
+
+### 1.2 多语言
+
+Qwen3 模型支持 **119 种语言和方言**。这一广泛的多语言能力为国际应用开辟了新的可能性，让全球用户都能受益于这些模型的强大功能。
+
+### 1.3 增强的 Agent 能力
+
+优化 Qwen3 模型的 Agent 和 代码能力，同时也加强对 MCP 支持。
+
+示例展示 Qwen3 是如何思考并与环境进行交互的。
+
+## 2 预训练
+
+Qwen2.5是在 18 万亿个 token 上预训练，Qwen3使用数据量几乎是其两倍，涵盖 119 种语言方言。
+
+为构建这庞大数据集，不仅从网络收集数据，还从 PDF 文档中提取信息。使用 Qwen2.5-VL 从这些文档中提取文本，并用 Qwen2.5 改进提取内容的质量。为了增加数学和代码数据的数量，利用 Qwen2.5-Math 和 Qwen2.5-Coder 这两个数学和代码领域的专家模型合成数据，合成了包括教科书、问答对以及代码片段等多种形式的数据。
+
+预训练过程分三阶段。
+
+### 2.1 第一阶段（S1）
+
+模型在超过 30 万亿个 token 进行预训练，上下文长度为 4K token。这一阶段为模型提供基本的语言技能和通用知识。
+
+### 2.2 第二阶段（S2）
+
+增加知识密集型数据（如 STEM、编程和推理任务）的比例来改进数据集，随后模型又在额外 5 万亿个 token 上进行了预训练。
+
+### 2.3 最后阶段
+
+使用高质量的长上下文数据将上下文长度扩展到 32K token，确保模型能够有效地处理更长的输入。
+
+![](https://qianwen-res.oss-accelerate-overseas.aliyuncs.com/qwen3-base.jpg)
+
+由于模型架构改进、训练数据增加及更有效训练方法，Qwen3 Dense 基础模型的整体性能与参数更多的Qwen2.5基础模型相当。如Qwen3-1.7B/4B/8B/14B/32B-Base 分别与 Qwen2.5-3B/7B/14B/32B/72B-Base 表现相当。
+
+特别在 STEM、编码和推理领域，Qwen3 Dense 基础模型的表现甚至 ＞ 更大规模的 Qwen2.5 模型。
+
+Qwen3 MoE 基础模型，仅用 10% 激活参数达到与 Qwen2.5 Dense 基础模型相似性能。带来训练和推理成本显著节省。
+
+## 3 后训练
+
+![](https://qianwen-res.oss-accelerate.aliyuncs.com/assets/blog/qwen3/post-training.png)
+
+为开发同时具备思考推理和快速响应能力的混合模型，实施了四阶段的训练流程：
+
+- （1）长思维链冷启动
+- （2）长思维链强化学习
+- （3）思维模式融合
+- （4）通用强化学习
+
+#### 3.1 第一阶段
+
+用多样的的长思维链数据对模型进行了微调，涵盖了数学、代码、逻辑推理和 STEM 问题等多种任务和领域。这一过程旨在为模型配备基本的推理能力。
+
+### 3.2 第二阶段
+
+重点是大规模强化学习，利用基于规则的奖励来增强模型的探索和钻研能力。
+
+### 3.3 第三阶段
+
+在一份包括长思维链数据和常用的指令微调数据的组合数据上对模型进行微调，将非思考模式整合到思考模型中。确保了推理和快速响应能力的无缝结合。
+
+### 3.4 第四阶段
+
+在包括指令遵循、格式遵循和 Agent 能力等在内的 20 多个通用领域的任务上应用了强化学习，以进一步增强模型的通用能力并纠正不良行为。
+
+## 4 实战Qwen3
+
+在不同框架用Qwen3。
+
+注意，必须使用 Python3.11+。
+
+### transformers
+
+在 Hugging Face `transformers` 中使用 Qwen3-30B-A3B 的标准示例：
+
+```python
+from modelscope import AutoModelForCausalLM, AutoTokenizer
+
+model_name = "Qwen/Qwen3-30B-A3B"
+
+# load the tokenizer and the model
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    torch_dtype="auto",
+    device_map="auto"
+)
+
+# prepare the model input
+prompt = "Give me a short introduction to large language model."
+messages = [
+    {"role": "user", "content": prompt}
+]
+text = tokenizer.apply_chat_template(
+    messages,
+    tokenize=False,
+    add_generation_prompt=True,
+    enable_thinking=True # Switch between thinking and non-thinking modes. Default is True.
+)
+model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
+
+# conduct text completion
+generated_ids = model.generate(
+    **model_inputs,
+    max_new_tokens=32768
+)
+output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist() 
+
+# parsing thinking content
+try:
+    # rindex finding 151668 (</think>)
+    index = len(output_ids) - output_ids[::-1].index(151668)
+except ValueError:
+    index = 0
+
+thinking_content = tokenizer.decode(output_ids[:index], skip_special_tokens=True).strip("\n")
+content = tokenizer.decode(output_ids[index:], skip_special_tokens=True).strip("\n")
+
+print("thinking content:", thinking_content)
+print("content:", content)
+```
+
+禁用思考模式，只需修改参数 `enable_thinking` ：
+
+```python
+text = tokenizer.apply_chat_template(
+    messages,
+    tokenize=False,
+    add_generation_prompt=True,
+    enable_thinking=False  # True is the default value for enable_thinking.
+)
+```
+
+对于部署，可用 `sglang>=0.4.6.post1` 或 `vllm>=0.8.4` 来创建一个与 OpenAI API 兼容的 API endpoint：
+
+SGLang：
+
+```shell
+python -m sglang.launch_server --model-path Qwen/Qwen3-30B-A3B --reasoning-parser qwen3
+```
+
+vLLM：
+
+```shell
+vllm serve Qwen/Qwen3-30B-A3B --enable-reasoning --reasoning-parser deepseek_r1
+```
+
+要禁用思考模式，可移除参数 `--reasoning-parser`（以及 `--enable-reasoning`）。
+
+### 本地开发
+
+可运行：
+
+```bash
+ollama run qwen3:30b-a3b
+```
+
+用 ollama 与模型进行交互。也可用 LMStudio 或 llama.cpp 及 ktransformers 等代码库进行本地开发。
+
+### 高级用法
+
+提供一种软切换机制，允许用户在 `enable_thinking=True` 时动态控制模型的行为。可在用户提示或系统消息中添加 `/think` 和 `/no_think` 来逐轮切换模型的思考模式。多轮对话中，模型会遵循最近指令。
+
+多轮对话示例：
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+class QwenChatbot:
+    def __init__(self, model_name="Qwen3-30B-A3B/Qwen3-30B-A3B"):
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModelForCausalLM.from_pretrained(model_name)
+        self.history = []
+
+    def generate_response(self, user_input):
+        messages = self.history + [{"role": "user", "content": user_input}]
+
+        text = self.tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True
+        )
+
+        inputs = self.tokenizer(text, return_tensors="pt")
+        response_ids = self.model.generate(**inputs, max_new_tokens=32768)[0][len(inputs.input_ids[0]):].tolist()
+        response = self.tokenizer.decode(response_ids, skip_special_tokens=True)
+
+        # Update history
+        self.history.append({"role": "user", "content": user_input})
+        self.history.append({"role": "assistant", "content": response})
+
+        return response
+
+# Example Usage
+if __name__ == "__main__":
+    chatbot = QwenChatbot()
+
+    # First input (without /think or /no_think tags, thinking mode is enabled by default)
+    user_input_1 = "How many r's in strawberries?"
+    print(f"User: {user_input_1}")
+    response_1 = chatbot.generate_response(user_input_1)
+    print(f"Bot: {response_1}")
+    print("----------------------")
+
+    # Second input with /no_think
+    user_input_2 = "Then, how many r's in blueberries? /no_think"
+    print(f"User: {user_input_2}")
+    response_2 = chatbot.generate_response(user_input_2)
+    print(f"Bot: {response_2}") 
+    print("----------------------")
+
+    # Third input with /think
+    user_input_3 = "Really? /think"
+    print(f"User: {user_input_3}")
+    response_3 = chatbot.generate_response(user_input_3)
+    print(f"Bot: {response_3}")
+```
+
+### Agent示例
+
+Qwen3 在工具调用能力方面表现出色。推荐 [Qwen-Agent](https://github.com/QwenLM/Qwen-Agent) 充分发挥 Qwen3 的 Agent 能力。Qwen-Agent 内部封装了工具调用模板和工具调用解析器，大大降低了代码复杂性。
+
+要定义可用的工具，您可以使用 MCP 配置文件，使用 Qwen-Agent 内置的工具，或者自行集成其他工具。
+
+安装依赖：
+
+```bash
+qwen_agent、uvx、dateutils
+
+# mac安装 uv 代替 uvx
+# brew install uv
+uv pip install mcp-server-time mcp-server-fetch
+pip install "qwen-agent[code_interpreter]"
+```
+
+
+
+```python
+from qwen_agent.agents import Assistant
+
+# Define LLM
+llm_cfg = {
+    'model': 'Qwen3-30B-A3B',
+
+    # Use the endpoint provided by Alibaba Model Studio:
+    # 'model_type': 'qwen_dashscope',
+    # 'api_key': os.getenv('DASHSCOPE_API_KEY'),
+
+    # Use a custom endpoint compatible with OpenAI API:
+    'model_server': 'http://localhost:8000/v1',  # api_base
+    'api_key': 'EMPTY',
+
+    # Other parameters:
+    # 'generate_cfg': {
+    #         # Add: When the response content is `<think>this is the thought</think>this is the answer;
+    #         # Do not add: When the response has been separated by reasoning_content and content.
+    #         'thought_in_content': True,
+    #     },
+}
+
+# Define Tools
+tools = [
+    {'mcpServers': {  # You can specify the MCP configuration file
+            'time': {
+                'command': 'uvx',
+                'args': ['mcp-server-time', '--local-timezone=Asia/Shanghai']
+            },
+            "fetch": {
+                "command": "uvx",
+                "args": ["mcp-server-fetch"]
+            }
+        }
+    },
+  'code_interpreter',  # Built-in tools
+]
+
+# Define Agent
+bot = Assistant(llm=llm_cfg, function_list=tools)
+
+# Streaming generation
+messages = [{'role': 'user', 'content': 'https://qwenlm.github.io/blog/ Introduce the latest developments of Qwen'}]
+for responses in bot.run(messages=messages):
+    pass
+print(responses)
+```
+
+mac 上运行代码改造：
+
+```java
+from qwen_agent.agents import Assistant
+
+llm_cfg = {
+    'model': 'qwen3-32b-mlx',
+    'model_server': 'http://127.0.0.1:1234/v1',  # api_base
+    'api_key': 'lm-studio',
+
+}
+
+tools = [
+    {'mcpServers': {
+            'time': {
+                'command': 'uv',
+                'args': ['run', 'mcp-server-time', '--local-timezone=Asia/Shanghai']
+            },
+            "fetch": {
+                "command": "uv",
+                "args": ["run", "mcp-server-fetch"]
+            }
+        }
+    },
+  'code_interpreter',
+]
+
+bot = Assistant(llm=llm_cfg, function_list=tools)
+
+messages = [{'role': 'user', 'content': 'https://qwenlm.github.io/blog/ Introduce the latest developments of Qwen'}]
+for responses in bot.run(messages=messages):
+    pass
+print(responses)
+```
+
+响应：
+
+```json
+[
+    {
+        "role": "assistant",
+        "content": "<think>\nOkay, let's see. The user wants me to introduce the latest developments of Qwen based on the provided blog URL. First, I need to fetch the content from that URL. The function 'fetch-fetch' is available for this. I'll use it to get the blog's content.\n\nWait, the URL is https://qwenlm.github.io/blog/, so I'll input that into the fetch function. The parameters required are 'url', and optionally 'max_length', 'start_index', and 'raw'. Since the user probably wants a summary, I'll set 'max_length' to 5000 to get enough content without being too long. The default for 'raw' is false, which means it'll simplify the HTML, so that's good. \n\nOnce I fetch the content, I need to process it. The blog might have sections about updates, new features, performance improvements, etc. I'll need to parse the markdown content to extract key points. But since the fetch function returns the content as markdown, I can then summarize that.\n\nAfter fetching, I'll check the response. If it's successful, I'll read through the markdown to find recent posts or sections mentioning Qwen's latest developments. Common topics might include model architecture changes, training data updates, new capabilities like code writing or multi-language support, performance benchmarks, and use cases.\n\nI should structure the answer by highlighting major updates, maybe in bullet points. Also, note any significant improvements or new features mentioned in the blog. If there are specific dates or version numbers, include those for clarity. Make sure to mention if the blog talks about open-source releases or integrations with other tools.\n\nI should be careful not to include outdated information and focus on the latest developments as of the blog's publication date. If there are multiple posts, prioritize the most recent ones. Also, check for any technical details that might be relevant to users interested in Qwen's advancements.\n</think>\n\n",
+        "reasoning_content": ""
+    },
+    {
+        "role": "assistant",
+        "content": "",
+        "reasoning_content": "",
+        "function_call": {
+            "name": "fetch-fetch",
+            "arguments": "{\"url\":\"https://qwenlm.github.io/blog/\", \"max_length\":5000}"
+        }
+    },
+    {
+        "role": "function",
+        "content": "Contents of https://qwenlm.github.io/blog/:\nQWEN CHAT GitHub Hugging Face ModelScope Kaggle DEMO DISCORD\nIntroduction Today, we are excited to announce the release of Qwen3, the latest addition to the Qwen family of large language models. Our flagship model, Qwen3-235B-A22B, achieves competitive results in benchmark evaluations of coding, math, general capabilities, etc., when compared to other top-tier models such as DeepSeek-R1, o1, o3-mini, Grok-3, and Gemini-2.5-Pro. Additionally, the small MoE model, Qwen3-30B-A3B, outcompetes QwQ-32B with 10 times of activated parameters, and even a tiny model like Qwen3-4B can rival the performance of Qwen2....\n\nQWEN CHAT GITHUB HUGGING FACE MODELSCOPE DISCORD\nIntroduction Last December, we launched QVQ-72B-Preview as an exploratory model, but it had many issues. Today, we are officially releasing the first version of QVQ-Max, our visual reasoning model. This model can not only “understand” the content in images and videos but also analyze and reason with this information to provide solutions. From math problems to everyday questions, from programming code to artistic creation, QVQ-Max has demonstrated impressive capabilities....\n\nQWEN CHAT HUGGING FACE MODELSCOPE DASHSCOPE GITHUB PAPER DEMO DISCORD\nWe release Qwen2.5-Omni, the new flagship end-to-end multimodal model in the Qwen series. Designed for comprehensive multimodal perception, it seamlessly processes diverse inputs including text, images, audio, and video, while delivering real-time streaming responses through both text generation and natural speech synthesis. To try the latest model, feel free to visit Qwen Chat and choose Qwen2.5-Omni-7B. The model is now openly available on Hugging Face, ModelScope, DashScope,and GitHub, with technical documentation available in our Paper....\n\nQWEN CHAT GITHUB HUGGING FACE MODELSCOPE DISCORD\nIntroduction At the end of January this year, we launched the Qwen2.5-VL series of models, which received widespread attention and positive feedback from the community. Building on the Qwen2.5-VL series, we continued to optimize the model using reinforcement learning and open-sourced the new VL model with the beloved 32B parameter scale under the Apache 2.0 license — Qwen2.5-VL-32B-Instruct. Compared to the previously released Qwen2....\n\nQWEN CHAT Hugging Face ModelScope DEMO DISCORD\nScaling Reinforcement Learning (RL) has the potential to enhance model performance beyond conventional pretraining and post-training methods. Recent studies have demonstrated that RL can significantly improve the reasoning capabilities of models. For instance, DeepSeek R1 has achieved state-of-the-art performance by integrating cold-start data and multi-stage training, enabling deep thinking and complex reasoning.\nOur research explores the scalability of Reinforcement Learning (RL) and its impact on enhancing the intelligence of large language models....",
+        "reasoning_content": "",
+        "name": "fetch-fetch"
+    },
+    {
+        "role": "assistant",
+        "content": "<think>\nOkay, let me try to figure out how to approach this. The user asked about the latest developments of Qwen, and I used the fetch tool to get the blog content. Now I need to parse the response from the tool and summarize the key points.\n\nFirst, looking at the fetched content, there are several sections. The first one mentions Qwen3 with a 235B-A22B model, which is the flagship. It says it's competitive with other top models in coding, math, and general capabilities. There's also a smaller MoE model, Qwen3-30B-A3B, and even a 4B version.\n\nNext section talks about QVQ-Max, the visual reasoning model. It can understand images and videos, analyze them, and provide solutions for math problems to artistic creation. This is an official release after a preview version with issues.\n\nThen there's Qwen2.5-Omni, the end-to-end multimodal model that handles text, images, audio, video, and does real-time streaming with speech synthesis. Available on platforms like Hugging Face.\n\nAnother part is about Qwen2.5-VL-32B-Instruct, optimized with reinforcement learning and open-sourced under Apache 2.0 license.\n\nLastly, there's a mention of Scaling Reinforcement Learning (RL) in their research to improve model performance beyond pretraining.\n\nI need to structure these points clearly. Start with the latest models released, their features, performance compared to others, multimodal capabilities, open-source availability, and research advancements. Make sure to highlight key numbers like 235B parameters, 4B for smaller models, and the platforms where they're available. Also note the open-source licenses and any notable achievements like outperforming other models.\n</think>\n\nThe latest developments in Qwen, as outlined on the official blog, include:\n\n1. **Qwen3 Flagship Models**:\n   - Launched **Qwen3-235B-A22B**, a 235-billion-parameter model with competitive performance in coding, math, and general knowledge compared to top models like DeepSeek-R1, o1, Grok-3, and Gemini-2.5-Pro.\n   - Introduced a **small MoE variant (Qwen3-30B-A3B)** with 30B parameters and **Qwen3-4B**, a compact model that rivals the performance of Qwen2 while maintaining efficiency.\n\n2. **Visual Reasoning with QVQ-Max**:\n   - Released the first stable vision-language (VL) model **QVQ-Max**, which can interpret images/videos and perform reasoning for tasks ranging from math problems to creative applications. This follows the preview QVQ-72B-Preview but with improved stability and capabilities.\n\n3. **Multimodal Model Qwen2.5-Omni**:\n   - Launched **Qwen2.5-Omni-7B**, an end-to-end multimodal model that processes text, images, audio, and video with real-time streaming responses (text + speech synthesis). Available for public use on Hugging Face, ModelScope, and GitHub.\n\n4. **Enhanced VL Model Qwen2.5-VL-32B-Instruct**:\n   - Optimized the **Qwen2.5-VL series** using reinforcement learning (RL), open-sourced under Apache 2.0 license, and expanded to a 32B parameter scale for improved vision-language reasoning.\n\n5. **Research in Scaling Reinforcement Learning**:\n   - Explored RL to enhance model intelligence beyond traditional pretraining, with techniques inspired by DeepSeek R1’s success in multi-stage training for complex reasoning tasks.\n\nAll models are accessible via platforms like Hugging Face, ModelScope, and GitHub. Notably, Qwen3-4B and the open-sourced VL models prioritize accessibility without compromising performance.",
+        "reasoning_content": ""
+    }
+]
+```
+
+## 5 Qwen的朋友们
+
+欢迎更多新朋友加入社区，一起变得更好！
+
+![](https://qianwen-res.oss-accelerate-overseas.aliyuncs.com/qwen3-logo.png)
+
+## 6 未来发展
+
+Qwen3代表我们通往通用人工智能（AGI）和超级人工智能（ASI）旅程中的一个重要里程碑。通过扩大预训练和强化学习的规模，我们实现了更高层次的智能。我们无缝集成了思考模式与非思考模式，为用户提供了灵活控制思考预算的能力。此外，我们还扩展了对多种语言的支持，帮助全球更多用户。
+
+计划从多个维度提升我们的模型。这包括优化模型架构和训练方法，以实现几个关键目标：扩展数据规模、增加模型大小、延长上下文长度、拓宽模态范围，并利用环境反馈推进强化学习以进行长周期推理。
+
+我们正从专注于训练模型的时代过渡到以训练 Agent 为中心的时代。下一代迭代将为大家的工作和生活带来有意义的进步。
\ No newline at end of file
diff --git "a/docs/md/AI/llm/01-Prompt\347\275\221\347\253\231.md" "b/docs/md/AI/prompt/01-Prompt\347\275\221\347\253\231.md"
similarity index 100%
rename from "docs/md/AI/llm/01-Prompt\347\275\221\347\253\231.md"
rename to "docs/md/AI/prompt/01-Prompt\347\275\221\347\253\231.md"
diff --git "a/docs/md/AI/llm/02-\345\270\270\347\224\250Prompt.md" "b/docs/md/AI/prompt/02-\345\270\270\347\224\250Prompt.md"
similarity index 100%
rename from "docs/md/AI/llm/02-\345\270\270\347\224\250Prompt.md"
rename to "docs/md/AI/prompt/02-\345\270\270\347\224\250Prompt.md"
diff --git a/docs/md/distdb/bank-distributed-database-selection.md b/docs/md/distdb/bank-distributed-database-selection.md
new file mode 100644
index 000000000..28dbeec63
--- /dev/null
+++ b/docs/md/distdb/bank-distributed-database-selection.md
@@ -0,0 +1,166 @@
+# 银行分布式数据库选型
+
+## 0 前言
+
+数据库稳定性和可靠性是立身之本。稳定性要求最严苛在金融业，尤其银行业。仅经金融场景考验的数据库才能扬名，让其他行业用户放心。因此厂商都号称“金融级分布式数据库”。
+
+分布式数据库应用场景主要特征海量并发，业务规模越大，分布式数据库需求越迫切。
+
+## 1 工商银行（分布式中间件）
+
+工行之前主Oracle和DB2，过去20年银行基本就这二选一。都是单体数据库，只能垂直扩展，碰到技术天花板后就限制业务发展。工行面对这问题选择是，从单体数据库向MySQL为基础的分库分表方案转型。
+
+![](https://p.ipic.vip/0y78ln.png)
+
+### 为啥工行没选择分布式数据库？
+
+主因产品成熟度。工行架构改造在2018年大规模落地，而调研和试点工作则在更早2016-2017年。这时，商用NewSQL数据库推出不久，而金融场景严苛，注定银行不做第一个吃螃蟹。另一种PGXC风格的分布式数据库也正待破茧而出，反而是它的前身，“分布式中间件+开源单体数据库”组合更普及。
+
+所以，对当时工行，产品架构无选择余地，能做的就是选择产品。后来选择DBLE + MySQL组合：
+
+- MySQL普及度够高
+- DBLE则因它基于MyCat研发，号称“增强版MyCat”，由于MyCat已有较多应用案例，给DBLE加分
+
+虽如今这方案平淡无奇。但正这稳妥或者说保守，最大程度规避风险，也坚定了工行从主机下移应用系统的决心。从后来MySQL上千节点使用规模看，这方案更大意义在于，使工行逐步脱离对IBM主机和Oracle数据库依赖。分布式数据库尝试只是这个大目标下的副产品。
+
+相比OLTP技术应用平淡，工行在OLAP技术创新强。基本同期，工行联合华为成功研发GaussDB 200，并生产用。这款数据库对标Teradata和Greenplum等国外OLAP数据库。工行案例加持，不少银行计划或正用这款产品替换Teradata。
+
+## 2 邮储银行（单元化）
+
+零售用户在2019年已超6亿，使其也早早地就开始探讨分布式数据库的使用。
+
+也没选分布式数据库。核心业务系统改造方案更接近单元化架构，所以分布式中间件都没用。设计思路是将原商业数据库拆分成若干个小单体数据库，分别设置对应的应用实例。单体数据库选择PostgreSQL，这在银行业相对较少使用。
+
+单元化方案从应用整体看也是一种分布式架构，通过应用层重构弱化对数据库性能和稳定性等要求。若两种方式都能解决问题，咋在单元化和分布式数据库之间选？
+
+从成本上看，系统的单元化改造要付出巨大的代价，是一个推倒重建的过程，远高于过渡到分布式数据库的代价。我认为，邮储之所以会选择这个方式，可能有两个原因：
+
+1. 对数据库的技术把控能力。毕竟分布式数据库带来的技术挑战不容忽视。
+2. 核心系统本身重构的必要性。如果应用系统的分布式改造势在必行，那么两个方案的目标都截然不同，成本的比较也就无从谈起了。
+
+同样，民生银行也是在核心系统改造的背景下，完成了向分布式架构的升级。在民生银行的一份宣传材料中对分布式技术平台做了整体描述，其中有两段是和数据库相关，是这么写的“通过分库分表和读写分离实现分布式数据访问功能；基于可靠消息的最终一致性和基于冲正模型的反向处理实现分布式事务功能”。
+
+![](https://p.ipic.vip/pii5fh.png)
+
+可见民生银行也选择了与邮储银行大致相同的路线，弱化了分布式数据库的作用，更加强调整体架构改造，在应用系统层面做了更多的工作。
+
+好了，刚才我们说到的三家银行都采用了迂回的方案，下面终于要用到分布式数据库了。
+
+## 3 交通银行（研发NewSQL）
+
+交通银行的分布式数据库之路走得比较特别，它采用联合高校研发的方式，与华东师范大学和西北工业大学共同研发了分布式数据库CBase。
+
+CBase研发开始于2014年，在分布式数据库中算是非常早的了，但它的整体架构风格非常接近于NewSQL。不同于前几家银行，CBase并不是某个重要业务系统的附属品，已经有点技术驱动的味道。
+
+它最先用于历史库系统的数据存储，而后逐步实现了复杂SQL语句处理和高并发事务处理能力，在供应链、贷记卡授权和网联支付等系统使用。
+
+![](https://p.ipic.vip/drfo8x.png)
+
+CBase主要工作负载放在三类节点：
+
+- 数据存储节点与NewSQL风格完全一致
+- SQL处理节点和事务处理节点，就是计算节点的细化
+
+CBase也基于Raft协议设计和实现了轻量级分布式选举协议，分布式事务同样在2PC上改进。
+
+这款数据库主要在交通银行内用。但CBase开发团队在2019年发表《[分布式数据库在金融应用场景中的探索与实践](http://www.infocomm-journal.com/bdr/CN/article/downloadArticleFile.do?attachType=PDF&id=168111)》（刘雷 等(2019)），介绍CBase部分设计。
+
+交通银行研发分布式数据库在银行业是很有代表性的，因为之前还很少有在基础软件上进行大规模投入的先例。同样在2014年，中信银行也走上联合研发道路。
+
+## 4 中信银行（研发PGXC）
+
+GoldenDB是中信银行与中兴通讯联合研发产品，目前GoldenDB主要用户也是中信银行。中信银行核心业务系统在2020年5月正式上线切换到GoldenDB。这之前，基于GoldenDB的信用卡新核心系统已经在2019年10月投产运行。这两个重要系统的运行，使中信银行无可争议地成为分布式数据库应用最为深入的一家银行。核心业务系统是银行业务的心脏，它的稳定运行无疑为其他银行树立了标杆，客观上也加快分布式数据库的普及速度。
+
+GoldenDB和CBase有大致相同的发展路径，从产品研发到试点应用，只不过中信银行的步子更快些。当然，这并不是说交行研发人员的能力不行，因为这个速度上的差别确实有架构上的因素。GoldenDB是PGXC风格的分布式数据库，遇到的技术挑战更小；当然NewSQL架构上的优势，也让我们对CBase的未来充满期待。
+
+Q：同样核心系统改造，为啥中信银行就用分布式数据库？
+
+A：项目目标不同。中信的目标就是完成AS400小机下移，将应用程序翻写到开放平台，但是对应用架构本身并没有改造诉求。所以，数据库层面的平滑过渡就有很大的优势，编码逻辑改动小，测试成本低，最重要的是不会因为技术原因变动业务流程，大大降低项目实施难度。
+
+## 5 北京银行（NewSQL）
+
+北京银行是城市商业银行中的佼佼者，但相对于前几家银行，在资产规模和用户数量上有较大的差距。北京银行从2018年开始，先后在网联支付系统和网贷系统中应用了TiDB。
+
+事实上，很多比北京银行规模更小的城市商业银行，比如南京银行（OceanBase）、张家港银行（TDSQL）都已经上线了分布式数据库。表面上，我们似乎很难捕捉到他们替换数据库的动因。从业务压力的角度，业务量通常没有达到海量并发级别；同时城商行通常也不涉及“主机下移”带来可用性下降问题。
+
+他们为什么要做出这个选择呢？
+
+### 国产化的诉求
+
+由于各种原因，继续依赖Oracle这样的国外商业产品，很可能让银行将面临更大的风险。而对于小型银行来说，使用开源数据库还是分布式数据库，在成本上可能差异并不大。
+
+随着国内厂商加大技术投入，隐约有一种趋势，就是分布式数据库正在逐步成为国产数据库的代名词。那些原本深耕单体数据库技术的厂商，比如达梦、人大金仓，也在朝着分布式架构转型。
+
+所以，选择分布式数据库也就满足了国产化的诉求。
+
+### 实际收益
+
+由于小型银行的数据量并不大，上线分布式数据库后集群的节点规模没有大幅增长，对运维的冲击也相对小些。此外，利用分布式数据库的多租户特性，转变成类似Aurora使用方式，还能降低数据库实例管理的复杂度。所以，使用分布式数据库也是有一些实际收益的。
+
+### 技术潮流
+
+一旦技术趋势形成，就会无形影响人们选择。就像时尚潮流那样，同等价位，更愿意流行款式。如今的分布式架构转型就是这样的潮流，微服务架构、分布式数据库甚至容器云都是这个大潮下的浪花。
+
+风险可控前提下，受技术潮流影响，会有更多小型银行选择分布式数据库。
+
+## 6 光大银行（NewSQL & 分库分表）
+
+双路线策略，同时用NewSQL和分库分表。
+
+云缴费系统用自研分库分表方案。缴费业务量非常大，今天支付宝、微信甚至很多银行缴费服务，后台都要调用光大云缴费系统。截至2019年，云缴费系统累计用户5.49亿。
+
+其实，缴费业务是非常互联网化的业务，就是银行提供服务对接用户和缴费企业，所以它的业务模型比较简单和统一。这也意味着，它对分布式事务这样的复杂操作没有那么强烈的诉求。最后，用分库方案就很好地解决了海量业务的问题。
+
+光大在另一个系统，新一代财富管理平台使用了NewSQL数据库，也就是TiDB。这个系统是理财业务的全流程管理平台，业务量相对缴费要小很多，但业务要更复杂，而且在联机和批量方面都有计算需求。
+
+这个架构选择更多是面向未来，因为理财业务是光大银行重点发力的业务，对未来业务量的增长还是有很大预期的。同时，我想，伴随着NewSQL技术的发展，保持团队对新技术的感知和掌握，应该也是一个重要的原因。
+
+## 7 选型
+
+### 产品选型要服从于项目整体目标
+
+局部最优的选择拼装在一起未必是全局最优的方案。如果你的目标是要对整个应用系统做彻底重构，例如把单体架构改为微服务架构，那么要解决原来某些局部的问题，可能会有更多选择。这时候要从整体上评估技术复杂度、工程实施等因素，而不是仅选择局部最合理的方案。
+
+### 先进的产品可能会延长项目交付时间
+
+最先进的产品不一定是完美的选择。尤其是有进度要求时，往往会选择更稳妥、快速的办法。但是，这本质上是在短期利益和长期利益之间做权衡，没有绝对的对错，搞清楚你想要的是什么就行。
+
+### 当产品选型可能导致业务流程变更时，请慎重对待
+
+对任何项目来说，协作范围的扩大一定会增加实施难度。当技术部门对业务流程变更没有决定权时，我认为这是多数情况，通过技术手段避免这种变更往往是更好的选择。
+
+### 产品选型中的非技术因素
+
+正视非技术因素，评估它的合理性不是技术团队的职责。
+
+### 评估技术潮流对选型影响
+
+跟随潮流并不是人云亦云，你必须能够独立对技术发展趋势做出研判。太过小众的技术往往不能与工程化要求兼容。但同时，保持对新技术的敏感度和掌控力，也是非常必要的。
+
+## 8 总结
+
+1. 工商银行在主机应用下移的过程中，采用分布式中间件加MySQL的方式替换了原有的单体数据库。这个选择，一方面受制于当时分布式数据库的成熟度，另外这个方案的主要意义是大量使用了MySQL数据库，降低对主机和Oracle数据库的依赖，而分布式方案是一个副产品。
+2. 邮储银行和民生银行是在新一代核心系统建设的背景下进行分布式架构改造，所以他们有更多的项目目标，也能够承受更大的改造成本，这样分布式数据库能够平滑过渡、减少应用改造的优势也就不那么重要了。最终，两家银行都采用了类似单元化的架构，在应用层处理分布式事务等工作。
+3. 交通银行和中信银行都选择了自研方式。中信银行目前已经在核心业务系统上线GoldeDB，能够更快上线的一个原因就是PGXC的架构复用了单体数据库，遇到的技术挑战更少。
+4. 北京银行和很多规模更小的城商行也在陆续上线分布式数据库。我认为他们的选择因素有三个，国产化诉求、实际收益和技术潮流。我预测，未来还有更多的小型银行将上线分布式数据库。
+5. 光大银行采用了双路线策略，同时采用分库分表方案和NewSQL。这一方面因为不同系统的业务特点不同，另一方面也是要跟进NewSQL技术发展，保持对新技术的感知和应用能力。
+
+相对于互联网行业，金融场景的苛刻要求，让银行更倾向于保守的策略，但是不难发现，总会有一些企业更具开创精神。我相信，随着分布式数据库的日益成熟，技术红利会驱使更多企业做出积极的尝试。事实上，就在我们课程更新的过程中，2020年9月，工商银行宣布将在对公（法人）理财系统的主机下移方案中采用OceanBase数据库。
+
+![](https://p.ipic.vip/z7cb1v.png)
+
+## FAQ
+
+刘雷 等: [*分布式数据库在金融应用场景中的探索与实践*](http://www.infocomm-journal.com/bdr/CN/article/downloadArticleFile.do?attachType=PDF&id=168111).
+
+很多项目本质体现数据一致性甚至分布式事务，对账处理，内部账户使用，都体现性能和数据一致性取舍。带来数据分析和监管问题。尤其涉及大的三方商户、客户，又是复杂业务流程时，业务最本质还是数据一致性的维护，还是会回归到分布式事务或长事务，没有成熟底层中间件，在讨论方案时总是深入甚至陷入到异常处理的细节大海中，这循环一再重复。
+
+Q：“此外，利用分布式数据库的多租户特性，转变成类似 Aurora 使用方式，还能降低数据库实例管理的复杂度。”。多租户特性啥意思？它咋降低数据库实例管理复杂度？
+
+A：在一个集群支持多个业务系统，每个业务系统作为一个租户，这样集群管理工作会简化。
+
+Q：它对分布式事务这复杂操作没那么强烈诉求。最后分库方案就很好解决海量业务问题。
+
+意思是说，分库分表方案在事务模型比较简单的情况下，比Newsql更有竞争力吗？从技术角度为什么是这样呢？
+
+A：如果没有分布式事务，也没有跨分片查询，分库分表更简单。
\ No newline at end of file
diff --git a/docs/md/python/Installing packages into 'Python 3.9' requires administrator privileges.md b/docs/md/python/Installing packages into 'Python 3.9' requires administrator privileges.md
new file mode 100644
index 000000000..27573889a
--- /dev/null
+++ b/docs/md/python/Installing packages into 'Python 3.9' requires administrator privileges.md	
@@ -0,0 +1,104 @@
+# Installing packages into 'Python 3.9' requires administrator privileges
+
+## 0 报错信息
+
+```bash
+Installing packages into 'Python 3.9' requires administrator privileges.
+
+Configure a per-project virtual environment as your project interpreter
+to avoid installing packages to a protected area of the file system.
+```
+
+**权限问题**，通常发生在你试图在全局 Python 环境中安装包（如系统自带的 Python 或通过某些 IDE 默认配置使用了系统环境），而你的用户没有管理员权限或该路径受保护。
+
+## 1 原因分析
+
+### 尝试安装包到系统级 Python 环境
+
+如 `/usr/bin/python3.9`（Linux）或 `C:\Program Files\Python39`（Windows），这些目录是只读或需要管理员权限才能写入。
+
+### IDE（如 PyCharm、VS Code）默认使用了全局解释器
+
+导致你在项目中运行 pip install 时，会尝试将包安装到系统路径下。
+
+## 2 解决方案
+
+使用虚拟环境（Virtual Environment）。
+
+### 2.1 为项目创建并使用虚拟环境
+
+#### 2.1.1 方法一：使用 `venv` 创建虚拟环境（推荐）
+
+```bash
+# 在项目根目录下创建虚拟环境
+python3.9 -m venv venv
+```
+
+#### 2.1.2 方法二：使用 `virtualenv`（功能更强大）
+
+```bash
+pip install virtualenv
+virtualenv venv
+```
+
+## 3 激活虚拟环境
+
+| OS          | 激活命令                   |
+| ----------- | -------------------------- |
+| Windows     | `venv\Scripts\activate`    |
+| macOS/Linux | `source venv/bin/activate` |
+
+激活后，终端提示符一般会变成这样：
+
+```bash
+(venv) $
+```
+
+再安装包：
+
+```bash
+pip install transformers
+```
+
+所有包都会安装到当前项目的 `venv/` 目录中，无需管理员权限。
+
+## 4 配置 IDE 虚拟环境
+
+### 4.1 PyCharm设置项目解释器为虚拟环境
+
+打开 PyCharm → File → Settings (Preferences on Mac)，找到 `Project: <your_project_name>` → Python Interpreter，点击Add Interpreter。选择：
+
+#### Generate new
+
+![](https://p.ipic.vip/0igfw6.png)
+
+
+
+![](https://p.ipic.vip/frn7in.png)
+
+#### Existing environment
+
+1. 浏览到你的虚拟环境目录，例如：
+   - Windows: `venv\Scripts\python.exe`
+   - macOS/Linux: `venv/bin/python`
+2. 确认保存即可
+
+### 4.2 VS Code设置解释器
+
+1. 打开命令面板（Ctrl + Shift + P）
+2. 输入并选择：`Python: Select Interpreter`
+3. 选择你创建的虚拟环境（如 `./venv/bin/python`）
+
+## 5 建议
+
+- **不用全局 Python 安装包**，除非你知道自己在做啥
+- **每次新建项目都创建虚拟环境**
+- 可用 `which python` / `where python` 查看当前用的 Python 路径
+
+## 6 总结
+
+| 问题                         | 原因                     | 解决方案                        |
+| ---------------------------- | ------------------------ | ------------------------------- |
+| 安装失败，提示需要管理员权限 | 正在向系统 Python 安装包 | 使用虚拟环境（venv/virtualenv） |
+| 如何避免此类问题             | 全局环境权限限制         | 项目级虚拟环境隔离依赖          |
+| IDE 中如何解决               | 默认使用系统解释器       | 修改项目解释器为虚拟环境路径    |
\ No newline at end of file

From 372f998987af0e119db35cbb47f8c67388c6dd79 Mon Sep 17 00:00:00 2001
From: JavaEdge <sss2855845850@gmail.com>
Date: Fri, 6 Jun 2025 00:01:14 +0800
Subject: [PATCH 18/20] docs:update

---
 .vscode/settings.json                         |   3 +-
 docs/.vuepress/config.js                      |  57 +-
 ...on-tool-to-eliminate-llm-hallucinations.md | 154 -----
 ...40\345\244\247\346\250\241\345\236\213.md" | 134 ++--
 ...-of-rag-result-retrieval-and-reordering.md |  87 +--
 .../ai-agents-dont-security-nightmare.md      |  79 +++
 docs/md/AI/agent/improve-quality-gen-ai.md    | 220 ++++++
 docs/md/AI/agent/introducing-codex.md         | 157 +++++
 docs/md/AI/amazon-strands-agents-sdk.md       |  57 ++
 ...orkflow-processing-with-parallel-branch.md | 115 ++++
 ...workflow-resilience-with-error-handling.md |  61 ++
 docs/md/AI/llm/claude-4.md                    | 162 +++++
 ...ent-and-zapier-mcp-unlock-ai-automation.md | 179 +++++
 ...mented-search-unlock-ai-driven-insights.md | 146 ++++
 ...1-0-building-a-vibrant-plugin-ecosystem.md | 107 +++
 ...sation-variables-and-variable-assigners.md |  64 ++
 ...-child-retrieval-for-enhanced-knowledge.md |  92 +++
 ...on-tool-to-eliminate-llm-hallucinations.md | 317 +++++++++
 ...sage-queues-more-than-app-communication.md | 175 +++++
 docs/md/design/flyweight-pattern.md           | 633 ++++++++++++++++++
 .../building-product-search-system-with-es.md | 254 +++++++
 ...runtime-data-areas-from-pc-to-metaspace.md | 525 +++++++++++++++
 ...-examples_boost-concurrency-performance.md | 124 ++++
 ...-netty-to-handle-large-data-efficiently.md | 277 ++++++++
 ...-0-enhances-vector-database-performance.md |  47 ++
 ...able-scenarios-for-reactive-programming.md | 115 ++--
 ...amming-high-performance-full-stack-apps.md | 113 ++++
 docs/md/redis/redis-agpl-license.md           |  27 +
 ...onfiguration-to-drl-and-decision-tables.md | 241 +++++++
 docs/md/sentinel/basic-api-resource-rule.md   | 431 ++++++++++++
 docs/md/sentinel/origin-authority-control.md  | 106 +++
 ...y-to-custom-flow-control-and-monitoring.md | 143 ++++
 ...52\345\244\204\347\220\206\345\231\250.md" | 133 ----
 .../SpringMVC-AsyncHandlerInterceptor.md      |   0
 .../md/spring/SpringMVC-HandlerInterceptor.md | 167 +++++
 ...lve-spring-boot-package-scanning-issues.md | 146 ++++
 ...or-injection-dependencies-and-ambiguity.md | 189 ++++++
 ...-js-experience-the-charm-of-data-driven.md | 388 +++++++++++
 ...jax-requests-to-api-proxy-configuration.md | 145 ++++
 39 files changed, 6135 insertions(+), 435 deletions(-)
 delete mode 100644 docs/md/AI/00-rag-introduction-tool-to-eliminate-llm-hallucinations.md
 create mode 100644 docs/md/AI/agent/ai-agents-dont-security-nightmare.md
 create mode 100644 docs/md/AI/agent/improve-quality-gen-ai.md
 create mode 100644 docs/md/AI/agent/introducing-codex.md
 create mode 100644 docs/md/AI/amazon-strands-agents-sdk.md
 create mode 100644 docs/md/AI/llm/accelerating-workflow-processing-with-parallel-branch.md
 create mode 100644 docs/md/AI/llm/boost-ai-workflow-resilience-with-error-handling.md
 create mode 100644 docs/md/AI/llm/claude-4.md
 create mode 100644 docs/md/AI/llm/dify-agent-and-zapier-mcp-unlock-ai-automation.md
 create mode 100644 docs/md/AI/llm/dify-deep-research-workflow-farewell-to-fragmented-search-unlock-ai-driven-insights.md
 create mode 100644 docs/md/AI/llm/dify-v1-0-building-a-vibrant-plugin-ecosystem.md
 create mode 100644 docs/md/AI/llm/enhancing-llm-memory-with-conversation-variables-and-variable-assigners.md
 create mode 100644 docs/md/AI/llm/introducing-parent-child-retrieval-for-enhanced-knowledge.md
 create mode 100644 docs/md/AI/rag-introduction-tool-to-eliminate-llm-hallucinations.md
 create mode 100644 docs/md/RocketMQ/message-queues-more-than-app-communication.md
 create mode 100644 docs/md/design/flyweight-pattern.md
 create mode 100644 docs/md/es/building-product-search-system-with-es.md
 create mode 100644 docs/md/jvm/deep-dive-into-jvm-runtime-data-areas-from-pc-to-metaspace.md
 create mode 100644 docs/md/netty/java-lock-optimization-practice-netty-examples_boost-concurrency-performance.md
 create mode 100644 docs/md/netty/use-netty-to-handle-large-data-efficiently.md
 create mode 100644 docs/md/opensearch/opensearch-3-0-enhances-vector-database-performance.md
 rename "docs/md/reactive/\345\223\215\345\272\224\345\274\217\347\274\226\347\250\213\347\232\204\351\200\202\347\224\250\345\234\272\346\231\257.md" => docs/md/reactive/applicable-scenarios-for-reactive-programming.md (54%)
 create mode 100644 docs/md/reactive/spring-5-reactive-programming-high-performance-full-stack-apps.md
 create mode 100644 docs/md/redis/redis-agpl-license.md
 create mode 100644 docs/md/rules-engine/drools/drools-core-guide-configuration-to-drl-and-decision-tables.md
 create mode 100644 docs/md/sentinel/basic-api-resource-rule.md
 create mode 100644 docs/md/sentinel/origin-authority-control.md
 create mode 100644 docs/md/sentinel/spring-boot-integration-with-sentinel-practical-tutorial-from-dependency-to-custom-flow-control-and-monitoring.md
 delete mode 100644 "docs/md/spring/03-SpringMVC\346\213\246\346\210\252\345\244\204\347\220\206\345\231\250.md"
 rename "docs/md/spring/01-SpringMVC\347\232\204AsyncHandlerInterceptor\345\274\202\346\255\245\347\232\204\345\244\204\347\220\206\345\231\250\346\213\246\346\210\252\345\231\250.md" => docs/md/spring/SpringMVC-AsyncHandlerInterceptor.md (100%)
 create mode 100644 docs/md/spring/SpringMVC-HandlerInterceptor.md
 create mode 100644 docs/md/spring/farewell-bean-not-found-easily-solve-spring-boot-package-scanning-issues.md
 create mode 100644 docs/md/spring/why-spring-bean-difficult-birth-overcome-constructor-injection-dependencies-and-ambiguity.md
 create mode 100644 docs/md/vue/goodbye-jquery-thinking-create-checklist-apps-with-vue-js-experience-the-charm-of-data-driven.md
 create mode 100644 docs/md/vue/vue-js-vs-axios-practical-guide-from-ajax-requests-to-api-proxy-configuration.md

diff --git a/.vscode/settings.json b/.vscode/settings.json
index 3f154a560..ac73ba967 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -9,5 +9,6 @@
         "Servlet",
         "springframework"
     ],
-    "Codegeex.RepoIndex": true
+    "Codegeex.RepoIndex": true,
+    "files.autoSave": "afterDelay"
 }
\ No newline at end of file
diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index 480ba8c37..28e2fefb9 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -291,7 +291,7 @@ module.exports = {
                         text: 'Netty',
                         items: [{
                             text: 'Netty基础',
-                            link: '/md/netty/Netty基本组件.md'
+                            link: '/md/netty/netty-basic-components.md'
                         },
 
                         {
@@ -456,6 +456,11 @@ module.exports = {
                             text: 'Seata',
                             link: '/md/seata/01-Seata客户端依赖坐标引入与踩坑排雷.md'
                         },
+
+                        {
+                            text: 'Sentinel',
+                            link: '/md/sentinel/spring-boot-integration-with-sentinel-practical-tutorial-from-dependency-to-custom-flow-control-and-monitoring.md'
+                        },
                         ]
                     },
 
@@ -1273,6 +1278,7 @@ module.exports = {
                             "JVM专栏概述",
                             "01-JVM虚拟机-上篇",
                             "02-JVM虚拟机-下篇",
+                            "deep-dive-into-jvm-runtime-data-areas-from-pc-to-metaspace",
                             "00-JDK为何自己首先破坏双亲委派模型",
                             "00-G1垃圾收集器的日志格式",
                             "Metadata GC Threshold in Java",
@@ -1338,6 +1344,8 @@ module.exports = {
                         children: [
                             "Spring之BeanNameAware和BeanFactoryAware接口",
                             "这次彻底搞懂IoC容器依赖注入的源码",
+                            "farewell-bean-not-found-easily-solve-spring-boot-package-scanning-issues",
+                            "why-spring-bean-difficult-birth-overcome-constructor-injection-dependencies-and-ambiguity",
                             "别小看Spring过滤器,这些知识点你必须得掌握",
                             "Spring框架使用了哪些设计模式",
                             "阿里四面：你知道Spring AOP创建Proxy的过程吗？",
@@ -1349,9 +1357,9 @@ module.exports = {
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "01-SpringMVC的AsyncHandlerInterceptor异步的处理器拦截器",
+                            "SpringMVC-AsyncHandlerInterceptor",
                             "02-实现http请求的异步长轮询",
-                            "03-SpringMVC拦截处理器",
+                            "SpringMVC-HandlerInterceptor",
                             "SpringMVC-service-doDispatch",
                             "SpringMVC-DispatcherServlet-doDispatch",
                         ]
@@ -1527,12 +1535,24 @@ module.exports = {
                         sidebarDepth: 0,
                         children: [
                             "00-Spring响应式编程",
-                            "响应式编程的适用场景",
+                            "applicable-scenarios-for-reactive-programming",
                             "01-想让系统更具有弹性？了解背压机制和响应式流的秘密！",
+                            "spring-5-reactive-programming-high-performance-full-stack-apps",
                             "04-Spring为何偏爱Reactor响应式编程框架",
                             "05-流式操作：如何使用 Flux 和 Mono 高效构建响应式数据流？",
                         ]
                     }],
+                    
+                    "/md/sentinel/": [{
+                        title: "Sentinel基础",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "spring-boot-integration-with-sentinel-practical-tutorial-from-dependency-to-custom-flow-control-and-monitoring",
+                            "basic-api-resource-rule",
+                            "origin-authority-control",
+                        ]
+                    }],
 
                     "/md/go/": [{
                         title: "Go",
@@ -1646,6 +1666,8 @@ module.exports = {
                         sidebarDepth: 0,
                         children: [
                             "netty-off-heap-memory-leak-detection",
+                            "java-lock-optimization-practice-netty-examples_boost-concurrency-performance",
+                            "use-netty-to-handle-large-data-efficiently",
                         ]
                     },
                     ],
@@ -1681,6 +1703,7 @@ module.exports = {
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
+                            "message-queues-more-than-app-communication",
                             "消息队列面试必问解析",
                             "消息队列的事务消息",
                             "避免无法克服的队列积压",
@@ -1769,6 +1792,7 @@ module.exports = {
                             "06-如何快速定位 Redis 热 key",
                             "Redis异步子线程原理详解",
                             "12-Redis 闭源？",
+                            "redis-agpl-license",
                         ]
                     },
                     {
@@ -1802,6 +1826,7 @@ module.exports = {
                             "04-Kibana常见RESTful API操作",
                             "05-倒排索引与分词",
                             "07-整合进 SpringBoot 项目",
+                            "building-product-search-system-with-es",
                         ]
                     }],
                     "/md/ck/": [{
@@ -2021,11 +2046,13 @@ module.exports = {
                         sidebarDepth: 0,
                         children: [
                             "01-Vue开发实战",
+                            "goodbye-jquery-thinking-create-checklist-apps-with-vue-js-experience-the-charm-of-data-driven",
                             "vue2-to-vue3",
                             "05-教你快速搭建Vue3工程化项目",
                             "Vuex设计Vue3项目的数据流",
                             "router",
                             "table",
+                            "vue-js-vs-axios-practical-guide-from-ajax-requests-to-api-proxy-configuration",
                         ]
                     }],
 
@@ -2159,6 +2186,7 @@ module.exports = {
                             "Claude3到底多强",
                             "计算机使用功能",
                             "claude-3-7-sonnet",
+                            "claude-4",
                         ]
                     },
 
@@ -2180,6 +2208,13 @@ module.exports = {
                             "Build-App-with-Dify",
                             "integrate-dify-and-aws-services-to-enable-more-flexible-translation-workflows",
                             "llm-knowledge-base-segmentation-data-cleaning",
+                            "enhancing-llm-memory-with-conversation-variables-and-variable-assigners",
+                            "accelerating-workflow-processing-with-parallel-branch",
+                            "boost-ai-workflow-resilience-with-error-handling",
+                            "introducing-parent-child-retrieval-for-enhanced-knowledge",
+                            "dify-v1-0-building-a-vibrant-plugin-ecosystem",
+                            "dify-deep-research-workflow-farewell-to-fragmented-search-unlock-ai-driven-insights",
+                            "dify-agent-and-zapier-mcp-unlock-ai-automation",
                         ]
                     },
                     ],
@@ -2282,6 +2317,15 @@ module.exports = {
                     ],
 
                     "/md/AI/agent/": [{
+                        title: "智能体发展",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "ai-agents-dont-security-nightmare",
+                            "improve-quality-gen-ai",
+                        ]
+                    },
+                    {
                         title: "辅助编程",
                         collapsable: false,
                         sidebarDepth: 0,
@@ -2289,6 +2333,7 @@ module.exports = {
                             "changelog-cursor",
                             "goodbye-cursor-hello-windsurf",
                             "Junie",
+                            "introducing-codex",
                         ]
                     },
                     ],
@@ -2351,7 +2396,7 @@ module.exports = {
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "00-rag-introduction-tool-to-eliminate-llm-hallucinations",
+                            "rag-introduction-tool-to-eliminate-llm-hallucinations",
                             "01-RAG应用框架和解析器",
                             "02-相似性检索的关键 - Embedding",
                             "03-core-of-rag-result-retrieval-and-reordering",
@@ -2414,6 +2459,7 @@ module.exports = {
                             "overcoming-fear-uncertainty-and-doubt-in-the-era-of-ai-transformation",
                             "aigc-app-in-e-commerce-review",
                             "ai-trends-disrupting-software-teams",
+                            "amazon-strands-agents-sdk",
                         ]
                     },
 
@@ -2477,6 +2523,7 @@ module.exports = {
                             "适配器模式",
                             "门面模式",
                             "iterator-pattern",
+                            "flyweight-pattern",
                         ]
                     },
                     ],
diff --git a/docs/md/AI/00-rag-introduction-tool-to-eliminate-llm-hallucinations.md b/docs/md/AI/00-rag-introduction-tool-to-eliminate-llm-hallucinations.md
deleted file mode 100644
index 897da96fb..000000000
--- a/docs/md/AI/00-rag-introduction-tool-to-eliminate-llm-hallucinations.md
+++ /dev/null
@@ -1,154 +0,0 @@
-# 00-“消灭”LLM幻觉的利器 - RAG介绍
-
-大模型一定程度改变了我们生活工作的思考方式，越来越多的个人和企业在思考如何将大模型应用到更加实际的生产生活。
-
-## 1 LLM的问题
-
-### 1.1 幻觉
-
-LLM因为是一个预训练模型，它已有一些知识储备，我们提的问题跟他的知识储备不相符时，会产生一些幻觉问题，看上去正确的回答。
-
-### 1.2 新鲜度
-
-LLM预训练出来之后，不能感知到我们实时更新的工业数据，还有企业内部的一些私域数据。
-
-### 1.3 数据安全
-
-LLM训练依赖很多训练数据集，然后为了保证大语言模型的效果更好，训练集的质量及数据量越多，对LLM的训练最终效果更好，但又期望LLM帮解决一些垂类问题，又希望在数据安全有些防范，如企业内部敏感数据不能暴露出去，让公有的LLM去进行训练。
-
-## 2 RAG是啥？
-
-为解决LLM刚提到问题，提出RAG，将企业内部私域数据及实时更新的一些公域数据，通过一些处理后，变成可进行相似性搜索的向量数据，然后存储到向量数据库。
-
-和LLM交互时，用户提问。先在我们的相同数据库中进行相似性检索，检索与提问相关的知识内容，检索后交给LLM，连同用户的提问一起让 LLM 去生成回复。
-
-RAG帮助我们个人及用户去把企业内部的一些知识数据，很快构建出一个庞大知识库，然后结合目前已有LLM能力，可快速制作智能问答机器人应用。
-
-![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/47ab7653f34a903658793e80be1d8489.png)
-
-### 小结
-
-为LLM提供来自外部知识源的额外信息的概念。这允许它们生成更准确和有上下文的答案，同时减少幻觉
-
-- 检索：外部相似搜索
-- 增强：提示词更新
-- 生成：更详细的提示词输入LLM
-
-## 2 RAG应用咋构建？
-
-
-
-![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/74f210f06ba2acf4b91bb726e762ab39.png)
-
-
-
-![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/6bc1a91e2ac250fa0558a52f89d48640.png)
-
-使用到RAG的这条链路之后，用户先去构建好的知识库，即向量数据库里进行相似性检索，再带出一部分的知识知识文档。这部分知识文档会跟用户的query结合。
-
-然后通过prompt技术组装成一个最终完成的一个输入给到LLM，让LLM回复。
-
-最关键就是知识库生成这步，因为主要涉及把我们的知识文档去做内容提取及拆分。还要进行量化，入库。
-
-### 2.1 RAG步骤
-
-1. 知识切片成Chunk
-
-2. 向量化Chunk入库
-
-   前两步都是去知识库生成。
-
-3. Query检索知识Chunk
-
-4. 构建Prompts
-
-5. 调用LLM生成回答
-
-   后三步都是知识库生成后，在检索方面需要做的。
-
-### 2.2 基于Langchain构建 RAG 应用
-
-Langchain中RAG的实现：
-
-![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/08cc6cd9c8945bebc67d50fde04618f0.png)
-
-各种文档 - 各种 loader - 文本切片 - 嵌入向量化 - 向量存储 - 各种检索链。
-
-
-
-![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/d23779a15d1e548c9fecfd3b501e8b3c.png)
-
-#### 设计思想
-
-把那五步拆成不同组件，然后由不同节点做相应处理。让用户去编写自己的业务逻辑的代码，然后把这整个过程串起。
-
-#### 优势
-
-- 可快速构建一个demo，帮助开发者去理解RAG应用
-- 庞大社区支持，如一些插件或它的一个版本更新迭代都很快
-
-#### 痛点
-
-本质上通用性很强。为保证强通用性，效果层面不一定做到最好，需企业或个人投入较大精力，把整体的RAG在召回层的效果提升到最佳。
-
-## 3 bad case
-
-构建整个RAG应用过程中会遇到的一些问题和解决方案。
-
-### 3.1 拒答
-
-用户提问：请问A产品分析报告多久分析一次？
-
-召回的相关知识：A产品的分析报告信息近30天的数据分析结果。
-
-原因是我们用户的问题，在相关知识中没明确提到，只是有一定相似度。但跟我们用户问题不直接相关。这样的相关知识以及用户的问题。组装后交给LLM回答，本质上是人为制造干扰。
-
-对此，有个工程化实践叫拒答。
-
-### 3.2 消歧
-
-提问：A课程适合多大年龄小孩。
-
-知识库召回两条数据，其中一条是期望的一个知识，就在A课程文档。会有一段话跟提问相关，但还会召回其他的一个干扰知识。如其他文档里一些内容，像该课程适合3到7岁的小孩，适合6到8岁的女孩。这种知识内容也会被召回。
-
-期望的召回内容携带一部分干扰信息，这干扰信息没有A课程这个关键字，然后也不会召回。在这两个知识内容交给大源模型处理，他也无法理解哪个字内容正确。
-
-更希望在召回层，就有较好手段处理。工程化实践里，会对用户进行改写，增强query的一个效果。
-
-也用到类似BM25这种倒排索引，提升关键字的权重。如干扰知识里没生成这个关键字，其相似度分数较低，就不会召回。
-
-### 3.3 分类
-
-可能有用户的提问类似：服务器连接不上，应当如何解决？
-
-现在给知识库里面注入的文档，都是类似连接服务器应该有哪些步骤。
-
-将这些知识内容召回，交给LLM也能引导用户。但不能直切要害，用户更希望，我现在连接不上，有啥排查手段。更好的还是通过提供一些专门QA文档，增强整个知识召回内容准确性。
-
-用户可能问一些跟他实例相关的问题。如CPU占用变高或内存变高，实际响应可能是技术支持文档里的一些处理方案，就是我现在内存变更咋处理。但用户想知道为啥变高。有一个意图识别模型，判断用户他想要的问题具体是一个什么类的，需不需要用到RAG，也会判断他是否需要用到诊断引擎。类似问题2，需要用到诊断引擎，那我们会调用其他RAG无关的诊断相关技术为用户排查问题，并且给用户反馈一个结果。
-
-## 4 咋提升RAG应用效果？
-
-
-
-![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/436b65827d8f997647d25dc980076556.png)
-
-$$
-整体效果 = 文档处理效果 * Embedding效果 * Retrieval效果 * LLM效果
-$$
-demo易，但上手难，主要因为LangChain、LLamIndex框架盛行。很快接入就是初级的一个状态，可能只做到35%。
-
-想提高整体一个准确率，在拆分那儿会拆更合理、提取内容时，把整个内容提取更好。做向量化时，去选择我们的向量，更好的一个embedding模型。
-
-最终跟LLM交流时，选择效果更好的LLM，然后把这效果给提升到更高。
-
-但60%的准确率还是达不到生产期望。希望准确率90%，在RAG应用构建各阶段，都有很多工程化手段。
-
-目前RAG整体应用在界内的比较关注的一个地方就是在召回。因为涉及知识文档，思考方向：
-
-- 优先保护保证这个召回率
-- 优先保证这个精度
-
-RAG召回是希望获得更多和用户提问相关的知识内容，还是说我只需要更关键的知识内容排在最顶。某云厂商相关数据库AI套件选择前路，期望召回更多跟用户相关的提问的内容。
-
-精度尽量保证召回内容在top3、top5位置出现，因为召回的一些内容确实有一部分干扰信息。但目前LLM能力尚可，对这种干扰性信息的排除能力较好。
\ No newline at end of file
diff --git "a/docs/md/AI/00-\344\270\272\344\273\200\344\271\210\350\246\201\345\255\246\344\271\240\345\244\247\346\250\241\345\236\213.md" "b/docs/md/AI/00-\344\270\272\344\273\200\344\271\210\350\246\201\345\255\246\344\271\240\345\244\247\346\250\241\345\236\213.md"
index 4967495df..519148bbe 100644
--- "a/docs/md/AI/00-\344\270\272\344\273\200\344\271\210\350\246\201\345\255\246\344\271\240\345\244\247\346\250\241\345\236\213.md"
+++ "b/docs/md/AI/00-\344\270\272\344\273\200\344\271\210\350\246\201\345\255\246\344\271\240\345\244\247\346\250\241\345\236\213.md"
@@ -1,129 +1,139 @@
-# 00-为什么要学习大模型
+# 为什么要学习大模型
 
-## 0 prompt engineer
+## 1 学习大模型的意义
 
-就是prompt工程师它的底层透视。
+### 1.1 底层逻辑
 
-## 1 学习大模型的重要性
+AI大潮已来，不加入就被淘汰。就像现在职场谁不会用PPT和excel一样。你问任何一个人他会不会用PPT，都说会用，只是说好还是不好，除非岗位跟电脑完全无关。但凡用电脑，基本都用excel和PPT，不会用的基本都被淘汰，逻辑一样。
 
-### 底层逻辑
+#### AI虽有应用场景，好像跟普通人无关？
 
-人工智能大潮已来，不加入就可能被淘汰。就好像现在职场里谁不会用PPT和excel一样，基本上你见不到。你问任何一个人问他会不会用PPT，他都会说会用，只是说好还是不好。你除非说这个岗位跟电脑完全无关。但凡说能用上电脑的，基本上都会用excel和PPT，你不会用的基本上都被淘汰了，逻辑一样。
+如智能驾驶，人脸识别，跟普通人关系不大，我们都是被动使用。但现在大模型跟我们每人都有关，强大的提升工作效率工具。你不会用，就好像跟PPT和excel一样，你就会慢慢被职场淘汰。
 
-人工智能虽有一些应用场景，好像跟普通人没关。如智能驾驶，人脸识别，好像跟普通人关系不太大，我们都是被动使用。但现在这大模型跟我们每个人都有关，它是一个强大提升工作效率工具。你不会用，将来就好像跟PPT和excel一样，你就会慢慢的被职场淘汰。
+#### 会用就行？
 
-会用就行？好像我们会用大模型，好像很简单对吧？无论是文心，还是通义千问，还是ChatGPT，用起来很简单，就是聊天不就OK？但其实不够，因为我们用它不只是当搜索引擎，用它是为提升工作效率，所以还要用的好。
+用大模型，好像很简单。无论通义千问、ChatGPT，用起来简单，聊天就OK。但还不够，因为我们用它不只是当搜索引擎，用它是为提升工作效率，得用的好。
 
-### 啥叫用的好？
+### 1.2 啥叫用的好？
 
-如写文章，PPT，写excel，可让他给你进行优化。甚至codding，也可让大模型帮你写。当然说让它完全替代你的代码不可能，但是你可以用它给你写一些框架性东西或具体的一个小问题，可直接让他写，然后拿过来你试下好不好用，甚至有bug也可以让他改一下。这样其实还是大幅度提升工作效率，最终跟PPT和excel依然逻辑类似。
+如写文章、PPT和excel，让他给你优化。甚至coding，让大模型帮你写。完全替代你的代码不可能，但给你写一些框架性东西或具体一个小问题，然后拿过来你试下好不好用，有bug也可让他改。还是大幅提升工作效率，最终跟PPT和excel依然逻辑类似。
 
-## 2 大模型的潜力与微调
+## 2 LLM潜力与微调
 
-大模型是人工智能代表，潜力与使用方式有关。使用好大模型可提高效率，让人获得更好的待遇和更多机会。然而大模型潜力要通过微调挖掘，以适应不同场景和需求。大模型出现引发行业需求爆发，尤其随ChatGPT到来，其问答能力超过临界值，行业需求将逐渐增加。
+LLM是AI代表，潜力与使用方式有关。潜力要通过微调挖掘，以适应不同场景和需求。大模型出现引发行业需求爆发，尤其随ChatGPT问答能力超过临界值，行业需求逐渐增加。
 
-你发现PPT和excel用的好的PPT一看就惊艳，excel用的特别熟练，你这个数据分析用的非常的到位，你的待遇会远远高于那些用的不好的。大模型也一样：
+PPT和excel技能高的的PPT一看就惊艳，excel用的特熟练，你这数据分析用的非常到位，待遇自然远高于那些用的不好的。LLM同理：
 
-- 用好你可几倍于原来效率
-- 用不好，你可能跟原来没什么区别
+- 用好，几倍原效率
+- 用不好，就感觉和现状无区别
 
-差距非常明显，有人就可一人干两人活，那待遇肯定远高于能保持原效率的人。大模型底层逻辑用的不好：
+差距明显，有人可一人干两人活，待遇肯定高于原效率的人。
 
-- 要么没挖掘出大模型潜力，你只是让他答一些普通问题
-- 要么就是你这个prompt写的不好，他就开始胡乱回答
-- 或你问的问题范围不好，他就开始胡乱回答
+### LLM底层逻辑用的不好
 
-这都是用的不好的一些标志，但最终你用的好。
+- 没挖掘出大模型潜力，你只是让他答普通问题
+- prompt写不好，他就乱答
+- 问的问题范围不好，也不着边际乱答
 
-假设你已通过各种尝试磨练或技巧学习，把某模型潜力发挥到极致。如文心一言最终能解决所有问题吗？也不行，就比如大模型不会回答关于你公司内部信息问题，因为他不知道，他没训练过。
+这都是用的不好的标志。
 
-当然现在通过知识库可部分解决这个问题，但知识库不是万能，最终他一定会有场景需要训练。比如说你想调整他回答的语气，让他活泼点或更官方点或让他的回答的更有一些个人特色。这种场景的大模型，因为它没有训练这种内容，所以它不可能满足你的需求。你一定要对它进行训练，至少微调。
+若已通过各种尝试磨练或技巧学习，把某模型潜力发挥到极致。如ChatGPT最终能解决所有问题吗？也不行，就比如大模型不会回答你公司内部信息问题，因为他不知道，没数据训练过。
 
-所以总结下，大模型是一个非常强大的一个工具，他作为人工智能代表，AIGC已来到普通人接受范围内。这时不仅要会用，还要用好，甚至会微调，才能拉开跟其他职场人员的差距。这样我们的待遇才能更丰厚，工作机会更多。
+通过知识库可部分解决这问题，但知识库不是万能，最终会有场景需要训练。如想调整他回答的语气活泼点或更官方点或有些个人特色。这种场景大模型，因为没有训练这种内容，所以不可能满足你的需求。你要对它训练，至少微调。
 
-你要学习到第二点，就是行业需求爆发了，就是基点以来。自从大模型出现，它的问答能力突破了一个临界值，就好像都有一个值。以前的模型都在临界值下徘徊，导致很难商用，只能在学术界兜转。直到ChatGPT才迈过这阀值，就是我们能接受的门槛，错误已经少到一定界限。这种我们会发现他已经可以用了，问什么问题都能回答上来，这就是基点。这就导致行业需求其实是慢慢会爆发起来的，它应对哪些场景呢？
+所以不仅要会用，还要用好，甚至微调，才能拉开跟其他职场人差距。待遇才能更丰厚，工作机会更多。
+
+### 问答能力突破临界值
+
+行业需求爆发，自大模型出现，问答能力突破临界值。以前模型都在临界值下徘徊，难商用，只能在学术界兜转。直到ChatGPT迈过阀值，错误少到一定界限。问什么都能回答，这就是奇点。导致行业需求爆发。
 
 ## 3 大模型的应用需求
 
-大模型在公司内部问题解决、产品解答、智能聊天和游戏NPC等方面的应用需求。大模型的使用可以提高效率、流畅度和人机交互体验。随着需求的增加，相关工程师的需求也会提升。
+公司内部问题解决、产品解答、智能聊天和游戏NPC等方面的应用需求。大模型可提高效率、流畅度和人机交互体验。随需求增加，相关工程师需求也会提升。
+
+### 3.1 对内
 
-### 对内
+像OA、ERP和CRM等问题，平时都是文档来文档去，如OA公司制度都是文档，某人对某制度疑惑，要么问HR或行政，整体效率低。这些知识全都可接入大模型，模型+知识库。
 
-像OAERPCRM等这些问题。平时都是是文档来文档去，比如说里面OA公司的制度都是文档，某人对某制度疑惑，要么问HR或行政，整体效率低。未来这些知识其实全部都可接到一个大模型之后，让一个模型加一个知识库，效率大大提高。
+### 3.2 对外
 
-### 对外
+类似客服解答产品的这种需求。每个公司都有自己的一些产品，有些产品边界、产品参数，还有售后服务之类，都要解答客户问题。
 
-也有类似客服解答产品的这种需求。每个公司都有自己的一些产品，有些产品边界、产品参数，还有一些应对各种情况的服务之类的，都要解答客户问题。现在解决方法一般先建一个官方网站里面介绍产品，然后后面再对接一个真人客服，当然也会加一些智能客服内容，但总体效果不如未来使用大模型加知识库，然后还有智能聊天，这是最底层需求。但现在人越来越忙，尤其老年人，他们没人聊天。这需求其实非常大，但一直没有被满足。但总之现在大模型出现之后，让问题看见曙光。
+现解决方案是一般先建一个官方网站介绍产品，后台再对接一个真人客服，当然也会加一些智能客服内容，但总体效果不如用大模型+知识库的智能聊天。
 
-### 智能NPC
+现在人越来越忙，尤其老年人，他们没人聊天。这需求其实非常大，但一直没有被满足。
 
-如游戏里面的NPC都是写死的，都是给你一个逻辑控制，遇到啥场景他做啥回答，完全写死，所以感觉刻板。如将来游戏NPC也接入大模型，让他对话更流畅，更像一个人。但这个游戏里面单纯的找各种不同人对话，是不是感觉也很有意思？这就是游戏里需求，也非常大。尤其未来元宇宙如果出现vr、ar都结合上之后，再加大模型，这里面的需求场景几乎无限大。
+### 3.3 智能NPC
 
-行业需求爆发，是不是可能让从事相关工作的工程师的待遇进行提升？肯定的，不过个案不能代替全部。如果说按一个行业，它总体待遇是由供需关系和创造价值量决定的。但是总体上它的需求产生了爆炸性提升。但总体上，互联网其实就是一个这样一层一层往上叠代爆发的过程。
+如游戏里NPC都是写死，都是给你一个逻辑控制，遇到啥场景他做啥回答，感觉刻板。如将来游戏NPC接入大模型，对话更流畅，更像人。但这个游戏里面单纯的找各种不同人对话，是不是感觉也很有意思？vr、ar都结合后，再加大模型，需求场景几乎无限。
 
 ## 4 互联网行业技术发展与工资待遇
 
-互联网行业工资待遇高的原因是因为需求突然爆发，供应不足；互联网是编辑成本低的行业；创造的价值量与用户量成正比，但成本不成正比；技术的发展也是一层一层往上叠代的，学习最顶层的技术才能拿到高薪。
+行业需求爆发，是不是能让从事相关工作的工程师的待遇提升？肯定的，不过个案不能代替全部。
 
-互联网刚出，你会个HTML，简单JS，工资可能就拿非常高。当时根本无法想象的。90年代当时美国互联网泡沫，你就是会一个HTML这么简单的一个东西就可以拿很高的年薪。就是因为这个需求突然爆发了，但供应提不上来，没那么多人会，所以工资待遇高。而且互联网又是一个编辑成本很低的一个行业。就是你只要做出一个东西，可以给全球每一个人看你这个成本，还是原来的成本不会增加太多。
+一个行业，总体待遇由供需关系和创造价值量决定。互联网行业待遇高的原因是需求爆发，供应不足；互联网是编辑成本低的行业；创造的价值量与用户量成正比，但成本不成正比；技术发展也是一层层迭代，学习最顶层技术才能高薪。
 
-这就是为什么互联网行业的待遇容易比较高，这就是创造的价值量跟你的用户量成正比，但是你的用户量跟你的成本却不成正比。你一个用户成本跟100万个用户的成本其实差不了许多，差的可能你就是服务器成本，但是你主要的研发成本差不多，剩下主要是供需关系。
+互联网初期，会HTML，简单JS，工资就很高。就是因为需求爆发，但供应提不上来，没那么多人会，所以工资待遇高。
 
-最开始HML假设在这位置，然后就是ASP、PHP语言刚出来的一些动态页面，会这些语言你就高薪。再往后安卓出来智能手机IOS之前可能还有java，java是在这位置后，然后IOS和安卓它是一层一层往上开发，然后到算法，现在到了大模型。
+互联网又是一个编辑成本低的行业。只要做出一个东西，可给全球每个人看，还是原来成本，不会增加太多。
 
-你现在再学习下面的东西，如HTML，PHP5、java。在现在这个位置学习他，你不可能高薪，因为它已是基础设施。就好像你开发应用一样，你现在去开发操作系统，你除非说国产替代，正常来讲，微软和苹果已把操作系统完全占领，你不可能再打开空间。再往上，可能微信QQ之类的，你再开发一个类似的，也不可能打败它。
+这就是为啥互联网行业待遇较高，这就是创造的价值量跟用户量成正比，但用户量跟你的成本不成正比。1个用户成本跟100万个用户成本差不了许多，可能就服务器成本，但主要研发成本差不多，剩下主要是供需关系。
 
-跟这个技术的原理是类似的，技术也是一层一层往上叠代。你现在这个角度去学习更底层东西。不是说完全没必要学，如果说你有时间可学习，这样知识体系更完整。但仅靠下面知识找工作，高薪不易。你只有拿最顶层技术，可能高薪。
+最开始HTML假设在这位置，再就是ASP、PHP刚出来的一些动态页面，会这些就高薪。再安卓，出来了智能手机和Java。IOS和安卓一层层往上开发，到算法，现在到大模型。
+
+再学习如HTML，PHP、Java，你不可能高薪，因为它已是基础设施。就好像你开发应用，你现在去开发操作系统，除非国产替代，正常来讲，微软和苹果已把os完全占领，不可能再打开空间。再往上，可能微信QQ之类，你再开发类似，也不可能打败。
+
+技术层层往上迭代，你现在角度去学习更底层东西。不是完全没必要学，若你有时间可学，这样知识体系更完整。但仅靠下面知识找工作，高薪不易。你只有拿最顶层技术，更可能高薪。
 
 ## 5 大模型训练经验与高薪offer
 
-前段时间有个大模型训练的拿到200万年薪。工作经验只有六年。他为什么那么高offer？大模型经验他比较多，大模型其实是GPT3出来后，CP3出来到现在大概也就三年。算上GBTR大概四年，他在阿里就有四年大模型训练经验，很难得。
+前段时间有大模型训练200万年薪。工作经验只有六年。因为他大模型经验多，大模型其实是GPT3出来后，到现在也就三年，算上GBTR大概四年，他在阿里就有四年大模型训练经验，很难得。
 
-模型本身其实现在工作需求已比较大。如果说它下面游戏NPC有了一个突破，然后你又比较熟悉这方向，会的人又比较少。这时你立马就可跳槽拿高薪。
+模型本身工作需求已较大。若它下面游戏NPC有突破，然后你又比较熟悉，会的人又少。立马可跳槽高薪。
 
-## 6 为啥通过本套专栏学习大模型？
+## 6 为啥通过本专栏学习大模型？
 
-这套专栏是围绕大模型，就围绕ChatGPT进行组织的。首先基于ChatGPT的历史发展开始讲解前后左右：
+专栏围绕大模型，就围绕ChatGPT、通义千问组织。先基于ChatGPT的历史发展开始讲解前后左右：
 
-- 前就是它的历史
-- 后讲大模型延伸。高效微调训练也会讲，但是我们完整的这个175B的ChatGPT训练不动。所以用了高效微调训练了一个6B的模型及launch基于long ten结合一个稍微小一点的语言模型6B的进行一些应用的开发，这是后面
-- 左右就是用到了强化学习，在ChatGPT训练的时候用到了强化学习。展开讲了，避免你产生一些知识盲区。
+- 前，就是它的历史
+- 后，讲大模型延伸。但完整175B ChatGPT训练不动。所以用高效微调训练一个6B模型及langchain结合小模型6B进行应用开发
+- 强化学习，在ChatGPT训练时用到
 
-不像有的说讲这个ChatGPT，直接把NLP1大套底层的知识都搬给你，这些也不是没有用。但是就对你这个主题稍微有点偏会，导致你如果说这个东西肯的时间太长，会让你兴趣丧失，不太利于你学习。这个知识用到的知识我都给你讲了也不会显得过于单薄。
+不像有的人讲ChatGPT，直接NLP一大套底层知识搬给你。这些不是没用，但对你入门主题偏离，导致理论啃太久，兴趣丧失，不利学习。等用到这些知识再回看就不显得单薄。
 
-现在关于大模型或ChatGPT专栏，主要还是一些帖子或简单专栏。它对它的GPT依赖的一些知识，如transformer、历史，还有强化学习都不太多。这就需要你有比较多的基础知识才能看那些课。我这课相对降低你对基础知识要求。讲课的时候也包含了一些底层的思考，你也可以认为是一些类比，能让你更好的理解这些模型到底是在干什么。
+现关于大模型或ChatGPT专栏，主要还是一些帖子或简单专栏。对GPT依赖知识，如transformer、历史，强化学习都不多。需有较多理论基础知识才看懂。而本专栏相对降低对基础知识要求。讲解时也包含一些底层思考和类比，让你更好理解这些模型到底在干啥。
 
 ## 7 专栏学习方法及收获
 
-现在训练专栏都不系统，因为ChatGPT是新兴事物，22年8月才出现，然后11月才火起来，至今不满2年。要么它就是基于传统的NOP专栏，然后再单独开一张，介绍一下全程PPT。
+现在训练专栏都不系统，因为ChatGPT是新兴事物，22年8月才出现，然后11月才火起来，要么它就是基于传统的NLP专栏，然后再单独开一张，介绍全程PPT。
 
-### 学习方法
+### 7.1 学习方法
 
-不只是学习本套专栏的方法，其实学习所有人工智能你都可以用这套方法，就是关于数学公式推导。人工智能有大量数学公式推导，是人工智能专栏最大难点，但你数学不好，又想学课咋办？建议先跳过，先扫两眼公式，感觉看懂就看看。看不懂跳过，把公式推倒当成黑盒，只记结论及逻辑。但建议你有能力，感觉数学还可，还是把公式啃完，当然了大部分应用开发工程师不需要。
+不只是学习本套专栏的方法，其实学习所有人工智能你都可以用这套方法，就是关于数学公式推导。人工智能有大量数学公式推导，是人工智能专栏最大难点，但你数学不好，又想学课咋办？建议先跳过，先扫两眼公式，感觉看懂就看看。看不懂跳过，把公式推倒当成黑盒，只记结论及逻辑。但建议你有能力，数学还可，就把公式啃完，当然大部分应用开发工程师不需要。
 
-### 收获
+### 7.2 收获
 
-你会学习到ChatGPT等大模型训练原理，即：
+你会学习到ChatGPT、千问等大模型训练原理，即：
 
 - 底层原理
 - 如何训练
 
-然后掌握多种NLP逻辑，因为fort它是为了解决下游NLP任务的，如文本分类，N12，阅读理解。所以本套专栏其实都会在介绍port时候介绍一些逻辑。用它们解决下游任务也比较简单，在代码实践上也进行了一个样例的操作，可上手解决实际问题。你就拿一个人家训练好的波尔模型拿过来，然后在下游进行或者分类，或者说NE2，去接一下不同的下游处理，就可以直接上手处理不同的任务，或者一般还是需要微调的，所以你再训练一下就可以解决实际问题了。
+再掌握多种NLP逻辑，因为fort就是为解决下游NLP任务，如文本分类，N12，阅读理解。就拿一个人家训练好的Bert模型拿过来，然后在下游进行或者分类，或者说NE2，去接一下不同的下游处理，就可以直接上手处理不同的任务。一般还是需要微调，所以你再训练即可解决实际问题。
 
-然后理解bert和GPT的模型异同，实际上是bert系列和GPT系列他们的模型的差异。然后学会高效调参技巧，如peft和 Langchain。简单理解就是你的显存不够时，还能把这个大模型训起来。如6B13B都可训起来。最后就学会用浪琴加上不同大模型。如千问模型再加一个知识库向量数据库，如face搭建一个自己的智能助手，这是收获。
+理解bert系列、GPT系列模型差异。学会高效调参技巧，如PEFT和 Langchain。就是显存不够时，还能把LLM训起来，如6B、13B。最后用langchain加不同LLM如qwen+知识库使用向量数据库，搭建一个自己的智能助手。
 
 ## 8 适合人群
 
-想从零开始学习chat GP的人群。基础不多想学没关系，数学基础不是那么的优秀也可学。可把数学公式推导先跳过。后面对数学有兴趣，把这基础补补再来看也OK
-
-想理解大模型底层原理，以便更好使用大模型。如为什么大模型避免不了幻觉，就是说它避免不了胡乱回答。你只有理解底层原理才知为什么，你才能尽量的有指导性去回避让他乱答。
+想从0开始学习ChatGPT的人群。基础不多想学没关系，数学基础不是那么的优秀也可学。可把数学公式推导先跳过。后面对数学有兴趣，把这基础补补再来看也可。
 
-想自行训练和搭建大模型服务的人群。要么就是外包，你给别公司去搭建。要么就是你在公司里其他人都不会，又不想花很多钱去买外包服务。但自己学一下给自己公司搭一个大模型的服务地图储备，这个其实还看目的。如只是想学会它底层原理，然后去更好使用这些模型，那懂点点python、linux就可。对技术依赖不多。但如果说你想训练场，你想玩的更彻底，那我的建议还是要有一些数学基础，有一些人工智能基础。
+想理解大模型底层原理，以便更好使用大模型。如为啥大模型避免不了幻觉，就是说它避免不了回答。只有理解底层原理才知为什么，你才能尽量有指导性去避免他乱答。
 
-## 9 提供服务
+想自行训练和搭建大模型服务的人群：
 
-问题的解答。这个问题我这边是定期会看问题，然后定期回答。
+- 外包，你给别公司去搭建
+- 你在公司里，其他人都不会，又不想花很多钱去买外包服务
 
-在线笔记，还会拉一个群，这样与其他的小伙伴们一起交流。
+但自己学一下给自己公司搭一个大模型服务做储备，也看目的：
 
-有些问题，其他同学还要好，互相之间交流有时也很重要，这就是导学。
\ No newline at end of file
+- 只想学底层原理，去更好使用这些模型，那懂点python、linux就可，对技术依赖不多
+- 但想训练它，想玩更彻底，还要有数学和AI基础
\ No newline at end of file
diff --git a/docs/md/AI/03-core-of-rag-result-retrieval-and-reordering.md b/docs/md/AI/03-core-of-rag-result-retrieval-and-reordering.md
index e263cc4fd..9a5d2ece9 100644
--- a/docs/md/AI/03-core-of-rag-result-retrieval-and-reordering.md
+++ b/docs/md/AI/03-core-of-rag-result-retrieval-and-reordering.md
@@ -1,34 +1,36 @@
-# 03-RAG的核心-结果召回和重排序
+# RAG的核心-结果召回和重排序
 
 ## 1 完整RAG应用的检索流程
 
-![](https://javaedge-1256172393.cos.ap-shanghai.myqcloud.com/image-20240414173436869.png)
+![](https://p.ipic.vip/a0stn3.png)
+
+从用户输入Query到最终输出答案，整个流程包括Query预处理、检索召回、排序，每个环节都有不同方法提升检索效果。
 
 ## 2 Query预处理
 
 ### 2.1 意图识别
 
-判断query问的是什么类型的问题，从而决定是否走RAG链路。
+判断query问的啥类型问题，决定是否走RAG链路。
 
-示例1：
+#### 示例1
 
-- 深圳有什么好玩的 闲聊问题
-- VDB支持哪些检索算法 产品常见问题
+- 深圳有啥玩的？ 闲聊问题
+- VDB支持哪些检索算法？ 产品常见问题
 
-示例2：
+#### 示例2
 
-- 为什么某个MongoDB实例内存占用过高 检查类问题
-- 云Redis如何扩容 产品常见问题
+- 为啥某MongoDB实例内存占用过高？ 检查类问题
+- 云Redis咋扩容？ 产品常见问题
 
 #### 流程图
 
-![](https://javaedge-1256172393.cos.ap-shanghai.myqcloud.com/image-20240414174957382.png)
+![](https://p.ipic.vip/oup930.png)
 
 ### 2.2 生成同义query
 
 针对query生成同义句，不同问法提高召回，检索结果做合并。
 
-示例1：**VDB支持哪些检索算法**
+示例1：**VDB支持啥检索算法**
 
 - 列举一下VDB所支持的检索算法
 - VDB有哪些可用的检索算法
@@ -40,7 +42,7 @@
 
 #### 流程图
 
-![](https://javaedge-1256172393.cos.ap-shanghai.myqcloud.com/image-20240414175138044.png)
+![](https://p.ipic.vip/gyl5ct.png)
 
 ### 2.3 query标准化
 
@@ -48,30 +50,36 @@
 
 示例1：VDB支持哪些检索算法
 
-腾讯云向量数据库支持哪些检索算法
+xx云向量数据库支持哪些检索算法
 
 示例2：COS如何上传对象
 
-腾讯云对象存储如何上传对象
+xx云对象存储如何上传对象
 
 #### 流程图
 
-![](https://javaedge-1256172393.cos.ap-shanghai.myqcloud.com/image-20240414175519594.png)
+![](https://p.ipic.vip/tcuags.png)
 
 ## 3 检索召回
 
+![](https://p.ipic.vip/2qkawe.png)
+
 
 
-![](https://javaedge-1256172393.cos.ap-shanghai.myqcloud.com/image-20240414175607157.png)
+| 索引类型 | 使用场景                                                     | 适用向量规模 | 召回率                 |
+| -------- | ------------------------------------------------------------ | ------------ | ---------------------- |
+| FLAT     | 暴力检索，召回率100%，但检索效率低。                         | 10万以内     | 最高，可保证100%召回率 |
+| HNSW     | 基于图算法构建索引，可通过调整参数平衡查询日志和，具体信息：搜索效率。<br>检索效率高，但数据量大时内存消耗变高，具体请参考官方文档。 | 10万-1亿     | 95%+，可根据参数调整   |
+| IVF系列  | 基于聚类算法构建的索引，可通过参数调整召回率，适用于上亿规模的数据集，检索效率高，内存占用低，写入效率高。 | 亿以上       | 95%+，可根据参数调整   |
 
 每次召回时，如何提升结果的排序效果，使与Query更相关的结果更靠前？
 
-1. **使用更有效的索引技术**：使用更高级的索引技术如倒排索引、压缩倒排索引等可以加速检索过程并提高结果的相关性。这些技术可以使得相似的文档在索引中更靠近，从而使得相关的结果更容易被召回。
-2. **优化检索模型**：使用适合任务的检索模型如BM25、BERT等，这些模型可以更好地捕捉文档之间的语义和相关性，从而提升召回结果的质量。
-3. **利用用户反馈**：收集用户的点击、浏览、收藏等行为反馈信息，通过机器学习算法不断优化排序模型，使得更符合用户兴趣的结果更容易被召回并排在前面。
-4. **引入上下文信息**：考虑查询的上下文信息，比如用户的地理位置、设备信息、搜索历史等，可以更好地理解用户意图，提升召回结果的相关性。
-5. **使用深度学习技术**：利用深度学习技术如卷积神经网络、循环神经网络等，可以更好地学习文档之间的语义关系，从而提高结果的排序效果。
-6. **结合多种特征**：结合文本特征、结构特征、用户特征等多种特征进行综合排序，可以更全面地考虑到文档与查询之间的相关性。
+1. **使用更有效的索引技术**：使用更高级的索引技术如倒排索引、压缩倒排索引等可以加速检索过程并提高结果的相关性。这些技术可以使得相似的文档在索引中更靠近，从而使得相关的结果更容易被召回
+2. **优化检索模型**：使用适合任务的检索模型如BM25、BERT等，这些模型可以更好地捕捉文档之间的语义和相关性，从而提升召回结果的质量
+3. **利用用户反馈**：收集用户的点击、浏览、收藏等行为反馈信息，通过机器学习算法不断优化排序模型，使得更符合用户兴趣的结果更容易被召回并排在前面
+4. **引入上下文信息**：考虑查询的上下文信息，比如用户的地理位置、设备信息、搜索历史等，可以更好地理解用户意图，提升召回结果的相关性
+5. 使用深度学习技术：如卷积神经网络、循环神经网络等，可更好学习文档之间的语义关系，从而提高结果的排序效果
+6. **结合多种特征**：结合文本特征、结构特征、用户特征等多种特征进行综合排序，可以更全面地考虑到文档与查询之间的相关性
 
 综合运用以上方法，可以在召回阶段有效提升结果排序效果，使得与Query更相关的结果更靠前。
 
@@ -102,34 +110,37 @@ Query预处理中，做了生成同义Query，最终应该如何合并检索结
 
 Rerank：RAG中百尺竿头更进一步
 
-![](https://javaedge-1256172393.cos.ap-shanghai.myqcloud.com/image-20240414180259423.png)
-
-**Embedding模型存在一定的局限性**：实际召回结果中，embedding没办法完全反应出语义的相似性，至少这K个文件的排名并不是我们认为的从高分到低分排序的。
+![](https://p.ipic.vip/j84nai.png)
 
+**Embedding模型局限性**：实际召回结果中，embedding无法完全反应出语义相似性，至少这K个文件的排名并非我们认为的从高分到低分。
 
+排序模型目的在于，对召回内容有更合理排序结果，减少提供给模型的上下文长度，长度越长，对模型压力越大。
 
-排序模型的目的在于对召回内容有一个更合理的排序结果，减少提供给模型的上下文长度，长度越长，对模型来说压力越大。
-
-![](https://javaedge-1256172393.cos.ap-shanghai.myqcloud.com/image-20240414180419790.png)
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/974f3c64951c640dfd26adbf92ab2da1.png)
 
 基于Learning2Rank的思路提升文本语义排序效果：
 
-![](https://javaedge-1256172393.cos.ap-shanghai.myqcloud.com/image-20240414180449705.png)
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/46a36f3a3a9dc1600d21025080c63c3d.png)
 
 ### Listwise的优化
 
-
-
-![](https://javaedge-1256172393.cos.ap-shanghai.myqcloud.com/image-20240414180547671.png)
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/d11518137f7d823c5e26a31246a45c06.png)
 
 指示函数做近似：
 
-![image-20240414180613515](/Users/javaedge/Downloads/IDEAProjects/java-edge-master/assets/image-20240414180613515.png)
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/bc7a9bb034683c429a791e902c8b34b4.png)
 
 最终loss function：
 
-![](https://javaedge-1256172393.cos.ap-shanghai.myqcloud.com/image-20240414181059672.png)
-
-
-
-![](https://javaedge-1256172393.cos.ap-shanghai.myqcloud.com/image-20240414181113460.png)
\ No newline at end of file
+$$
+\begin{align*}
+\hat{\pi}(x) &= 1 + \sum_{y \in X, y \neq x} \frac{\exp(-\alpha s_{x,y})}{1 + \exp(-\alpha s_{x,y})} \\
+NDCG &= N_n^{-1} \sum_{x \in X} \frac{2^{r(x)} - 1}{\log_2(1 + \hat{\pi}(x))}
+\end{align*}
+$$
+ 效果对比：
+
+| model                        | FAQ ACC@5 | 文档 ACC@5 | 混合数据 ACC@5 |
+| ---------------------------- | --------- | ---------- | -------------- |
+| bge-reranker-large(开源SOTA) | 90.26     | 75.98      | 77.17          |
+| Our Model                    | 93.76     | 83.20      | 81.21          |
\ No newline at end of file
diff --git a/docs/md/AI/agent/ai-agents-dont-security-nightmare.md b/docs/md/AI/agent/ai-agents-dont-security-nightmare.md
new file mode 100644
index 000000000..23ca41dc0
--- /dev/null
+++ b/docs/md/AI/agent/ai-agents-dont-security-nightmare.md
@@ -0,0 +1,79 @@
+# AI智能体不一定是安全噩梦
+
+AI智能体（AI agents）正成为下一波关键的人工智能发展趋势。在经历了两年多的生成式AI热潮后，业界的关注开始转向那些能够自主执行操作的AI系统。
+
+不过，目前这类技术尚未广泛应用。一项由Capgemini开展的调研显示，只有10%的受访企业高管表示他们目前正在使用AI智能体；但有50%计划在2025年部署，三年内这一比例预计将达到80%。这表明，企业不仅对提升流程自动化充满期待，而且已经在积极筹备落地计划。
+
+然而，尽管AI智能体在提升运营效率、加速企业工作流方面潜力巨大，但它也带来了不少风险。如今正是一个关键时刻：如果在没有充分考虑的情况下仓促采用这项技术，可能会破坏它的长期价值。
+
+那么，AI智能体的风险到底有哪些？如果它真有可能成为安全隐患，我们又该如何应对？
+
+## 什么是AI智能体？它与以往的AI有什么不同？
+
+要理解AI智能体的风险，首先得搞清楚我们到底在说什么。实际上，“AI agent”这个术语在业内有多种不同解释。
+
+我们可以把AI智能体理解为一种算法系统，它不仅能够根据数据做出决策，还能基于该决策执行相应的动作。虽然它与生成式AI存在一些相似之处，但最大的区别在于，智能体不是生成内容，而是执行行为。
+
+值得一提的是，这项技术其实并不像炒作那样新鲜。从视频游戏到机器人流程自动化（RPA），算法智能体在多个领域已经存在几十年。如今的不同之处在于，它们的应用范围变得更广。虽然还没达到通用AI的程度，但已经可以基于简单的指令完成相当复杂的一系列操作。
+
+也正因如此，如今的AI智能体激发了技术专家和企业领导人的想象力——它们似乎具备了解决复杂问题、完成具体任务的能力。
+
+## AI智能体存在哪些安全风险？
+
+那么，AI智能体到底有哪些安全隐患？大致可以分为两个技术层面的风险和一个社会层面的风险。我们逐一来看。
+
+### 数据泄露
+
+一个可能更严重的风险是**数据泄露**。AI智能体依赖于访问各种信息源，它需要与不同的服务进行交互，在必要时收集和共享数据，以完成任务。
+
+这种在问题各个环节间灵活流动的能力虽然是AI智能体的一大优势，但“流动性”本身却往往与“安全性”背道而驰。想一想：安全的核心本质其实就是对访问权限的限制——谁能访问什么，何时访问。
+
+一个穿越组织边界、甚至在组织内外自由活动的AI智能体，其数据传输过程往往难以追踪。哪怕是一个看似简单的旅行预订任务，也可能涉及到员工或组织的敏感信息被传递给了谁、传到了哪里等安全问题。
+
+### 缺乏问责机制
+
+在上述技术性风险之外，还有一个贯穿始终的核心问题：**AI智能体缺乏问责机制**。我们可以从两个角度来看“问责”：一个是任务执行方面，一个是产品法律责任方面。
+
+#### 任务执行责任
+
+任务层面的问责机制听起来很简单但却至关重要。比如，你让一位旅行社工作人员帮你订假期，或让团队成员维护某个系统模块——如果任务没完成，责任归属清晰明了，可以调查原因、追责或升级处理。这种责任机制在人与人之间虽然不总是舒适，但逻辑非常清晰。
+
+但AI智能体就不同了。在某种意义上，它似乎将人类从责任链中剥离了出去。它不受约束，也没有现成机制确保它的行为是正确的；一旦出错，既无法问责，也很难追踪问题根源。因此，看似无摩擦、无缝接入的AI智能体，在没有配套问责机制的情况下，可能会带来一系列意想不到的后果。
+
+#### 产品责任
+
+另一个类似的问题是**法律责任归属**：当AI智能体未按预期完成任务或出现错误时，责任到底该由谁承担？目前法律对此缺乏明确界定。虽然像欧盟的《AI法案》正在尝试让组织对AI的使用承担更多责任，但这些新规是否能适用于如今不断演进的AI技术，还不清楚。
+
+目前，大部分法律都倾向于将责任归于人类行为者。例如，在自动驾驶领域，AI智能体的决策直接影响人身安全，因此人类用户往往要承担最终责任。
+
+从企业角度看，这种做法似乎减轻了机构负担，但中期来看可能弊大于利。试想：一旦普通用户需要为系统的每个决策负责，信任度就会迅速下降，从而严重影响AI智能体的广泛落地与应用。
+
+## 不加思索地过度热情，会加剧AI智能体的安全问题
+
+AI智能体的安全隐患，往往因为人们的盲目乐观和急于部署而被放大。
+
+比如，现在很多组织把AI智能体用于处理重复性操作，如将数据从一个系统转移到另一个系统。这类任务虽然繁琐，但其实通过构建更好的API或自动化工具也能高效完成，而且这些方式更易于测试与维护。
+
+换句话说，很多时候是因为急于解决琐碎问题，才不必要地引入了安全风险。
+
+## 如何应对AI智能体带来的安全挑战？
+
+面对这些风险，我们可以采取多种方法来应对。
+
+首先，要认真评估AI智能体的适用场景。是否一定要使用智能体？如果一个设计良好、经过充分测试的API能更高效、安全地完成任务，那可能是更优选择。
+
+但如果确实需要使用AI智能体（未来很多企业也的确会发现某些场景适合使用它），那么就必须秉持良好的工程实践，尤其是在测试和安全方面。
+
+这意味着在项目早期就要引入**风险分析**和**威胁建模**等流程。更深入地看，还需要通过不断测试与探索来了解智能体的行为。虽然目前该领域尚未形成统一标准（这本身也是一种风险），但团队可以通过设计各种测试场景，试图干扰、误导智能体，从而找出其弱点与漏洞。基于这些测试结果，可以进一步设计“控制机制”（类似于当前生成式AI中常用的“护栏”机制），限定智能体的活动范围，确保其行为在可控范围内进行。
+
+## 提前测试与整体思维：保障AI智能体安全的关键
+
+最终，若想让AI智能体既安全又真正发挥作用，有两个核心要素必须重视：
+
+首先是**战略层面的整体思维**：不要把智能体视为解决一切问题的“万能钥匙”。它只是工具箱中的一种工具，应该与生成式AI、新API等其他手段协同配合，共同提升团队效能。
+
+其次是**工程层面的良好实践**：从开发早期就要开展必要的安全分析，并在各个层面持续测试智能体的行为。
+
+**虽然这可能会增加一些开发成本和流程复杂性，但从长远来看，它能帮助AI智能体真正为组织带来价值。**
+
+你希望我帮你提炼出一份更简洁的摘要吗？
\ No newline at end of file
diff --git a/docs/md/AI/agent/improve-quality-gen-ai.md b/docs/md/AI/agent/improve-quality-gen-ai.md
new file mode 100644
index 000000000..1d91dcfae
--- /dev/null
+++ b/docs/md/AI/agent/improve-quality-gen-ai.md
@@ -0,0 +1,220 @@
+# 如何提高生成式 AI 生成代码的质量以及团队协作的效率
+
+## 0 要点
+
+- 编程助手领域正在迅速发展，主要分为：基于 VS Code 的工具（如分支或 CoPilot）、传统 IDE 巨头（如 JetBrains）和其他工具。大多数创新发生在 VS Code 领域，主要由新公司推动，而 IDE 公司则进展较慢
+- 生产级代码仍需人类的关注和专业知识。完全依赖生成式 AI 工具的人可能会暴露于严重的安全漏洞。如果你不知道自己在做什么，其严重性会呈指数级增长
+- 生成式 AI 会无差别地放大问题：无论你是否犯错，它都会放大。在“通往生产”的道路上，遵循最佳实践比以往任何时候都更为关键，以确保规范和验证由人类监督和认可
+- 尽管有时看起来像 AI 编码器在学习，但这只是统计。为了提高成功的概率，你需要提供反馈，并通过提供更多更好的信息来提高上下文的质量
+- 反馈循环比以往任何时候都更为重要，以确保你构建的软件为用户提供所需的功能
+
+Thoughtworks AIGC 领域专家 Birgitta Boeckeler。
+
+## 1 编程助手领域的快照
+
+你通常会在 Martin Fowler 的博客上撰写文章，提供生成式 AI 领域的最新发展动态。那么，让我们先来说说有什么新动态，因为在我看来，生成式 AI 领域的更新速度甚至比 JavaScript 库还要快。我们才眨了一下眼，可能在那段时间里生成式 AI 领域就出现了两个新工具。
+
+### 啥是新的？
+
+这几乎是现在经常被问到的问题，即使我目前全职负责跟踪这个领域，我也不可能掌握所有的东西，对吧？所以，如果其他人不能在日常工作中做到这一点，也不必感到难过。而且我在演讲中说过的一件事是，演讲结束后的一个小时，我在网上看到它已经过时了。所以，这就是目前这个领域的问题，对吧？但当然，有一些事情开始变得更加稳定，或者现在工具中出现了某些模式。
+
+所以，当你回顾编程助手功能的演变时，我们首先有了自动补全，然后是加强版的自动补全，接着我们有了简单的 AI 聊天，然后聊天变得越来越强大。所以，在像 Copilot 或 Cursor 或 Windsurf 或其他许多工具这样的编程系统中，聊天现在也有了更多关于我们的代码的上下文，我们实际上可以询问整个代码库的问题。而且，有很多上下文提供者，我们可以如何引入当前的 git-diff 或更多与事物的集成，比如给我当前 JIRA 问题的文本等，当然，模型也在不断发展。
+
+让我们简化一下。让我们考虑趋势，工具的更新速度很快。一切都变化得如此之快，以至于很难跟上，但你可以将它们归类。我们与之交互的方式。我不太喜欢在浏览器中进行聊天，然后从一边移到另一边，或者我不太喜欢我们只是提供评论的部分。最好是以这种方式看待它。
+
+目前，我们正处于与模型交互的阶段，我们有了创新的自动插入功能，或者我们应该如何定位自己，当我们只是说，“让我们称它为一个自主的初级开发人员在我们身边。”我们是不是已经到了那一步，或者我们还没有？
+
+是的，可稍后讨论这个自主的初级开发人员是否真的自主。自去年 10 月、11 月以来，最新发生的事情是 IDE 或终端会话中的聊天，也有一些从终端进行的编程助手。让我们现在专注于 IDE，这个聊天现在变得非常强大，以至于你可以真正地从聊天中驱动你的实现，聊天现在可以同时更改多个文件。
+
+它可以运行终端命令。它基本上可以访问 IDE 可以访问的很多东西。这就是提供更多的自动化的东西，比如说我的编程助手生成的代码甚至无法编译或存在语法错误，对吧？所以通常在过去，我不得不去那里告诉它，这无法编译，但现在它实际上可以通过 IDE 捕获像代码检查错误或编译错误之类的东西，并且能够立即做出反应并自我纠正。
+
+或者它可以这样说，好的，让我们运行测试，然后它会立即发现测试是红色的还是绿色的，我们能够将这些纳入它的操作中。所以，这正是现在让人们使用“代理”这个词来称呼这些工具的原因。所以这就使它具有了代理性，对吧？所以我认为目前还没有一个很好的关于什么是代理的全面定义。我认为我们总是在我们所处的上下文中重新定义这个词，对吧？但在编程助手的上下文中，它是我们 IDE 或终端中的一个聊天，可以真正访问所有这些工具，比如编辑文件、运行终端命令等等。然后，是的，以一种更自动化的方式为我们做事，而我们仍然在看着它们。
+
+## 2 基于 VS Code 的代码助手与 JetBrains 家族 IDE 的插件
+
+我们正在变得更加自主。它需要的交互更少了，因为有时候你需要来回多次才能得到你想要的结果。但现在，似乎这一切都在迭代中发生，而不需要我们太多的输入。那么，让我问你另一个问题，因为我们正在泛泛地讨论 IDE。现在，从我的理解或者我看待这个领域的方式来看，这里有一些大玩家。你有 JetBrains 的，比如 Java 世界的 IntelliJ IDEA，你有 PyCharm 和整个家族。
+
+这些在 IDE 方面相当有影响力。然后你有 VS Code，这是微软的 Visual Studio 的小兄弟，也是微软的产品，并且被广泛使用。然后，还有一些新出现的工具，我还没有尝试过，比如 Windsurf 和 Cursor 等等。根据你的经验，他们在引入这些新使用方式方面是如何排名的？首先，一个更好的问题可能是他们是否从外部模型或外部插件中获得支持。我现在想到的是 JetBrains，另一方面，它们有原生支持。
+
+目前，大多数编程辅助行动实际上正在 Visual Studio Code 中发生，特别是如果你把 Windsurf 和 Cursor 也视为 Visual Studio Code，因为它们实际上是 Visual Studio Code 的分支。据我所知，他们分支或克隆的原因是，这给了他们更多对 IDE 核心的访问权限，因此他们可以构建更强大的功能。但因为很多这种进步，我会说，是关于与 IDE 的集成以及 IDE 中的开发人员体验、用户体验的。
+
+当你完全访问 IDE 的核心时，你可以做很多事情。所以，微软和 GitHub 有优势，因为他们拥有 Visual Studio Code。对于 GitHub Copilot，他们也可以深入到它的核心。但随后 Cursor 和 Codeium，他们构建了 Windsurf，分支出来，以便他们对这个有更多控制权，对吧？然后，在 JetBrains 那边也有一些事情发生，这对我来说和我的同事们来说是个大事，因为 JetBrains 一直是 Java、Kotlin 以及一些基于 JVM 编译器的语言的首选 IDE，对吧？
+
+所以，大组织开始为 IDE 许可证付费，因为它非常好，对吧？在那之前，它一直是免费的，不是吗，像 Eclipse 和类似的工具？不幸的是，在 JetBrains 生态系统中，事情进展没有那么快。例如，GitHub co-pilot 插件和 JetBrains 经常在功能上落后于 VS Code 插件。JetBrains 自己正在构建的东西也仍在进行中，所以他们没有在构建代理，例如，但进展有点慢。所以，这是有时减缓了编程系统采用的一个因素。
+
+这也阻止了一些开发人员进行实验，因为他们是 JetBrains 生态系统的一部分，并且更喜欢它。还有关于 JetBrains 辅助功能实际上强大的地方还有很多需要探索的地方，JetBrains 辅助功能在某些用例中已经足够强大，也许你甚至不需要 AI，对吧？但是，JetBrains 生态系统有点落后。目前，大多数行动都在 Visual Studio Code 中发生。还有基于终端的编程辅助工具。所以 Anthropic 最近发布了 Cloud Code，例如，你可以在终端中运行。
+
+有一些开源工具像 Goose 和 Aider 也可以做到这一点。所以这些通常是开源的。就目前使用的模型而言，我认为我使用过的几乎所有编程辅助工具现在都允许你插入自己的 API 密钥，以便实际使用来自例如你的 Anthropic API 密钥或你的 OpenAI API 密钥的模型。特别是，它们都支持某种方式访问 Claude Sonnet 模型系列，无论是由你提供 API 密钥，还是由他们从 Anthropic 提供，因为 Claude Sonnet 系列已被证明在编程方面非常出色。
+
+所以，当我尝试不同的工具时，我通常使用 Claude Sonnet 作为模型，以便至少在那部分是稳定的，这样我就可以进行比较，因为你总是必须使用这些工具几次，直到你对……只是对它有一个感觉，这个感觉是否比那个其他工具更好，对吧？很难只通过一两次测试就说这个现在更好或这个现在更差，对吧？所以是的，Claude Sonnet 模型系列，Cursor 和 Windsurf，我认为是最受欢迎的。还有一个开源的 VS code 扩展叫做 Cline 和一个 Cline 的变体叫做 Roo Code。所以这四个，我认为是目前代理领域最受欢迎的。
+
+### 小结
+
+在工具方面，也就是在锤子方面，目前，分支或者微软 GitHub 是领先的。我们也可以知道为什么允许评论，鉴于 GitHub Copilot 已经领先好几年了，每个人都很早就开始了。然后，还有一些新出现的工具，而像 JetBrains 家族这样的传统工具，在代理编程方面，用引号来说，落后了。
+
+当你看到 Cursor 和 Windsurf 时，Cursor 自从存在以来，总是提出一些关于用户体验的真正有趣的新想法。然后，几个月后，你总是会看到 GitHub Copilot 有一个类似的功能，对吧？所以，Copilot 因为很多组织已经在 GitHub 上托管代码，所以他们已经信任 GitHub 与他们的代码，所以更容易做到这一点，对吧？然后，他们通常是其他 IDE 中有趣功能的追随者，至少从外部看起来是这样。
+
+Codium 之前的一些工具。他们在审查领域有很多工具，在测试领域也有很多工具。他们总是给人一种走在前沿的感觉。现在，他们似乎在某种程度上缩小了差距。但是现在，我想到这一点，我们实际上跳到了问题的中间，因为我们开始讨论编程。
+
+但实际上，如果你看看一个项目的周期，通常你会从构思阶段开始，等等。然后，你会开始引导项目，这只会发生一次。但我在想这一点，因为作为一家公司或咨询公司，我们每年至少要引导几次新项目。然后，这促使我问一个问题，关于这些所谓的无代码工具，或者在编程辅助的中世纪时代，他们称之为可爱的工具，我不知道，还有一些其他的。我也尝试过用 Copilot 引导项目。
+
+## 3 “无代码”工具，如 Replit，适用于原型设计，尤其是它们与无服务器的交叉
+
+Q：你的感觉是什么？你提到的工具，如 Cursor、Windsurf，甚至是 VS Code，在引导新项目方面是否也很好，或者我们应该转向其他东西，进行原型设计，看看它在市场上的反应，然后再转向一个更传统的空间，在那里你只是开始编码？
+
+是的，我没有怎么使用过像 Loveable、Bolt、Replit 这样的工具，因为它们通常也带有一个平台即服务，对吧？所以你可以立即部署它们。而且通常，我们的客户类型，他们没有这样的部署环境。所以他们有他们自己的环境。但我看到我的同事们主要用这些工具来制作原型，对吧？还有非编程人员，比如设计师之类的人，使用这些工具来快速制作一个真正可工作的原型。然后，我听到的大多数人都说，当他们查看代码时，他们觉得代码仍然很“原型化”，所以他们不想将其投入生产。
+
+但尽管如此，每个人对这些工具在原型设计方面的表现都印象深刻，但我自己没有尝试过。
+
+### 小结
+
+我们可以利用它们来加快构思阶段的进程。所以，与其在传统领域中使用有限选项的模拟，你可以快速构建一个类似原型的东西，收集反馈，然后回到更传统的空间，在那里你提前制作功能。
+
+这也取决于用户。我几周或几个月前读过一篇关于 Replit 的文章，他们有意识地决定不将程序员作为他们的主要受众，而是针对非程序员。这个策略的一部分也是倾向于利用无服务器部分在路径下，对吧？所以他们也可以为你启动一个数据库，然后连接一切，对吧？因为这是非程序员真正挣扎的地方，他们使用编程辅助工具，如 Cursor、Windsurf 或 Cline，这些工具构建了所有的代码，然后，他们不知道，是的，但数据库怎么办，它会安全吗，对吧？
+
+所以，我认为这个空间很有趣，值得我们关注，看看你实际上如何为非程序员创建一个安全的环境，利用无服务器和 AI。我不知道它是否会实现，但它当然可以填补一些基础设施知识方面的空白，当然，非程序员也没有这方面的经验。
+
+## 4 在软件开发生命周期的各个阶段使用生成式 AI
+
+**Olimpiu Pop**：这让我想到，我们在你的演讲中提到的一个轶事，关于那个家伙在几个小时内制作了一个 SaaS，然后，当他意识到他的代码不适合生产时，他开始哭泣。所以，这就是我们应该如何对待这些工具。它们是原型，但它们忽略了像操作安全性、安全性、可扩展性等等这样的东西。所以，最好能够将它们分解成更小的部分，并像我们所知道的那样构建它们，以使其足够安全和稳健，以便在现实生活中使用。
+
+好的，现在我们触及了我们目前所拥有的内容，但再次强调，这个周期比这更长，通常被称为 SDLC，因为现在我们必须称它为经典，尽管我们没有看到它被正确采用，但现在我们必须称它为经典。那么，SDLC 现在有多重要呢？因为在我脑海中，它一直是一套最佳实践。你必须进行测试，你必须实施单元测试。你认为一个适当的 SDLC 实施将如何帮助采用代理式或如今被称为的编码，或者我们应该依赖于编辑 AI，然后有人会接手我们的问题？
+
+**Birgitta Böckeler**：对我来说，SDLC 或软件交付生命周期只是一个描述，即有多个阶段，如果没有更好的词的话，当然，我们所说的并不是瀑布模型，而是许多、许多、许多阶段以敏捷的方式进行小迭代，对吧？对我来说，这只是一个描述我们通常做事方式的术语，对吧？我想，作为一个行业，我们现在必须质疑的是，既然有了这些新工具，这是否改变了任何东西，对吧？例如，我们可以跳过这些阶段中的任何一个吗，还是其中一些变得更加重要或不那么重要，或者这些阶段中哪些最适合使用 AI，哪些不太适合使用 AI，对吧？
+
+所以，在这个意义上，这个概念仍然非常有用。而且这也很有趣，因为我已经很久没有听到 SDLC 这个缩写词了，直到 AI 再次出现，突然间，我周围的人都开始再次使用这个缩写词。我不知道为什么会这样，因为我认为作为一个行业，我们一直在循环中，对吧？我们又开始审视我们所做的一切，质疑一切，并真正回到我们实际上在做什么以及 AI 对此意味着什么？
+
+所以，这又是我们行业的一个反思时刻，我们似乎每 10 年左右就会经历一次这样的时刻。到目前为止，我还没有看到任何……当然，有很多关于让我们自动化整个过程或让我们自动化整个开发部分的实验，但随后，规范是非常重要的，人类必须去做。那么，验证呢？我们也希望 AI 来做吗，还是说这整个过程是人类指定机器构建，然后我们再次验证，会是这样吗，对吧？
+
+而且，根据我们目前所拥有的以及我们仍然面临的挑战，这些挑战我们甚至还没有谈到，因为这些编程助手目前还不能真正为你自主构建一个完整的功能，但我们也许可以在几分钟后讨论这个问题。是的，所以，就目前而言，我看不到一种方法可以完全自动化整个过程，对吧？特别是当涉及到规范时，当涉及到测试以及真正知道测试是否真的检查了我们真正做的事情时，对吧？所以，我认为测试领域必须发生很大的变化，或者目前正在发生变化，对吧？
+
+是的，所有这些问题，我应该让 AI 生成我的测试，然后，我是否知道它实际上做了什么，对吧？然而，你当然可以在某种程度上或另一种形式中使用 AI 来应对所有这些小阶段和任务领域，因为这是一项非常基于语言的工作。
+
+**Olimpiu Pop**：我必须提到去年的一个主题演讲。我们有 Trac Bannon，她谈到了 SDLC 的空间。她花了很多时间研究我们如何增强它。我记得她也有类似的研究在进行。她说，好吧，修复你的 SDLC，意味着在持续部署领域设定一个目标，你需要有自动化的测试，你需要有检查措施来确保所有阶段都得到妥善遵循，然后你才会处于更安全的一方。
+
+关于测试，要么先生成测试再编写代码，要么反过来，不要用生成式 AI 同时做这两件事，因为那样会偏向于生成式 AI，不左不右。
+
+**Birgitta Böckeler**：这可能取决于具体情况，是的。而且，我想说的是，我也看到一些我们的客户问，“哦，我们如何使用 AI 来解决我们在生产路径上遇到的所有问题，对吧？”生产路径也许也是 SDLC 的一个好词，对吧？而且我认为，当把它当作创可贴使用时，可能会非常危险，但你实际上有根本问题需要在你的交付管道或测试过程中修复，对吧？因为否则，它可能会成为一个实际上使事情变得更糟的创可贴，对吧？是的，因为生成式 AI 会无差别地放大。
+
+它可能会放大你所拥有的东西。如果那真的很糟糕，或者核心部分有问题，那么这可能会成为一个问题。另一点是，因为我们所做的事情是一个复杂的系统，如果我们只是增加其中一个环节的吞吐量，比如通过编程助手来提高编程的速度，那么我们会在其他地方遇到瓶颈和其他二阶效应，对吧？所以，如果你可以更快地编写代码，你也可以更快地审查代码吗？你可以更快地填充积压任务吗？你可以更快地创建设计吗？你可以足够快地部署它吗？你会有更多技术债务吗？如果你有更高的功能吞吐量，你如何进行产品管理，当你有更多的功能时，对吧？
+
+而这些事情中的一些我们可以在其他领域用 AI 来缓解，但有些事情，你不能仅仅加快机器的速度，如果你没有一个好的底层流程，摩擦力很小。
+
+Q：AI 是一个加速器。如果你朝着正确的方向前进，你会更快到达那里。但如果你面前有很多坑洼，你就会有更多的膝盖和脚踝受伤，因为它会以同样的方式更快地前进，但你会有更多的问题，对吧？
+
+是的，因为它的非确定性，如果你不知道自己在做什么，那么它可能会使情况变得更糟，风险更高，是的。
+
+## 5 如何在日常编程中使用代理式 AI
+
+**Olimpiu Pop**：但我们之前确实有一个观点，你说存在挑战。那么现在，考虑到一个普通开发人员的日常工作，一个知道自己在做什么并且了解局限性的经典开发人员，我们可以做些什么，我们能做什么，我们不能做什么。
+
+**Birgitta Böckeler**：关注一下我们一开始谈到的这些代理模式，它们现在比以前更强大了，是我们 IDE 中的伴侣，我可以这样说，我在页面上需要一个新的按钮，当用户点击它时，会发生以下事情，然后 AI 去为我更改一个、两个、三个、十个文件，并为我创建一个测试，等等，等等，对吧？所以，首先，我要说的是，它不能自主运行。它必须受到监督。作为一名开发人员，我仍然坐在它面前，实际上看着这些步骤，在我看到它走向我不希望的方向时进行干预。
+
+所以，特别是对于较大的非琐碎的事情，我还没有看到一个代理在没有我的干预下自主地做任何事情，对吧？我是说，最简单的事情是如果结果甚至无法工作，但那是显而易见的，但还有更隐蔽的事情关于设计，可能会使它在未来变得不那么可维护和可扩展，或者我谈到了测试，对吧？所以它有时在生成测试方面相当不错，但它也可能给人一种虚假的安全感，对吧？所以，我看到它测试不足。然后在另一方面，冗余测试，比如太多的断言或太多的测试方法，这使得测试非常脆弱。
+
+在未来，每次我更改代码时，突然间我可能会有 30 个测试失败，对吧？我是说，谁没有在代码库中遇到过这种情况？通常在测试中，有太多的模拟。它把测试放在错误的地方，所以我将来可能找不到它们。而且，要让它首先运行一个失败的测试，实际上向我展示失败的测试，这样我就可以将其作为审查机制，看看测试是否有意义，这会给我很多关于审查这个的安全感，对吧？但它并没有这样做。
+
+它立即转向实现。所以，这就是整个测试领域，对吧？正如我所说，设计有时也会变得太像意大利面。所以，它就像一个初级开发人员，就像你之前说的。是的，我有很多例子，我的脑袋上亮起了灯泡，就像，“哦，好吧。是的，我明白了它为什么会出错。”然后第二天，当你这样做时，它又做对了。
+
+**Olimpiu Pop**：好的，所以它是根据你的反馈进行学习的，还是——
+
+## 6 编程助手做对的概率：你需要什么
+
+**Birgitta Böckeler**：不，不，它不是。不，不，这只是统计。这是一个概率问题。一次它有效；一次它无效。这与学习无关。是的。
+
+**Olimpiu Pop**：好的，所以你只是在掷骰子。
+
+**Birgitta Böckeler**：有点，是的，然后，所以我们的工作作为开发人员，首先，我们当然必须评估在这种情况下使用 AI 是否值得。它是否让我更快还是更慢？所以我们还必须知道何时停止。我经常使用它来尝试一些我知道我没有很好地描述的东西，但让我们看看它会做什么。然后这有助于我思考设计，对吧？然后，我撤销并重新做。我要么自己做，要么……所以我们必须评估我们如何增加它做我想做的事情的概率，我们可以通过提示来做到这一点。
+
+我们可以通过像自定义规则这样的功能，通过拥有良好的文档，基于代码的东西，等等。所以，我如何增加概率？但我们永远不能保证它总是给我们我们想要的东西。
+
+**Olimpiu Pop**：好吧，这很公平。很长一段时间以来，我一直在关注这个领域，并传播像与 AI 进行结对编程这样的想法，当我编写代码时，它在这里生成测试。但随后我开始思考并挑战自己，因为如果它只查看我的代码并生成测试，正如你所说，它只会根据我正在做的事情生成绿色测试。所以，如果我在代码中引入了一个缺陷，那么我就没有任何方法知道这是有问题的。
+
+**Birgitta Böckeler**：没错。是的，我也看到它做这样的事情，我说，“哦，测试失败了”，然后，它怎么知道是需要修复测试还是修复代码呢？有时它会反过来做，如果你不注意，它实际上会在代码中引入一个错误。是的。
+
+**Olimpiu Pop**：好的。那么我如何增加生成适当代码或适当需求的概率，仅仅将它们作为上下文提供是否会有帮助，或者是否有可能将来自客户的需求，无论什么，团队的业务分析等纳入其中，以使其变得更好？
+
+**Birgitta Böckeler**：从技术上讲，现在有越来越多的方法可以与上下文提供者集成，对吧？就像我之前提到的 JIRA 票据等，从技术上讲，使它更方便地拉取进来。但当然，这仍然取决于这个票据是如何措辞的。谁没见过那些只说“修复按钮”的 JIRA 票据，或者我不知道。我一时想不出更好的例子，对吧？所以，通过更具体地说明你想要什么，可以增加概率，对吧？我听说过这个，并且与每天在生产代码库中使用这些工具的同事确认过。
+
+当他们向我展示他们用它实现的例子以及他们如何向 AI 描述时，这通常是相当具体的，对吧？所以这里是我需要在 UI 上的五个字段，这是我们的数据库模式。所以这是一个相对较低的层次，这增加了概率，对吧？这当然也增加了你必须花费在用自然语言而不是代码描述它的时间。但在这些情况下，它仍然常常让我觉得它减轻了我的认知负担，使用 AI 并花费时间描述所有这些细节是值得的，对吧？
+
+这是增加概率的一种方式：已经有一个计划。
+
+**Olimpiu Pop**：很好，谢谢。现在，我必须回到你之前说的一件事。你提到了 SDLC 中的验证阶段，但我们刚才也谈到了测试。现在，我在想，如果我在思考代码，我就会想到测试。我在解决方案层面思考解决方案。在这种情况下，我会想到验证，我的感觉是，在参加了 QCon 和这段时间参加的其他会议之后，我的感觉是验证变得非常重要，尤其是在 AI 领域，因为当我们谈论 AI 是黑箱的时候，我们不能谈论测试。
+
+因为我们没有一个适当的接口，但我们谈论验证。这把我推向了一个全新的层面。关于这一点，你有什么想法吗？
+
+**Birgitta Böckeler**：是的。一般来说，当我们使用这些工具时，我们总是必须考虑我的反馈循环是什么，对吧？当 AI 为我做某事时，我的反馈循环是什么，以便快速知道这是正确的事情，对吧？它可以是一些小事情，比如 IDE 现在为我做了一些事情，对吧？当语法完全错误时，IDE 会告诉我，这只是一个非常低层次的例子，对吧？然后，抽象层次越高，我作为人类就越需要参与其中。这甚至延伸到了我们应该是编写测试的人，然后 AI 做其他所有事情的想法，对吧？
+
+例如，Dave Farley 的 Continuous Delivery YouTube 频道上有一个视频。我想我们现在把它叫做 Modern Software Engineering YouTube 频道。我不记得标题是什么了，但他正在谈论推测，测试是否将成为未来的规范、未来的编码，对吧？所以我们将编写测试，其他一切都是由 AI 完成的。因为我们编写了测试，我们必须在测试中非常具体，所以我们必须给出一个非常具体的规范。这就是我们如何知道它是否有效，而这将是我们在未来所做的一切，对吧？
+
+编写测试就是编码。所以这是他的一种推测，我觉得这很有趣。
+
+**Olimpiu Pop**：好吧，我不能说我不同意这一点，因为最终，有很多变化。如果你想想肯·贝克和他的 TDD，这在低层次上非常好，你只是编写代码和整个架构，但那是在很小的增量中。现在，如果你看看那个，我们可能正在看一个不同的层次。它可能更像是 BDD，行为驱动开发，你只是提前考虑一切。我不得不承认，我尝试和一些产品经理一起做这件事，让他们这样做，然后，尝试模仿某种 DSL 并生成大块代码。
+
+但除此之外，我的感觉是，现在比以往任何时候都更重要的是拥有产品开发思维，你要思考整个事情并理解它。但我们现在讨论的所有内容，这些都是通过试错学到的东西。你需要成为一名经验丰富的开发人员，才能理解这一点。而当我提到经验丰富时，我指的是两件事。其中之一是编码和构建软件的方式，但你也要了解你所从事的行业以及规则和事物的运作方式。
+
+## 7 软件开发职业阶梯可能会改变
+
+你不能是一个初级开发人员并成长为做那件事。那么我们对初级开发人员怎么办？我们只是取消了初级开发人员的头衔，然后说每个人都是高级开发人员，或者你如何帮助他们达到这个位置？
+
+**Birgitta Böckeler**：高级别的含义可能会改变，对吧？是的，但我的意思是，这确实是一个经常被问到的问题。当我参加 QCon 会议时，人们总是问我这个问题，部分原因是我也不知道，我们得等着看。我总是说，我不想美化我过去学习的方式，然后说，“哦，年轻人，他们会做错的。”我从互联网上复制了这么多东西，只是尝试一下，它是否有效，甚至在我查看我粘贴的代码之前，说实话。所以这只是我觉得现在有更多的吞吐量，速度更快，对吧？
+
+所以，我们将不得不看看团队如何缓冲这种情况。通常，团队中的高级人员会缓冲这种情况。如果有人因为不知道而犯了错误，团队中的其他人可能会抓住它，对吧？但现在，如果错误的吞吐量增加，你还能用你的团队缓冲它吗？我想，这是一个问题，尽管我希望今天，你仍然可以通过做错事情来学习，就像我们过去那样，然后它被你周围的自动安全网和人员抓住。
+
+然后，我从中学到了东西。所以，我希望它能继续这样下去。而且，通常那些担心初级开发人员的人并没有真正使用过 AI 工具。所以，我认为对于经验丰富的人员来说，即使你持怀疑态度，我理解这一点。我也会在兴奋和怀疑之间摇摆不定。我们必须使用这些工具并理解它们的含义，因为你不能仅仅从会议演讲或手册中了解它，这样当新来的人进来并使用这些工具时，说实话。
+
+然后，当我们告诉他们不，你不能用 AI 这样做时，他们会说，为什么我应该信任你？你甚至不使用这些工具，对吧？所以我们必须自己使用它们，这样我们才能了解风险在哪里，并帮助新来的人，我们一起经历这种认知转变，并希望以一种负责任的方式发展我们的实践。
+
+**Olimpiu Pop**：好吧，这很公平。所以，在听你说话的时候，我在想如何让人们跟上速度，并有一个合理的年轻开发人员与资深开发人员的比例。当时我想到了一种方法，而不是生成大量关于如何进行数据库操作、如何编写代码等的文档，将所有这些信息整合到，我们称之为 CLI 中，如果这对你有帮助的话。我不知道，让我们在云端创建一个数据库。你给它一个大小，一个名称，然后就生成它。
+
+我想象的是，初级开发人员，一个年轻人，或者甚至是一个刚刚加入项目的人，可以使用这个工具，说一些事情已经完成，或者如果涉及到编码，就去验证它。然后，随着时间的推移，他开始理解它。他得到了一个视角，然后他可以开源查看这个工具是如何构建的。他发现了一个错误，他修复了它。你认为这种方法，我们在做的一切周围都有护栏。最初，你只是遵循规则，然后当你达到那个水平，当你理解现状时，你可以挑战它。你认为这种方法会有效吗？
+
+**Birgitta Böckeler**：是的，也许不会完全修复它们，但当然，我们一直拥有的安全网，我们需要比以往任何时候都更加重视它们，也许在我们的管道中以及我们能自动化的所有方面。但你实际上提出了一个很好的观点。人们通常只关注初级开发人员带来的风险，但也有这么多新的机会，让他们更快地学习，更快地发现信息，而不总是不得不向更高级的人提问，对吧？所以，你举了例子，也许你可以有描述和文档，你实际上也可以将它们输入到 AI 中。
+
+所以，作为一名更高级的开发人员，你可以通过为团队中的其他人提供编程助手的自定义规则，实际上放大了某些约定。你也可以将这些自定义规则作为人类来阅读，以了解这个团队是如何编码的。我们也在 Thoughtworks 实验这些提示库，用于实践，而不仅仅是编码。如果你想象我最喜欢的例子，总是威胁建模，因为它是安全的，这是一个令人望而生畏的实践。很多人不知道如何去做，所以他们拖延它或者干脆不做，对吧？
+
+但你可以实际上在提示中描述某些威胁建模实践，比如 STRIDE 模型。然后，如果你提供你正在工作的上下文，AI 可以在你的特定上下文中给你一个例子。所以，你不需要阅读理论并将其应用到你的特定问题中。这是其中一个例子，AI 实际上可以帮助我们更快地理解事物，并将其应用到我们的上下文中，这可能对新来的初级人员也非常有帮助，实际上可能帮助他们比我们更快地学习，对吧？
+
+**Olimpiu Pop**：好的，谢谢。还有没有什么其他你认为重要的内容需要强调的？在我们的对话中，有什么是我们需要强调的？
+
+## 8 在生成式 AI 怀疑者和爱好者之间找到正确的平衡
+
+**Birgitta Böckeler**：我现在经常谈到的是，随着自动化水平的提高，或者这些为我们生成更多代码的代理，质量的风险。而且，因为我个人在使用这些工具时总是感觉如此，一方面，感觉很棒，我一直在使用它们，不仅因为这是我的角色，也因为我喜欢它们，但你会陷入这种“它有效”的诱惑。也许我可以直接推送它，对吧？而且我总是发现一些东西，作为一名负责任的开发人员，我应该在推送之前进行更改，因为我也正在处理其他人在代码库上工作。
+
+所以，我必须考虑这将如何影响他们，对吧？他们真的会理解它的工作原理吗？这会阻碍他们正在做的事情吗，或者我们将来能够维护它吗，对吧？但诱惑真的很高，变得懒惰，变得自满，只是想，“啊，它会没事的”。是的，总有太多的东西，我在推送之前发现，是的，你总是必须审查、审查、审查，真正关注，这就像驾驶一辆自动驾驶汽车，你的注意力有点下降，因为你只是让它驾驶，然后当出现问题时，你的注意力没有集中。
+
+这不是一个很好的类比，因为它们的风险特征非常不同，但我发现自己就像这些代理一样，不断地做事、做事，而觉得去审查所有这些代码是一种额外的努力和障碍，因为我们喜欢编写代码，而不是审查代码，对吧？所以，可能很快就会有一个真正的清算，不仅是对于初级开发人员，而且对于高级开发人员来说，我们不再思考。
+
+**Olimpiu Pop**：我认为它已经来了，如果你看看软件供应链恶意代码的传播方式。所以，软件供应链中的威胁每年都在增长。我认为我们已经到了那里。在我和你讨论之前，我就看到了这些数字。2024 年，我们有 70 万个恶意软件包，而在前一年我们只有 250 个。如果你说这只是一个小数字，250 个意味着是前三年总数的两倍。所以，这个趋势正在呈指数级增长，可能比这还要多。所以，我认为正如你所说，清算即将到来，我们必须修复它。
+
+**Birgitta Böckeler**：这是其中一个心理方面。另一个我现在看到的心理现象是，一些组织的文化真的是，每个人都必须使用 AI，否则你为什么这么慢？你有 AI 了。然后是另一端的怀疑者，他们说：“这也很愚蠢。你为什么甚至要尝试这个？”所以，这两种极端观点，还有中间的人，对吧？而且我认为我们现在需要的文化是，爱好者们推动我们前进，而怀疑者们又稍微拉我们下来一点，以了解这个并不要求太快，避免陷入所有这些新的安全漏洞和技术向量等等。
+
+但同时，也不要忽视它，说它会消失，因为它不会消失。所以我们必须都使用它，以了解如何负责任地使用它。我认为需要在这两者之间找到平衡，而且狂热者和怀疑者必须以某种方式合作。
+
+## 9 根据 Thoughtworks 技术雷达评估、采用或搁置
+
+**Olimpiu Pop**：好吧，谢谢。最后，鉴于你是 Thoughtworks 的代表，Thoughtworks 技术雷达是该领域许多人的北极星，甚至被许多人模仿。让我们尝试将 AI 领域的一些东西放在象限上，看看我们应该尝试什么，什么不应该尝试。让我们看看编码，代理编码，你如何看待它？我们应该搁置它、尝试它、评估它吗？我们应该如何拥抱它？
+
+**Birgitta Böckeler**：是的，我刚才还在想我实际上可以查看一下我们现在雷达上的内容。所以，感谢你的推荐，对吧？ThoughtWorks 技术雷达，我们每半年汇总一次我们目前在项目中看到的内容，并将其放入这些环中，如采用、试验、评估和搁置。而且在这个特定领域，我们没有任何东西在“采用”类别中。在编程辅助领域，我认为 GitHub Copilot、Cursor 和 Cline 等目前处于试验阶段。所以，试验阶段是我们使用引号的阶段，我们在生产环境中使用它，对于编程助手来说，这意味着我们实际上在与客户的项目中使用它们来编写生产代码。
+
+Windsurf 也在上面，处于评估阶段。还有你谈到的 Replit 和 Bolt 等工具。我们还有来自 Vercel 的 v0，目前也在评估中，因为我们的团队已经尝试过它。我们在整个环中有一些东西，有时这意味着不要做，或者也可以意味着谨慎行事。其中一个是满足于 AI 生成的代码，我刚才已经谈到了很多。我们还有在搁置阶段用 AI 替代结对编程。Thoughtworks 一直大力倡导结对编程。
+
+虽然 AI 代理可以涵盖结对编程的一些动态，这样你实际上有两个大脑而不是一个，现在有了代理，也许还有这种，代理做战术思考，而我做战略思考。所以它确实涵盖了一些东西，但结对编程实际上是一种让团队变得更好的实践。所以，它涉及到协作、集体代码所有权、上下文共享以及所有这些事情。所以我们不认为它可以被 AI 替代。
+
+而且，对于我们谈到的一些风险，它实际上可以成为一种缓解措施，与 AI 结对编程。所以，有一个结对与 AI 助手一起工作，这也可以是一种非常有趣的技巧，当你在一个团队中有初级开发人员和高级开发人员时，你实际上想看看彼此是如何使用助手的，并从中学习，对吧？
+
+## 10 总结
+
+通过我们整个对话，感觉我们目前还没有被取代。也许明天我们会变得多余，但目前看来，比以往任何时候都更重要的是使用我们的大脑，将我们推向正确的方向，然后找到一个共同点，作为个体在怀疑中的共同点。所以，要谨慎行事，但也接受变化。
+
+参考：
+
+- [开发者技能在代理编码中的作用](https://martinfowler.com/articles/exploring-gen-ai.html#memo-13  )
+- [在组织中采用生成式 AI 之前，先修复你的 SDLC：Bannon 在 QCon London 的行动呼吁](https://www.infoq.com/news/2024/04/ai-sdlc-adoption/  )
+- [将 AI 应用于 SDLC：新想法和陷阱！ - 利用 AI 改善软件工程](https://qconlondon.com/keynote/apr2024/applying-ai-sdlc-new-ideas-and-gotchas-leveraging-ai-improve-software-engineering  )
+- [验收测试是编程的未来](https://www.youtube.com/watch?v=NsOUKfzyZiU  )
+- [STRIDE 模型](https://en.wikipedia.org/wiki/STRIDE_model  )
+- [Vercel 的 v0](https://v0.dev/  )
+- [Roo Code - AI 代理](https://aiagentstore.ai/ai-agent/roo-code  )
+- [技术雷达 | 技术格局指南 | Thoughtworks](https://www.thoughtworks.com/radar  )
\ No newline at end of file
diff --git a/docs/md/AI/agent/introducing-codex.md b/docs/md/AI/agent/introducing-codex.md
new file mode 100644
index 000000000..2ff93176c
--- /dev/null
+++ b/docs/md/AI/agent/introducing-codex.md
@@ -0,0 +1,157 @@
+# 不止是编码：Codex 如何重塑软件工程的未来（现已登陆 ChatGPT）
+
+## 0 前言
+
+Codex 是一款基于云端的软件工程代理工具，能够同时处理多项任务，由 codex-1 提供支持。今天起，它已向 ChatGPT Pro、Team 和 Enterprise 用户开放，Plus 用户也将很快可用。
+
+[Try Codex](https://chatgpt.com/codex)。
+
+仪表盘询问“接下来我们应该编写什么代码？”背景是淡彩色代码主题，带有提示框、仓库/分支选择器和任务列表：
+
+![](https://p.ipic.vip/h6412e.jpg)
+
+今天，推出 Codex 研究预览版：一款基于云端的软件工程代理工具，能同时处理多项任务。Codex 可执行诸如编写功能、回答代码库相关问题、修复漏洞及提出待审核的拉取请求等任务；每个任务都在其自己的云端沙盒环境中运行，预先加载了你的代码库。
+
+Codex 由 codex-1 提供支持， OpenAI o3 的一个版本，专为软件工程优化。通过在多种环境中对真实世界的编码任务进行强化学习训练，生成的代码能够紧密反映人类风格和拉取请求偏好，严格遵循指令，并且可以迭代运行测试，直到获得通过结果。我们今天开始向 ChatGPT Pro、Enterprise 和 Team 用户推出 Codex，很快也将支持 Plus 和 Edu 用户。
+
+## 1 Codex 的工作原理
+
+现可在 ChatGPT 的侧边栏中访问 Codex，并通过输入提示词并点击 **“Code”** 来为其分配新的编码任务。如想向 Codex 询问有关代码库的问题，点击 **“Ask”**。每个任务都在一个独立的隔离环境中独立处理，该环境预先加载了你的代码库。Codex 可读取和编辑文件及运行包括测试框架、代码检查工具和类型检查器在内的命令。任务完成通常需要 1~30min，具体取决于复杂程度，你可以实时监控 Codex 的进度。
+
+完成任务后，Codex 会在其环境中提交更改。Codex 通过引用终端日志和测试输出提供其操作的可验证证据，使你能够追溯任务完成过程中的每一步。然后，你可以审查结果，请求进一步修订，打开 GitHub 拉取请求，或将更改直接集成到你的本地环境中。在产品中，你可以配置 Codex 环境，使其尽可能接近你的实际开发环境。
+
+
+
+
+
+Codex 可以通过放置在代码库中的 AGENTS.md 文件进行引导。这些是类似于 README.md 的文本文件，你可以通过它们告知 Codex 如何导航代码库、运行哪些命令进行测试，以及如何最好地遵循项目的标准实践。与人类开发人员一样，当提供配置好的开发环境、可靠的测试设置和清晰的文档时，Codex 代理的表现最佳。
+
+在编码评估和内部基准测试中，即使没有 AGENTS.md 文件或自定义脚手架，codex-1 也显示出强大的性能。
+
+![](https://p.ipic.vip/zdj7w5.png)
+
+23 个经过 SWE-Bench 验证的样本由于无法在我们的内部基础设施上运行而被排除在外。codex-1 的测试最大上下文长度为 192k 个标记，推理努力程度为中等，这正是今天产品中将提供的设置。有关 o3 评估的详细信息，see [here⁠](https://openai.com/index/introducing-o3-and-o4-mini/)。
+
+我们的内部 SWE 任务基准是一组精选的真实世界内部 SWE 任务，来自 OpenAI。
+
+## 2 构建安全可信的代理工具
+
+我们以研究预览的形式发布 Codex，这与我们的迭代部署策略一致。我们在设计 Codex 时优先考虑了安全性和透明度，以便用户可以验证其输出 —— 随着 AI 模型独立处理更复杂的编码任务，以及安全考虑因素的演变，这一保障措施变得越来越重要。用户可以通过引用、终端日志和测试结果来检查 Codex 的工作。当不确定或遇到测试失败时，Codex 代理会明确沟通这些问题，使用户能够就如何继续做出明智的决策。在集成和执行之前，用户手动审查和验证所有代理生成的代码仍然至关重要。
+
+代码审查截图，带有测试文件覆盖层，验证了带引号的文件名，以及在蓝色背景上的总结和通过的测试：
+
+![](https://p.ipic.vip/saxj1h.jpg)
+
+代码审查截图，带有黑色终端覆盖层，显示带引号的文件名通过了一个测试；“修复 /diff 中特殊字符的错误”更改的总结和差异在淡蓝色背景上可见：
+
+![](https://p.ipic.vip/tzqxoa.jpg)
+
+## 3 与人类偏好保持一致
+
+训练 codex-1 的主要目标之一是使其输出紧密符合人类编码偏好和标准。与 OpenAI o3 相比，codex-1 始终能够产生更干净的补丁，准备好立即进行人类审查并集成到标准工作流程中。
+
+> 案例详见官网：https://openai.com/index/introducing-codex/
+
+## 4 防止滥用
+
+防止人工智能驱动的软件工程被恶意应用，例如用于恶意软件开发，正变得越来越重要。同时，保护措施不应过度阻碍合法且有益的应用，这些应用可能涉及有时也用于恶意软件开发的技术，例如低级内核工程。
+
+为了平衡安全性和实用性，Codex经过训练，能够识别并明确拒绝针对恶意软件开发的请求，同时清晰区分并支持合法任务。我们还增强了政策框架，并纳入了严格的安全评估，以有效强化这些边界。我们已发布对[o3系统卡的补充说明](https://openai.com/index/o3-o4-mini-codex-system-card-addendum/)，以反映这些评估。
+
+## 5 安全执行
+
+Codex代理完全在云端的安全、隔离容器中运行。在任务执行期间，互联网访问被禁用，将代理的交互限制为仅限于通过GitHub仓库明确提供的代码和用户通过设置脚本配置的预安装依赖项。代理无法访问外部网站、API或其他服务。
+
+## 6 早期用例
+
+OpenAI的技术团队已开始将Codex作为其日常工具的一部分使用。它通常被OpenAI工程师用于处理重复且范围明确的任务，例如重构、重命名和编写测试，这些任务否则会打断专注。它同样适用于搭建新功能、连接组件、修复漏洞和起草文档。团队正在围绕它形成新的习惯：处理值班问题、在一天开始时规划任务以及卸载后台工作以保持进度。通过减少上下文切换和提醒被遗忘的待办事项，Codex帮助工程师更快地交付产品，并专注于最重要的事务。
+
+在发布之前，我们还与一组外部测试者合作，以更好地了解Codex在不同代码库、开发流程和团队中的表现。
+
+- [思科](https://blogs.cisco.com/news/the-future-is-coming-faster-than-you-think)正在探索Codex如何帮助其工程团队更快地实现雄心勃勃的想法。作为早期设计合作伙伴，思科通过在产品组合中评估Codex的实际用例并向OpenAI团队提供反馈，正在帮助塑造Codex的未来。
+- [Temporal](https://temporal.io/)使用Codex加速功能开发、调试问题、编写和执行测试以及重构大型代码库。它还通过在后台运行复杂任务来帮助他们保持专注，使工程师保持流畅的工作状态，同时加快迭代速度。
+- [Superhuman](https://superhuman.com/)使用Codex加快小型但重复的任务，如提高测试覆盖率和修复集成失败。它还通过使产品经理能够贡献轻量级代码更改（无需工程师介入，除非进行代码审查）来帮助他们更快地交付产品。
+- [Kodiak](https://kodiak.ai/)正在使用Codex编写调试工具、提高测试覆盖率和重构代码，以加快其自动驾驶技术Kodiak Driver的开发。Codex还成为了一个有价值的参考工具，通过提供相关上下文和过去的更改，帮助工程师理解不熟悉的堆栈部分。
+
+根据早期测试者的经验，我们建议同时将范围明确的任务分配给多个代理，并尝试不同类型的任务和提示，以有效地探索模型的能力。
+
+## 7 Codex CLI的更新
+
+上个月，我们推出了Codex CLI，这是一个轻量级的开源编码代理，可在您的终端中运行。它将像o3和o4-mini这样的模型的强大功能带入您的本地工作流程，使您能够与它们配对，更快地完成任务。
+
+今天，我们还发布了codex-1的较小版本，这是专为在Codex CLI中使用而设计的o4-mini版本。这个新模型支持CLI中的更快工作流程，并针对低延迟代码问答和编辑进行了优化，同时保留了指令遵循和风格方面的相同优势。它现在作为Codex CLI中的默认模型以及API中的codex-mini-latest提供。随着我们继续改进Codex-mini模型，底层快照将定期更新。
+
+我们还使将您的开发者账户连接到Codex CLI变得更加容易。您不再需要手动生成和配置API密钥，而是可以使用ChatGPT账户登录并选择您想要使用的API组织。我们将为您自动生成和配置API密钥。使用ChatGPT登录Codex CLI的Plus和Pro用户还可以分别从今天开始兑换5美元和50美元的免费API积分，有效期为接下来的30天。
+
+## 8 Codex的可用性、定价和限制
+
+从今天起，我们开始向全球的ChatGPT Pro、企业版和团队用户推出Codex，很快将支持Plus和Edu用户。在接下来的几周内，用户将获得慷慨的访问权限，无需额外费用，以便您探索Codex的功能，之后我们将推出限速访问和灵活的定价选项，让您能够按需购买额外的使用量。我们计划很快向Plus和Edu用户扩展访问权限。
+
+对于使用codex-mini-latest进行开发的开发者，该模型在响应API上提供，定价为每100万输入标记1.50美元，每100万输出标记6美元，并提供75%的提示缓存折扣。
+
+Codex仍处于早期发展阶段。作为研究预览，它目前缺少一些功能，例如前端工作所需的图像输入，以及在代理工作时对其进行纠正的能力。此外，将任务委托给远程代理比交互式编辑花费的时间更长，这可能需要一些时间来适应。随着时间的推移，与Codex代理的互动将越来越类似于与同事进行异步协作。随着模型能力的提升，我们预计代理将能够处理更复杂的任务并持续更长时间。
+
+## 9 下一步计划
+
+我们设想了一个未来，开发者将主导他们想要负责的工作，并将其他工作委托给代理——通过人工智能更快地移动并提高生产力。为了实现这一目标，我们正在构建一套支持实时协作和异步委托的Codex工具。
+
+与Codex CLI等人工智能工具配对已迅速成为行业标准，帮助开发者在编码时更快地移动。但我们相信，Codex在ChatGPT中引入的异步多代理工作流程将成为工程师生产高质量代码的默认方式。
+
+最终，我们认为这两种互动模式——实时配对和任务委托——将融合。开发者将在他们的IDE和日常工具中与人工智能代理协作，以提问、获取建议和委托长期任务，所有这些都在一个统一的工作流程中。
+
+展望未来，我们计划引入更具互动性和灵活性的代理工作流程。开发者将很快能够在任务中途提供指导、协作制定实施策略并接收主动的进度更新。我们还设想与您已经使用的工具进行更深入的集成：今天Codex连接到GitHub，很快您将能够从Codex CLI、ChatGPT桌面版甚至您的问题跟踪器或CI系统等工具中分配任务。
+
+软件工程是第一个体验显著人工智能驱动生产力提升的行业之一，为个人和小团队开辟了新的可能性。尽管我们对这些收益持乐观态度，但我们也正在与合作伙伴合作，以更好地理解广泛代理采用对开发者工作流程、人员技能发展、技能水平和地理区域的影响。
+
+这只是开始——我们期待看到您用Codex构建什么。
+
+## 10 提示词
+
+我们分享codex-1系统消息，以帮助开发者了解模型的默认行为，并将Codex定制为在自定义工作流程中有效工作。例如，codex-1系统消息鼓励Codex运行AGENTS.md文件中提到的所有测试，但如果你时间紧迫，可以要求Codex跳过这些测试。
+
+```java
+# Instructions
+- The user will provide a task.
+- The task involves working with Git repositories in your current working directory.
+- Wait for all terminal commands to be completed (or terminate them) before finishing.
+
+# Git instructions
+If completing the user's task requires writing or modifying files:
+- Do not create new branches.
+- Use git to commit your changes.
+- If pre-commit fails, fix issues and retry.
+- Check git status to confirm your commit. You must leave your worktree in a clean state.
+- Only committed code will be evaluated.
+- Do not modify or amend existing commits.
+
+# AGENTS.md spec
+- Containers often contain AGENTS.md files. These files can appear anywhere in the container's filesystem. Typical locations include `/`, `~`, and in various places inside of Git repos.
+- These files are a way for humans to give you (the agent) instructions or tips for working within the container.
+- Some examples might be: coding conventions, info about how code is organized, or instructions for how to run or test code.
+- AGENTS.md files may provide instructions about PR messages (messages attached to a GitHub Pull Request produced by the agent, describing the PR). These instructions should be respected.
+- Instructions in AGENTS.md files:
+  - The scope of an AGENTS.md file is the entire directory tree rooted at the folder that contains it.
+  - For every file you touch in the final patch, you must obey instructions in any AGENTS.md file whose scope includes that file.
+  - Instructions about code style, structure, naming, etc. apply only to code within the AGENTS.md file's scope, unless the file states otherwise.
+  - More-deeply-nested AGENTS.md files take precedence in the case of conflicting instructions.
+  - Direct system/developer/user instructions (as part of a prompt) take precedence over AGENTS.md instructions.
+- AGENTS.md files need not live only in Git repos. For example, you may find one in your home directory.
+- If the AGENTS.md includes programmatic checks to verify your work, you MUST run all of them and make a best effort to validate that the checks pass AFTER all code changes have been made.
+  - This applies even for changes that appear simple, i.e. documentation. You still must run all of the programmatic checks.
+
+# Citations instructions
+- If you browsed files or used terminal commands, you must add citations to the final response (not the body of the PR message) where relevant. Citations reference file paths and terminal outputs with the following formats:
+  1) `【F:<file_path>†L<line_start>(-L<line_end>)?】`
+  - File path citations must start with `F:`. `file_path` is the exact file path of the file relative to the root of the repository that contains the relevant text.
+  - `line_start` is the 1-indexed start line number of the relevant output within that file.
+  2) `【<chunk_id>†L<line_start>(-L<line_end>)?】`
+  - Where `chunk_id` is the chunk_id of the terminal output, `line_start` and `line_end` are the 1-indexed start and end line numbers of the relevant output within that chunk.
+- Line ends are optional, and if not provided, line end is the same as line start, so only 1 line is cited.
+- Ensure that the line numbers are correct, and that the cited file paths or terminal outputs are directly relevant to the word or clause before the citation.
+- Do not cite completely empty lines inside the chunk, only cite lines that have content.
+- Only cite from file paths and terminal outputs, DO NOT cite from previous pr diffs and comments, nor cite git hashes as chunk ids.
+- Use file path citations that reference any code changes, documentation or files, and use terminal citations only for relevant terminal output.
+- Prefer file citations over terminal citations unless the terminal output is directly relevant to the clauses before the citation, i.e. clauses on test results.
+  - For PR creation tasks, use file citations when referring to code changes in the summary section of your final response, and terminal citations in the testing section.
+  - For question-answering tasks, you should only use terminal citations if you need to programmatically verify an answer (i.e. counting lines of code). Otherwise, use file citations.
+```
\ No newline at end of file
diff --git a/docs/md/AI/amazon-strands-agents-sdk.md b/docs/md/AI/amazon-strands-agents-sdk.md
new file mode 100644
index 000000000..0c47e0ee1
--- /dev/null
+++ b/docs/md/AI/amazon-strands-agents-sdk.md
@@ -0,0 +1,57 @@
+# Amazon 开源 Strands Agents SDK，用于构建 AI 智能体
+
+## 0 前言
+
+Amazon最近发布开源 SDK - Strands Agents，通过模型驱动方法简化智能体开发。框架允许开发者只需少量代码，通过定义提示词和工具列表，就能构建智能体。
+
+该项目得到多家科技公司和咨询公司支持。Amazon 表示：“目前已有多家公司加入我们，共同支持和贡献这个项目，包括 Accenture、Anthropic、Langfuse、mem0.ai、Meta、PwC、Ragas.io 和 Tavily。”Strands 的设计既适用于简单应用，也能扩展到复杂的智能体场景，支持从本地开发到生产部署，为开发者提供从原型到生产级别智能体的一站式路径。
+
+## 1 框架核心组成
+
+“模型（model）、工具（tools）和提示词（prompt）”。这三者构成了 Amazon 所称的“agentic loop”（智能体循环）：智能体通过这三种组件完成任务，往往可以自主执行。
+
+实际运行中，Strands 会将提示词和智能体上下文，以及智能体可用工具的描述，一起发给LLM。系统充分利用了当今 LLM 的强大能力，LLM 现在具备强大的推理、规划和工具选择能力。
+
+![](https://p.ipic.vip/rkikxc.png)
+
+## 2 执行流程
+
+遵循一个结构化模式，LLM 可选择用自然语言向用户回应，规划任务步骤，回顾过去的步骤，或选择一个或多个工具进行使用。
+
+而 Strands 会自动处理工具执行的技术细节：当 LLM 选择一个工具时，Strands 会负责调用工具并将结果返回给 LLM。
+
+这个过程会不断迭代，直到LLM 完成任务，Strands 返回智能体的最终结果。
+
+## 3 定位
+
+Strands Agents 自我[定位](https://strandsagents.com/0.1.x/)为“轻量级且适合生产环境”，支持多种模型提供方和部署方式。这个 SDK 能适配不同类型的工作负载，支持“对话型、非对话型、流式和非流式”智能体。
+
+## 4 主要功能
+
+包括“全面[可观测性](https://strandsagents.com/0.1.x/user-guide/observability-evaluation/observability/)、追踪以及可扩展的部署选项”，并内置了[工具](https://strandsagents.com/0.1.x/user-guide/concepts/tools/tools_overview/)，帮助开发者快速上手。该框架还支持高级功能，如“[多智能体](https://strandsagents.com/0.1.x/user-guide/concepts/multi-agent/agents-as-tools/)协作和自主智能体”，可实现“智能体团队协作，以及智能体随时间自我优化”的能力。
+
+Amazon 强调，Strands 将“安全性与隐私保护”作为重点，确保组织可以在保护数据的前提下负责任地运行智能体。该 SDK 的架构简洁且可定制，不依赖于特定模型或提供商，兼容各种模型和部署环境。
+
+## 5 开发工具
+
+该 SDK 还提供两个用于开发的额外软件包：[strands-agents-tools](https://pypi.org/project/strands-agents-tools/) 和 [strands-agents-builder](https://pypi.org/project/strands-agents-builder/)，均可在 GitHub 获取。tools 包提供了扩展智能体功能的示例实现，而 builder 包内置了一个智能体，可协助开发者创建自己的 Strands 智能体和工具。这些组件支持个性化开发，帮助开发者进一步拓展框架的功能。
+
+## 6 适用范围
+
+[超越](https://strandsagents.com/0.1.x/user-guide/quickstart/)了 Amazon Bedrock，支持多种模型提供方。开发者可：
+
+- 通过 API 接入 [Anthropic](https://docs.anthropic.com/en/home) 的 Claude 模型；
+- [LiteLLM](https://docs.litellm.ai/docs/) 提供了统一接口，支持 OpenAI、Mistral 等模型
+- 通过 [Llama API](https://strandsagents.com/0.1.x/user-guide/concepts/model-providers/llamaapi/)，框架支持 Meta 的 Llama 模型
+- 也可用 [Ollama](https://ollama.com/) 在本地运行模型，满足隐私或离线需求
+- OpenAI 的模型也可通过 API 直接访问，包括兼容 OpenAI 接口的替代模型
+- 开发者还可以[自定义模型提供方](https://strandsagents.com/0.1.x/user-guide/concepts/model-providers/custom_model_provider/)，以适配特定的实现需求
+
+## 7 总结
+
+有兴趣使用 Strands 构建 AI 智能体的开发者，可前往其[GitHub 页面]()，查看文档、示例代码，并参与到该开源项目的社区。
+
+参考：
+
+- https://aws.amazon.com/cn/blogs/opensource/introducing-strands-agents-an-open-source-ai-agents-sdk/
+- https://github.com/strands-agents
\ No newline at end of file
diff --git a/docs/md/AI/llm/accelerating-workflow-processing-with-parallel-branch.md b/docs/md/AI/llm/accelerating-workflow-processing-with-parallel-branch.md
new file mode 100644
index 000000000..1be679ebf
--- /dev/null
+++ b/docs/md/AI/llm/accelerating-workflow-processing-with-parallel-branch.md
@@ -0,0 +1,115 @@
+# Dify v0.8.0：使用并行分支加速工作流处理
+
+## 0 前言
+
+Dify Workflow 因其用户友好的设置和强大的功能而广受欢迎。然而，之前的版本以串行方式执行各个步骤，等待每个节点完成后再转到下一个节点。虽提供清晰结构，但这会降低复杂任务的处理速度，增加延迟和响应时间。
+
+Dify v0.8.0 通过引入并行处理功能解决了这些限制。Workflow 现在可以并发执行多个分支，从而能够同时处理不同的任务。这显著提高了执行效率，使 LLM 应用程序能够更快、更灵活地处理复杂的工作负载。
+
+### 创建并行分支
+
+要在工作流中定义并行分支：
+
+1. 将鼠标悬停在节点上
+2. 点击出现的 + 图标
+3. 添加不同的节点类型
+
+各个分支将并行执行并合并其输出。请参阅[文档](https://docs.dify.ai/guides/workflow/orchestrate-node)以获取详细说明。
+
+![](https://framerusercontent.com/images/QkwBs9JTNzarDPeT3fiiW9uLHg.gif)
+
+工作流包含多种并行场景。可尝试使用这些场景来加快流程。如已在早期版本构建工作流，请考虑用并行模式重构，提高性能。
+
+## 1 简单并行
+
+基本场景，可从一个固定节点（如起始节点）创建多个并行分支。可同时处理类似的子任务，如翻译或模型比较。
+
+模型比较工作流程中的简单并行性：
+
+https://framerusercontent.com/assets/CSv597nulCSy0uNXY95cOnpeY.mp4
+
+## 2 嵌套并行
+
+允许在工作流中实现多层级并行结构。从初始节点开始，工作流分支出多个并行路径，每个路径包含各自的并行流程。“科学写作助手”示例展示了两个嵌套层级：
+
+![](https://framerusercontent.com/images/Qw9cSS2B7WthYmU7mcdwVbuY.png)
+
+1. **第一级（框 1）：** 从问题分类器中，出现了两个主要分支：
+   a.概念解释（框 1）
+   b. 处理偏离主题的对话（“拒绝闲聊”分支）
+
+概念解释（concept explanation）分支（框1）包括：
+
+   \- Metaphors and analogies branch for enhanced concept understanding 
+   \- 隐喻和类比分支可增强概念理解
+
+   \- Theme extraction | Second level nesting (Box 2) for detailed concept analysis and content generation
+   \- 主题提取 | 第二级嵌套（框 2）用于详细的概念分析和内容生成
+
+2. **第二级（框 2）：** 主题提取分支执行两个并行任务：
+   a. 提取主题并搜索（提取主题 -> Serper）获取背景信息
+   b.提取主题并生成学习计划（学习计划->参数提取器->TavilySearch）
+
+这种多层嵌套并行结构非常适合诸如深入概念分析和科学传播内容创作等复杂、多阶段的任务。它能够同时处理不同的概念层面，包括基本解释、类比、背景研究和学习计划，从而提高处理效率和输出质量。
+
+## 3 迭代并行
+
+涉及循环结构内的并行处理。“股票新闻情绪分析”演示这种方法：
+
+![](https://framerusercontent.com/images/aVZRG8dmzQ47Vp9QEXjWPFU.png)
+
+1. **Setup:** Search and extract multiple news URLs for a specific stock.
+   **设置：** 搜索并提取特定股票的多个新闻 URL。
+
+2. **Iterative processing:** For each URL, execute in parallel: 
+   **迭代处理：** 对于每个 URL，并行执行：
+
+   a. Content retrieval: Use JinaReader to scrape and parse webpage content. 
+   a.内容检索：使用 JinaReader 抓取并解析网页内容。
+
+   b. Opinion extraction: Identify optimistic and pessimistic views using a parameter extractor. 
+   b. 观点提取：使用参数提取器识别乐观和悲观的观点。
+
+   c. Opinion summarization: Use two independent LLM models to summarize optimistic and pessimistic views concurrently.
+   c. 观点总结：使用两个独立的 LLM 模型同时总结乐观和悲观的观点。
+
+3. **Combine results:** Consolidate all findings into a single table.
+   **合并结果：** 将所有发现合并到一张表中。
+
+This method efficiently processes large volumes of news articles, analyzing sentiment from multiple perspectives to help investors make informed decisions. Parallel processing within iterations accelerates tasks with similar data structures, saving time and improving performance.
+该方法能够高效处理海量新闻文章，从多个角度分析情绪，帮助投资者做出明智的决策。迭代中的并行处理能够加速具有相似数据结构的任务，从而节省时间并提升性能。
+
+## 4 条件并行
+
+条件分支并行根据条件运行不同的并行任务分支。“面试准备助手”示例展示了此设置：
+
+![](https://framerusercontent.com/images/FN3HzbcjYTsIKTMDc7l1ojpK6Z0.png)
+
+1. **Main condition (IF/ELSE node):** Splits process based on dialogue_count: 
+   **主要条件（IF/ELSE 节点）：** 根据 dialog_count 拆分流程：
+
+   a. First dialogue: Confirm interview role and company 
+   a. 第一次对话：确认面试职位和公司
+
+   b. Later dialogues: Enter deeper processing
+   b. 后续对话：进入更深层次的处理
+
+2. **Secondary condition (IF/ELSE 2 node):** In later dialogues, branches based on existing company info and interview questions: 
+   **次要条件（IF/ELSE 2 节点）：** 在后续对话中，根据现有的公司信息和面试问题进行分支：
+
+   a. Missing company info: Run parallel tasks to search company, scrape webpage, summarize company info 
+   a. 缺少公司信息：运行并行任务来搜索公司、抓取网页、汇总公司信息
+
+   b. Missing interview questions: Generate multiple questions in parallel
+   b. 缺少面试问题：并行生成多个问题
+
+3. **Parallel task execution:** For question generation, multiple LLM nodes start at the same time, each creating a different question
+   **并行任务执行：** 对于问题生成，多个 LLM 节点同时启动，每个节点创建不同的问题
+
+This IF/ELSE structure lets Workflow flexibly run different parallel tasks based on current state and needs. (The question classifier node can serve a similar function.) This improves efficiency while keeping things orderly. It suits situations needing simultaneous complex tasks based on various conditions, like this interview prep process.
+这种 IF/ELSE 结构允许 Workflow 根据当前状态和需求灵活地运行不同的并行任务。（问题分类器节点可以实现类似的功能。）这在保持有序的同时提高了效率。它适用于需要根据各种条件同时执行复杂任务的情况，例如本面试准备流程。
+
+## 5 受益于工作流并行
+
+这四种并行方法（简单、嵌套、迭代和条件）提升了 Dify Workflow 的性能。它们支持多模型协作，简化复杂任务，并动态调整执行路径。这些升级提升了效率，拓宽了应用范围，更好地处理棘手的工作情况。您可以在探索页面的配套模板中快速试用这些新功能。
+Dify将继续增强 Workflow，提供更强大、更灵活的自动化解决方案。令人期待！
\ No newline at end of file
diff --git a/docs/md/AI/llm/boost-ai-workflow-resilience-with-error-handling.md b/docs/md/AI/llm/boost-ai-workflow-resilience-with-error-handling.md
new file mode 100644
index 000000000..804cf9782
--- /dev/null
+++ b/docs/md/AI/llm/boost-ai-workflow-resilience-with-error-handling.md
@@ -0,0 +1,61 @@
+# v0.14.0：告别 AI 应用崩溃，构建更可靠的智能工作流！
+
+## 0 前言
+
+使用 Dify 构建AI应用程序，需要处理复杂的工作流程，其中单个组件（节点）可能会遇到 API 超时或 LLM 输出异常等问题。以前，单个节点故障就可能扰乱整个工作流程。
+
+Dify引入强大的[错误处理功能 ](https://docs.dify.ai/guides/workflow/error-handling)，以防级联故障：
+
+- 不仅可捕获异常以维护工作流的执行
+- 还允许开发人员为四种关键节点类型定义自定义错误处理
+
+实现详细的调试并确保弹性
+
+## 1 为啥错误处理很重要？
+
+考虑文档处理工作流：
+
+1. 文本从PDF提取
+2. LLM分析该文本并生成结构化数据
+3. 代码处理这些数据，完善文本
+4. 输出精炼文本
+
+若无错误处理，LLM生成格式错误的数据或代码节点遇到错误都导致工作流程停止。Dify现提供以下解决方案：
+
+- **默认值：** 预定义输出值，允许下游节点即使在输入缺失、不正确或格式错误的情况下也能继续运行
+- **工作流重定向：** 异常时，工作流重定向到备用分支，用 `error_type` 、 `error_message` 变量捕获错误详细信息并启用后续操作，如通知或备份工具激活
+
+并行工作流中，单个分支故障以往导致整个流程停止。现在，这些错误处理策略允许其他分支继续运行，显著提高可靠性：
+
+![](https://framerusercontent.com/images/kzcUinzjsKGhAVkJ3wXH0V4Hek.png)
+
+## 2 具有错误处理的关键节点
+
+Dify高级错误处理针对四种易出错的节点类型：
+
+1. **LLM 节点：** 处理无效响应、API 问题和速率限制。开发者可设置默认输出或使用条件分支来获取替代解决方案
+2. **HTTP 节点：** 在保持工作流执行的同时，通过重试间隔和详细的错误消息解决 HTTP 错误（404、500、超时）
+3. **工具节点：** 如果主工具出现故障，可以快速切换到备用工具
+4. **代码节点：** 使用预定义值或替代逻辑分支管理运行时错误，记录错误详细信息以防止中断
+
+## 3 错误处理实例
+
+与外部 API 交互的工作流。为模拟各种 HTTP 状态代码，用 [httpstat.us](http://httpstat.us/) 服务：
+
+![](https://framerusercontent.com/images/z4wZNagHqt4HxeaiRLUN7mLrmY.png)
+
+1. 起始节点启动工作流
+2. HTTP请求节点调用 [httpstat.us](http://httpstat.us/)
+3. 失败分支处理错误
+4. 条件逻辑（Conditional logic）响应特定错误码：
+   - 403（禁止）：显示权限消息
+   - 404（未找到）：记录“未找到资源”消息
+   - 429（请求过多）：建议稍后重试
+   - 500（服务器错误）：切换到备份服务或触发警报
+5. 输出节点，生成适当的响应
+
+ 通过确保工作流程的稳定性并提供有价值的错误反馈，这种设计增强了业务运营的可靠性。
+
+## 4 使用Dify构建更可靠AI工作流
+
+Dify v0.14.0 增强的错误管理功能，提供更强大的控制力和灵活性，实现稳健工作流，妥善处理异常并防止中断，确保 AI 应用程序的可靠性。
\ No newline at end of file
diff --git a/docs/md/AI/llm/claude-4.md b/docs/md/AI/llm/claude-4.md
new file mode 100644
index 000000000..e50dcdc93
--- /dev/null
+++ b/docs/md/AI/llm/claude-4.md
@@ -0,0 +1,162 @@
+# Claude 4 震撼发布：编程能力登顶，智能体迈入新时代！
+
+2025年5月23日●阅读时间约5分钟
+
+## 0 前言
+
+Claude 一边处理多个任务的插图：
+
+![](https://www.anthropic.com/_next/image?url=https%3A%2F%2Fwww-cdn.anthropic.com%2Fimages%2F4zrzovbb%2Fwebsite%2F9890d1bb39c15c41772af22d2282eb612469051c-2880x1620.jpg&w=3840&q=75)
+
+Anthropic今天正式推出Claude模型新一代产品：**Claude Opus 4** 和 **Claude Sonnet 4**，编程能力、高阶推理以及AI智能体应用方面设立全新标准：
+
+- Claude Opus 4是目前全球最强编程模型，在复杂且持续运行的任务和智能体流程中表现尤为突出
+- Claude Sonnet 4则在Sonnet 3.7基础上一次重大升级，更精准理解并响应用户指令，同时在编程和推理方面表现更出色
+
+<iframe frameborder="0" allowfullscreen="" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" title="A day with Claude" width="100%" height="100%" src="https://www.youtube-nocookie.com/embed/oqUclC3gqKs?autoplay=0&amp;mute=1&amp;controls=1&amp;origin=https%3A%2F%2Fwww.anthropic.com&amp;playsinline=1&amp;showinfo=0&amp;rel=0&amp;iv_load_policy=3&amp;modestbranding=1&amp;enablejsapi=1&amp;widgetid=1&amp;forigin=https%3A%2F%2Fwww.anthropic.com%2Fnews%2Fclaude-4&amp;aoriginsup=1&amp;gporigin=http%3A%2F%2Fjavaedge.cn%3A3000%2F&amp;vf=1" id="widget2" data-gtm-yt-inspected-11="true" style="box-sizing: inherit;"></iframe>
+
+## 1 新功能
+
+- 扩展推理与工具调用功能（Extended thinking with tool use）：两款新模型均可在进行深入思考时调用工具（如[网页搜索](https://docs.anthropic.com/en/docs/build-with-claude/tool-use/web-search-tool)），可在推理与工具使用之间切换，以提升回答质量
+- 新增模型能力：支持并行调用多个工具、更精准执行指令；若开发者开放本地文件访问权限，Claude还能大幅提升记忆能力，提取并保存关键事实，帮助模型保持上下文一致性并逐步构建隐性知识
+- Claude Code 正式发布：在预览阶段获得大量积极反馈后，扩展了开发者与Claude协作方式。现支持通过GitHub Actions后台运行，并与VS Code和JetBrains原生集成，可在代码文件中直接显示修改，提升协作效率。
+- 新增API能力：Anthropic API推出[四项新功能](https://www.anthropic.com/news/agent-capabilities-api)，助开发者构建更强大AI智能体，包括代码执行工具、MCP连接器、文件API以及提示缓存功能（最长可达1h）
+
+Claude Opus 4与Sonnet 4属混合型模型，支持两种运行模式：
+
+- 即时响应
+- 深度推理
+
+Pro、Max、Team和Enterprise订阅用户可使用两个模型及其扩展推理功能，免费用户也可用Sonnet 4。这两款模型已上线Anthropic API、Amazon Bedrock和Google Cloud的Vertex AI平台，价格与此前版本保持一致：
+
+- Opus 4每百万tokens收费为15`$`（输入）/75`$`（输出）
+- Sonnet 4则为3`$`/15`$`
+
+------
+
+## 2 Claude 4
+
+Anthropic目前最强大模型，也是全球顶尖编程模型，在SWE-bench（72.5%）和Terminal-bench（43.2%）领先。在需持续专注数小时的大型任务中表现出色，远超所有Sonnet模型，大幅提升AI智能体的执行能力。
+
+Claude Opus 4在编程和复杂问题解决方面表现尤为出色，推动了
+
+### 2.1 前沿智能体产品发展
+
+- Cursor称其为“编程领域的最新标杆”，并极大提升对复杂代码库的理解能力
+- Replit反馈其精度显著提升，能高效处理跨文件的复杂改动
+- Block认为这是首个在编辑和调试过程中能稳定提升代码质量的模型，其内部代号为“goose”的智能体正使用它
+- Rakuten通过一项耗时7h的开源重构任务验证了它的稳定性
+- Cognition指出，Opus 4能解决其他模型无法应对的挑战，成功处理以往模型常出错的关键任务
+
+Claude Sonnet 4在Sonnet 3.7基础明显提升，SWE-bench成绩达72.7%，在兼顾性能与效率的同时，增强模型可控性。虽多数场景不及Opus 4，但提供更实用性能组合。
+
+### 2.2 实用性能组合
+
+- GitHub表示，Claude Sonnet 4在智能体场景表现卓越，将用于GitHub Copilot全新编程智能体
+- Manus称其在复杂指令执行、清晰推理和输出美观度方面都有明显改进
+- iGent报告称其在自动开发多功能应用方面表现优异，导航错误率几乎降为零
+- Sourcegraph认为这是软件开发领域的一次重大飞跃，模型更能保持任务专注，理解更深入，生成的代码更优雅
+- Augment Code表示，Sonnet 4成功率更高、代码修改更精细、在复杂任务中处理更谨慎，是他们的首选主力模型
+
+这些模型全面推动客户的AI战略：Opus 4在编程、科研、写作和科学发现等领域突破边界，而Sonnet 4则以更高性价比提升日常工作效率，是Sonnet 3.7的理想升级。
+
+Claude在软件工程任务中的对比图
+
+![](https://p.ipic.vip/i038v4.jpg)
+
+Claude 4模型在SWE-bench Verified测试中领先，这是一个真实软件工程任务的性能基准。
+
+![](https://p.ipic.vip/gmpshe.jpg)
+
+Claude 4系列在编程、推理、多模态能力及智能体任务中均表现出色。
+
+------
+
+## 3 模型改进
+
+除了扩展推理、并行工具使用与记忆能力提升外，我们大幅减少了模型在完成任务时“走捷径”或利用“漏洞”的行为。在特别容易出现这些行为的智能体任务中，新模型发生此类情况的概率比Sonnet 3.7低65%。
+
+Opus 4在记忆能力方面也远超以往模型。当开发者允许其访问本地文件时，它能高效创建并维护“记忆文件”，记录关键信息，提升长期任务的连贯性与表现。
+
+最后，我们为Claude 4引入了“思考摘要”功能，可利用小模型浓缩复杂的思维过程。仅约5%的情况下需要进行摘要，大多数推理过程足够简洁可完整展示。
+
+------
+
+## 4 Claude Code
+
+现已全面开放的Claude Code，将Claude的强大功能延伸至您的开发流程中：支持终端使用、主流IDE集成、并可后台运行。
+
+为VS Code与JetBrains推出了测试版扩展，Claude提出的代码修改将直接显示在文件中，使代码审查与追踪更加便捷。在IDE终端中运行Claude Code即可安装。
+
+还发布了可扩展的Claude Code SDK，方便您基于其核心构建自己的智能体与应用。还提供了一个示例：GitHub上的Claude Code（测试版）。在PR中标记Claude Code，即可自动响应审查意见、修复CI错误或修改代码。安装方式：在Claude Code中运行/install-github-app。
+
+------
+
+## 5 快速上手
+
+这些模型是迈向“虚拟协作者”的重要一步——能保持完整上下文、持续专注长期项目，并带来颠覆性成果。我们进行了大量测试与评估，以最大限度地降低风险并确保安全，包括[启用ASL-3等级保护措施](https://www.anthropic.com/news/activating-asl3-protections)。
+
+## 6 附录
+
+#### 性能基准数据来源
+
+- **OpenAI**：
+  - [o3发布文章](https://openai.com/index/introducing-o3-and-o4-mini/)
+  - [o3系统卡片](https://cdn.openai.com/pdf/2221c875-02dc-4789-800b-e7758f3722c1/o3-and-o4-mini-system-card.pdf)
+  - [GPT-4.1发布文章](https://openai.com/index/gpt-4-1/)
+  - [GPT-4.1官方评测数据](https://github.com/openai/simple-evals/blob/main/multilingual_mmlu_benchmark_results.md)
+- **Gemini**：
+  - [Gemini 2.5 Pro Preview模型卡片](https://storage.googleapis.com/model-cards/documents/gemini-2.5-pro-preview.pdf)
+- **Claude**：
+  - [Claude 3.7 Sonnet发布文章](https://www.anthropic.com/news/claude-3-7-sonnet)
+
+------
+
+#### 性能基准说明
+
+Claude Opus 4 和 Sonnet 4 是混合推理模型。本文所展示的基准测试分数，展示了模型在**启用或未启用扩展推理**时的最高表现。每项测试结果下方注明了是否使用了扩展推理功能：
+
+- **未使用扩展推理的测试**：
+  - SWE-bench Verified
+  - Terminal-bench
+- **使用扩展推理（支持最多64K tokens）的测试**：
+  - TAU-bench（未提供不使用扩展推理的结果）
+  - GPQA Diamond
+    - 未使用扩展推理时：Opus 4得分为74.9%，Sonnet 4为70.0%
+  - MMMLU
+    - 未使用扩展推理时：Opus 4得分为87.4%，Sonnet 4为85.4%
+  - MMMU
+    - 未使用扩展推理时：Opus 4得分为73.7%，Sonnet 4为72.6%
+  - AIME
+    - 未使用扩展推理时：Opus 4得分为33.9%，Sonnet 4为33.1%
+
+------
+
+#### TAU-bench 测试方法
+
+我们为航空与零售领域的代理策略添加了提示附录，引导Claude在使用工具和扩展推理时，更好地发挥其推理能力。模型在多轮对话任务中被鼓励记录自己的思考过程，与平常的推理模式区分开来，以充分发挥其分析能力。
+
+为适应Claude因更深入思考而增加的响应步骤数量，最大步骤数从30步上调至100步（大多数任务在30步内完成，仅有一个超过50步）。
+
+------
+
+#### SWE-bench 测试方法
+
+Claude 4系列在此项测试中仍使用此前版本中介绍的简单工具架构，仅包含两种工具：[bash终端工具与文件编辑工具](https://www.anthropic.com/engineering/swe-bench-sonnet)，通过字符串替换方式操作文件。不再包含Claude 3.7 Sonnet使用的[第三种“计划工具”](https://www.anthropic.com/engineering/claude-think-tool)。
+
+所有Claude 4模型的测试基于完整的500道题目进行评分。OpenAI的模型成绩则基于[477道题的子集](https://openai.com/index/gpt-4-1/)。
+
+------
+
+#### “高计算量”测试方法
+
+为获取更复杂任务下的准确评分，我们采用以下策略增加测试复杂度并启用并行计算资源：
+
+- 多次并行生成答案
+- 丢弃会破坏可见回归测试的代码补丁（类似于[Agentless（Xia等人，2024）](https://arxiv.org/abs/2407.01489)的拒绝采样方法；不使用隐藏测试信息）
+- 使用内部评分模型，在保留下来的候选答案中选出最优解
+
+最终得分如下：
+
+- Opus 4：79.4%
+- Sonnet 4：80.2%
\ No newline at end of file
diff --git a/docs/md/AI/llm/dify-agent-and-zapier-mcp-unlock-ai-automation.md b/docs/md/AI/llm/dify-agent-and-zapier-mcp-unlock-ai-automation.md
new file mode 100644
index 000000000..fac3bf78b
--- /dev/null
+++ b/docs/md/AI/llm/dify-agent-and-zapier-mcp-unlock-ai-automation.md
@@ -0,0 +1,179 @@
+# Dify Agent 与 Zapier MCP：解锁 AI 自动化新境界
+
+## 0 前言
+
+随AI Agent快速发展，使LLM与现实数据和工具无缝交互成为关键挑战。
+
+## 1 Dify社区的MCP插件
+
+Dify社区贡献了强大插件，以简化将外部 MCP 服务（如 Zapier MCP 和 Composio MCP）连接到你的 Agent 工作流过程：
+
+### 1.1 MCP SSE
+
+该插件用 HTTP + SSE与一或多个 MCP 服务器进行通信，使你的代理能动态发现和调用外部工具。
+
+### 1.2 MCP Agent Strategy
+
+该插件将 MCP 直接集成到工作流代理节点中，使代理能根据 MCP 定义的逻辑自主决定并调用外部工具。
+
+![](https://p.ipic.vip/59zpeg.png)
+
+## 2 Dify集成Zapier MCP
+
+Zapier MCP 服务器将超过 7,000 个应用和 30,000 个操作打包到单个 MCP 服务器 URL 中。从电子邮件到 CRM 更新或 Slack 通知，可在 Zapier 中快速配置操作，再直接插入Dify Agent工作流。
+
+### 2.1 快速设置
+
+1. 访问 [Zapier MCP 设置 ](https://actions.zapier.com/settings/mcp/)，https://mcp.zapier.com/mcp/servers/7cda9b58-3bd3-4165-aff5-4b6a6945173a/connections
+2. 复制你唯一的 MCP 服务器端点链接
+3. 单击“编辑 MCP 操作”以添加新工具和操作
+
+![](https://p.ipic.vip/i4n4nn.png)
+
+4. 选择一个应用程序（如Gmail）
+5. 选择并配置特定操作，如【Send Email】
+
+![](https://p.ipic.vip/83wri7.png)
+
+6. 设置【Send Email】：
+
+- 点击 Gmail 下的“连接”，登录并授权你的账户。
+- 对于收件人、主题和正文等字段，选择“让 AI 猜测一个值”，允许根据您的代理的交互动态生成 AI 驱动的内容。
+
+![](https://p.ipic.vip/k3w8v2.png)
+
+新UI：
+
+![](https://p.ipic.vip/aiwjw5.png)
+
+7. 重复此操作，以添加其他操作，扩展你的工具包：
+
+![](https://p.ipic.vip/for6h3.png)
+
+### 新增工具
+
+![](https://p.ipic.vip/mzb9s5.png)
+
+可见很多工具，选择【Gmail】：
+
+![](https://p.ipic.vip/wdyw93.png)
+
+再挑选【Gmail tools】，如【Send Email】：
+
+![](https://p.ipic.vip/zuwnuk.png)
+
+### 设置要连接的MCP client
+
+![](https://p.ipic.vip/3x7na0.png)
+
+先临时设置 cursor 为客户端，再点击【Connect】选项页：
+
+![](https://p.ipic.vip/79nuij.png)
+
+采集这里的 Server URL。
+
+## 3 用于动态工具调用的 MCP SSE 插件
+
+从 Dify Marketplace 安装 MCP SSE 插件：
+
+![](https://p.ipic.vip/v6li0k.png)
+
+安装完成后，将下方模板中的 URL 替换为刚才配置的 Zapier MCP 服务器 URL：
+
+```json
+{
+  "server_name": {
+    "url": "https://actions.zapier.com/mcp/*******/sse",
+    "headers": {},
+    "timeout": 5,
+    "sse_read_timeout": 300
+  }
+}
+```
+
+打开已安装的【MCP SSE 插件】，填写【MCP 服务配置】：
+
+![](https://p.ipic.vip/39p8wb.png)
+
+保存操作成功：
+
+![](https://p.ipic.vip/b1dofw.png)
+
+### 多个 MCP 服务器（如Composio）配置
+
+可能如下：
+
+```json
+{
+  "server_name1": {
+    "url": "http://127.0.0.1:8000/sse",
+    "headers": {},
+    "timeout": 5,
+    "sse_read_timeout": 300
+  },
+  "server_name2": {
+    "url": "http://127.0.0.1:8001/sse"
+  }
+}
+```
+
+### 新建Agent类型的应用
+
+配置完成后，创建新应用，并在“工具”部分启用你的 MCP SSE 插件
+
+![](https://p.ipic.vip/ib0kjh.png)
+
+Agent 将根据用户意图智能地调用相关工具，如通过集成的 Gmail 操作自动起草和【Send Email】：
+
+![](https://p.ipic.vip/ux5mpt.png)
+
+ 我的 qq 邮箱就收到邮件：
+
+![](https://p.ipic.vip/lrl793.png)
+
+还可将联系人 Excel 文件上传到 Dify 的知识库。这样，当你仅提供收件人姓名和邮件内容时，代理即可自动匹配收件人的邮件地址。
+
+还可设置特定提示，以确保邮件在发送前得到用户的确认：
+
+![](https://p.ipic.vip/rsg2k1.png)
+
+回复确认即可：
+
+![](https://p.ipic.vip/ig5s5u.png)
+
+收到邮件：
+
+![](https://p.ipic.vip/5xynwh.png)
+
+#### 提示词
+
+联系我本人 vx 获取。
+
+## 4 通过Agent Strategy插件集成 MCP
+
+除了 SSE 插件，MCP Agent Strategy 插件将 MCP 直接嵌入到你的工作流 Agent 节点：
+
+![](https://p.ipic.vip/fzip11.png)
+
+安装完成后，按照类似方式配置MCP服务器 URL：
+
+```json
+{
+  "server_name": {
+    "url": "https://actions.zapier.com/mcp/*******/sse",
+    "headers": {},
+    "timeout": 5,
+    "sse_read_timeout": 300
+  }
+}
+```
+
+![](https://p.ipic.vip/5jboy9.png)
+
+通过此配置，你的工作流代理可自主利用 Zapier MCP 执行诸如发送 Gmail 电子邮件之类的任务，作为自动化工作流的一部分。
+
+![](https://p.ipic.vip/cc8ref.png)
+
+## 5 总结
+
+Dify MCP 功能依赖社区开发的优秀插件。Dify正积极开发原生 MCP 支持，以更轻松在 Dify 直接配置 Zapier MCP 和 Composio 等外部服务，为用户打造更丰富、更强大集成功能。
\ No newline at end of file
diff --git a/docs/md/AI/llm/dify-deep-research-workflow-farewell-to-fragmented-search-unlock-ai-driven-insights.md b/docs/md/AI/llm/dify-deep-research-workflow-farewell-to-fragmented-search-unlock-ai-driven-insights.md
new file mode 100644
index 000000000..e65ad58e5
--- /dev/null
+++ b/docs/md/AI/llm/dify-deep-research-workflow-farewell-to-fragmented-search-unlock-ai-driven-insights.md
@@ -0,0 +1,146 @@
+# Dify 深度研究工作流：告别碎片化搜索，解锁 AI 驱动的全面洞察
+
+## 0 业务痛点
+
+标准搜索查询通常会因复杂问题而失效。学术论文、市场分析或代码调试，要找到完整答案通常需拼凑数十个单独搜索。这正是**深度研究的**用武之地——它能够直面这一日常挑战。Google Gemini、ChatGPT 和 DeepSeek-R1 等领先 AI 平台已提供这项强大功能。
+
+深度研究凭借其智能反馈循环脱颖而出：它能够识别知识缺口，锁定特定问题，进行系统性探索，并提供全面的报告。不同于传统的碎片化信息搜索，深度研究提供的答案既广泛又深入。
+
+本文展示咋用 Dify 构建深度研究工作流，主要包含三个关键组件： **循环变量、结构化输出和代理节点** 。创建一个能够独立进行研究并提供有意义见解的工作流。
+
+### 工作流概述
+
+Dify 中的深度研究工作流程分三阶段：
+
+1. **意图识别** ：工作流程捕捉您的研究主题，收集初始背景，并分析目标以确定明确的方向。
+2. **迭代探索** ：工作流程使用循环变量来评估知识以发现差距、运行有针对性的搜索并逐步建立发现。
+3. **综合** ：所有收集到的信息都成为一份带有适当引用的结构化报告。
+
+它反映了专家研究人员的思考：“我已经知道什么？缺少什么？下一步我应该研究什么？”
+
+## 1 第一阶段：研究基础
+
+### 1.1 起始节点
+
+应首先用基本输入参数配置**开始**节点：
+
+- **研究主题** ：需要探索的核心问题
+- **最大循环** ：本次研究会话的迭代预算
+
+![](https://p.ipic.vip/fzs1bn.png)
+
+### 背景知识获取
+
+建议使用 **Exa Answer** 工具收集初步信息，确保模型在深入研究之前理解术语。
+
+![img](https://framerusercontent.com/images/EhIWg3JSDcZhRLGQe5iki7CkiNI.png)
+
+### 意图分析
+
+需使用 **LLM** 节点来挖掘用户的真实意图，从而区分表面问题和进一步的信息需求。
+
+![img](https://framerusercontent.com/images/i4mbdrFrSrUFuDp60fxG1mVvjvc.png)
+
+## 2 第二阶段：动态研究周期
+
+### 循环节点：研究引擎
+
+[**循环**](https://docs.dify.ai/en/guides/workflow/node/loop)节点驱动着整个研究。在 Dify 中，它跨迭代传递信息，因此每个循环都建立在先前的发现之上。
+
+Dify的深度研究工作流程跟踪六个关键变量：
+
+- **findings**: 每个周期发现的新知识
+- **executed_querys**: 以前使用的搜索查询（防止冗余）
+- **current_loop**: 迭代计数器
+- **visited_urls**: 正确引用的来源跟踪
+- **image_urls**: 视觉内容引用
+- **knowledge_gaps**: 已确定的信息需求
+
+![img](https://framerusercontent.com/images/PWXvggJIDcgnnDNa8tmh04iLF5I.png)
+
+#### 循环变量 V.S 标准变量
+
+- **正常参考**遵循线性路径：节点 1 → 节点 2 → 节点 3
+- **循环引用前一次迭代**创建一个知识网络：节点可以访问当前迭代和前一次迭代的输出
+
+这种设计可以积累知识，避免重复工作，并在每个周期中增强焦点。
+
+![](https://framerusercontent.com/images/yxMNQCGEtMrc9PaOTFSG4fJ2WI.png)
+
+### 推理节点：提出更好的问题
+
+[**推理**](https://docs.dify.ai/en/guides/workflow/structured-outputs)节点采用结构化输出格式：
+
+```
+{
+    "reasoning": "Detailed justification for the chosen action path...",
+    "search_query": "Specific follow-up question targeting knowledge gaps",
+    "knowledge_gaps": "Information still needed to answer the original question"
+}
+```
+
+通过在 LLM 节点中启用 Dify 的结构化输出编辑器，您将收到一致的 JSON，以便下游节点能够可靠地处理。这可以清晰地提取推理路径、搜索目标和知识缺口。
+
+![](https://framerusercontent.com/images/O6n1ckQR5eEdvbpFDfqi44qU3zs.png)
+
+
+
+![](https://framerusercontent.com/images/PK0R1abx04WqaEFyeqXkb8MyY.png)
+
+
+
+![](https://framerusercontent.com/images/r0sVMLgkcczpNoaf3DcZQpJeM78.png)
+
+### 代理节点：进行研究
+
+好的问题只是开始。有效的研究需要果断的行动，而这正是 [**Agent**](https://docs.dify.ai/en/guides/workflow/node/agent) node 所擅长的。
+
+这些节点充当自主研究人员的角色，根据具体情况选择最合适的工具。工作流为代理提供了以下功能：
+
+**发现工具**
+
+- **exa_search**: 进行网络搜索并收集结果
+- **exa_content**: 从特定来源获取完整内容
+
+**分析工具**
+
+- **think** ：作为系统的反思引擎，灵感源自 Claude 的 Think Tool。它使代理能够评估发现、识别模式并确定后续步骤，这与研究人员暂停工作以整合笔记并规划其方法非常相似。
+
+可通过仅向代理提供其所需的内容来优化性能：仅提供来自上一个 LLM 节点的 search_query，而不是整个上下文。这种专注的方法可以提高工具选择的准确性。
+
+![](https://framerusercontent.com/images/0CLuSpFDGCISe9TmopYHKQFzc.png)
+
+### URL 提取
+
+工作流自动识别代理响应中的 URL 和视觉参考，从而正确跟踪所有信息源。
+
+![](https://framerusercontent.com/images/QShn1pxxcdlxwuzw5DSbl8bMmw.png)
+
+在每次迭代中，代理通过收集信息、处理内容和整合研究结果来完成一个完整的研究周期。
+
+### 变量赋值
+
+每个周期结束后， **变量分配器**节点都会更新研究状态。这确保每次迭代都建立在先前工作的基础上，而不是重复工作。
+
+![](https://framerusercontent.com/images/ALkQmoYYwpswtscez8zK52NYQ.png)
+
+## 3 第三阶段：研究综合
+
+一旦多个探索周期完成， **最终摘要**节点就会采用所有累积变量（发现、来源和支持数据）来生成综合报告。
+
+设置此节点是为了维护正确的 Markdown 引用并编制完整的参考文献列表。该工作流程还在关键节点设置了**答案**节点，以便在整个研究过程中提供流式更新。这些更新将最终报告构建成全面的分析和有效的参考文献，兼具分析深度和学术可信度。
+
+![](https://framerusercontent.com/images/3mDsHnoCl7F8QP1F4ZS7FeiYa84.png)
+
+## 总结
+
+本《深度研究指南》展示了 Dify 代理工作流程的卓越成就。Dify将专家研究方法数字化，并通过自动化加速其进程。
+
+未来的研究不仅仅在于拥有更多数据，更在于以更智能的方式探索数据。立即借鉴这些模式，构建您的研究引擎。
+
+参考：
+
+- https://github.com/dzhng/deep-research
+- https://github.com/jina-ai/node-DeepResearch
+- https://github.com/langchain-ai/local-deep-researcher
+- https://github.com/nickscamara/open-deep-research
\ No newline at end of file
diff --git a/docs/md/AI/llm/dify-v1-0-building-a-vibrant-plugin-ecosystem.md b/docs/md/AI/llm/dify-v1-0-building-a-vibrant-plugin-ecosystem.md
new file mode 100644
index 000000000..30b3c286a
--- /dev/null
+++ b/docs/md/AI/llm/dify-v1-0-building-a-vibrant-plugin-ecosystem.md
@@ -0,0 +1,107 @@
+# Dify v1.0.0：以插件生态和智能工作流驱动 AI 创新
+
+## 0 前言
+
+Dify v1.0.0正式发布，这标志着 Dify 作为 AI 应用开发平台迈出了重要的一步。
+
+### 版本亮点
+
+- **版本升级：** Dify 社区升级至 v1.0.0。
+- **插件机制** ：基于插件的新架构，模型和工具已迁移到插件，引入了代理策略、扩展和捆绑包
+- **工作流增强功能** ：已添加代理节点，用于在工作流和聊天流中实现智能编排和任务执行。
+- **开放生态系统** ： [Dify Marketplace](https://marketplace.dify.ai/) 的推出是为了与社区、合作伙伴和企业开发人员一起培育一个蓬勃发展的插件生态系统。
+
+## 1 人工智能应用开发的新范式
+
+随着生成式人工智能的迅速崛起，2025 年迎来了一系列重大创新：
+
+- 基于强化学习的大型语言模型（LLM），如 OpenAI 的 o1 和 DeepSeek-R1，在推理能力上表现出色
+- OpenAI Operator 正在探索通过计算机驱动的模型实现现实世界的任务自动化
+- Deep Research 则在智能异步信息处理方面表现出色
+
+这些进步标志着人工智能应用正在向独立执行复杂任务的方向转变。Dify 致力于打造下一代 AI 应用平台，为开发者提供四大核心能力：
+
+- **推理** ：整合增强的推理模型，以实现更佳的问题解决能力
+- **行动** ：扩展人工智能能力，以在数字（例如，执行软件操作）和物理环境（例如，智能家居和工厂的物联网设备集成）中执行操作
+- **动态内存** ：优化的 RAG 和内存机制，以改善上下文理解和长期任务执行
+- **多模式 I/O** ：处理多种数据模式（文本、图像、视频和语音），实现直观的人机交互
+
+Dify 提供灵活的开发框架，集成日益强大的模型、工具、决策逻辑和数据库，不断增强 AI 核心能力，使开发更加高效、智能，满足复杂的需求。
+
+鉴于人工智能应用的多样性，单一平台无法满足所有需求，标准化接口和通信协议至关重要。Dify 致力于构建一个开放、共享、充满活力的生态系统，让来自 Dify、社区开发者、企业以及第三方平台的组件无缝集成，实现价值共享和资源共享。最终，Dify 希望加速人工智能的落地，并推动创新。
+
+为了实现这一目标，Dify 开发了一个插件系统和市场，这是构建生态系统的关键一步。
+
+## 2 插件架构
+
+v1.0.0 版前，Dify面临重大挑战： **模型和工具与核心平台紧密集成，添加新功能需要修改核心代码库，这拖慢了开发速度并阻碍了创新。** 为解决这问题，重构了 Dify 的架构，并引入了一个插件系统，该系统具有以下四个主要优势：
+
+- **模块化插件：** 插件与 Dify 的核心架构分离，允许模型和工具独立运行，无需完整平台升级即可进行更新。用户只需更新相关插件，简化维护并确保兼容性。这也使新工具的开发和共享更加便捷，确保无缝集成。
+
+- **开发人员友好体验：** 插件遵循标准化开发协议，提供带有远程调试、代码示例和 API 文档的综合工具链，以简化开发
+
+- **热插拔设计** ：系统支持动态插件扩展和灵活使用，确保最佳的平台性能
+
+### 多种分发渠道
+
+![](https://framerusercontent.com/images/W7mBSNOkSJdEvAdnrjjDxXmkWo.jpg)
+
+#### Dify 市场（Dify Marketplace）
+
+一个用于聚合、分发和管理插件的平台。开发者可以提交他们的插件以供审核，并将其发布到 Dify 的插件库中。该市场目前提供 120 多个插件，包括：
+
+- **模型：** OpenAI o1 系列（o1、o3-mini 等）、Gemini 2.0 系列、DeepSeek-R1 及其提供商，包括 OpenRouter、Ollama、Azure AI Foundry、Nvidia Catalog 等
+- **工具：** Perplexity、Discord、Slack、Firecrawl、Jina AI、Stability、ComfyUI、Telegraph 等
+- [Dify Marketplace](https://marketplace.dify.ai/) 上有更多插件可供探索。查看[如何将插件发布到 Dify Marketplace](https://docs.dify.ai/plugins/publish-plugins/publish-to-dify-marketplace)
+
+
+#### 社区共享
+
+开发人员可以在 GitHub 等平台上自由共享插件，促进开源协作和社区驱动的创新。
+
+#### 本地部署
+
+Dify 社区版、云版、企业版用户均可从本地包文件安装插件，共享内部工具，加速部署速度，促进团队内部资源共享。
+
+这种模块化方法显著提高了 Dify 的灵活性和可扩展性，从而促进了更高效、更具创新性的生态系统。
+
+## 3 智能工作流
+
+开发者可以使用 Dify 的工作流和聊天流节点灵活地编排应用程序并解决复杂问题。Dify 专注于优化节点类型和功能，并强调开放性，以更好地满足开发者的多样化需求。v1.0.0 版本引入了 Agent 节点，并通过 Agent Strategy 插件增强了推理策略，从而实现了工作流和聊天流的智能、自主编排。
+
+https://framerusercontent.com/assets/YLncpf6QY0fFdPaIMoRXe4eVx8.mp4
+
+- [**代理节点** ](https://docs.dify.ai/guides/workflow/node/agent)：工作流和聊天流中的决策中心，根据资源调度、状态管理、推理记录、工具选择等策略动态调用模型，提升工作流效率和场景适应性。
+- [**Agent 策略** ](https://docs.dify.ai/plugins/quick-start/develop-plugins/agent-strategy-plugin)：将决策逻辑抽象为插件，并预设 **ReAct** 和 **Function Calling** 等策略，支持 Chain-of-Thoughts 和 Tree-of-Thoughts 等推理策略。同时，我们也提供了插件的开发标准，鼓励创新和共享
+
+## 4 开放生态系统
+
+多样化的插件将为 AI 应用提供核心能力，将 Dify 连接到外部平台，支持多模式交互，推动价值交换。
+
+![](https://framerusercontent.com/images/BcMft7b8RR1lmBCJPFH2CjuPF4Y.png)
+
+- **生态系统连接器：这些扩展功能**可实现与外部平台（例如 Slack）的无缝集成，从而促进数据和功能的互操作，从而构建高效的交互网络。插件端点还支持反向调用 Dify 的核心功能，包括模型、工具和工作流节点。
+- **多模态交互：** Dify 支持图像生成、语音交互等多模态模型和工具插件，扩展 AI 应用处理多样化输入输出格式的能力。
+- **价值共享平台：** Dify Marketplace 既是插件分发平台，也是创意交流中心。社区版下载量达 240 万次，企业版服务于众多财富 500 强企业。我们的目标是帮助企业找到解决方案，同时赋能开发者推动创新并创造收益。
+- 为了构建蓬勃发展的插件生态系统，我们渴望与更多合作伙伴携手，为用户提供更全面、更成熟的解决方案。 **在 v1.0.0 版本中，我们的首批合作伙伴包括 OpenRouter、Brave、E2B、SiliconFlow、Agora、Fish Audio、Dupdub 等。** 我们衷心感谢合作伙伴的支持，并期待为用户和开发者提供更丰富、更先进的解决方案，同时推进 AI 技术与现有软件的融合。
+
+
+这个开放的生态系统促进所有参与者的协作、创新和共同成功。
+
+## 5 前景
+
+我们将继续通过插件的方式解耦和开放 Dify 的核心能力，增强平台的灵活性，以满足多样化的开发需求。例如，我们利用数据处理组件来改进 RAG 工作流编排，帮助开发者应对复杂的挑战。
+
+为支持生态系统发展，我们将建立持续的合作伙伴网络，打造开放的 AI 中间件平台，连接工具与用户，并提供定制化的解决方案。我们还将推广行业专属用例，加速企业数字化转型和智能化升级。
+
+此外，Dify 将完善开发者文档和工具链支持，并通过线上线下活动邀请全球开发者共建。我们将认真倾听社区反馈，持续优化产品功能，致力于构建一个开放、繁荣、促进创新、资源共享的生态系统。
+
+## 6 总结
+
+为了让大家更便捷地体验 Dify v1.0.0，探索平台功能，参与 Dify 生态共建，相关访问链接如下：
+
+- [**Dify Community Version Dify 社区版**](https://github.com/langgenius/dify/releases/tag/1.0.0)
+- [**Dify Cloud Version Dify 云版本**](https://cloud.dify.ai/apps)
+- [**Dify Plugins Repo Dify 插件库**](https://github.com/langgenius/dify-plugins)
+- [**Dify Marketplace Dify 市场**](https://marketplace.dify.ai/)
+- [**Dify Plugin Docs Dify 插件文档**](https://docs.dify.ai/plugins/introduction)
\ No newline at end of file
diff --git a/docs/md/AI/llm/enhancing-llm-memory-with-conversation-variables-and-variable-assigners.md b/docs/md/AI/llm/enhancing-llm-memory-with-conversation-variables-and-variable-assigners.md
new file mode 100644
index 000000000..920cc3371
--- /dev/null
+++ b/docs/md/AI/llm/enhancing-llm-memory-with-conversation-variables-and-variable-assigners.md
@@ -0,0 +1,64 @@
+# Dify v0.7.0利用对话变量与变量赋值节点增强 LLM 记忆能力
+
+## 0 前言
+
+Dify一直致力于优化大语言模型（LLM）在应用中的记忆管理，以更好地应对各种具体场景需求。虽 LLM 能通过上下文窗口存储对话历史，但因为注意力机制的限制，在复杂场景中往往会出现记忆断层或聚焦不精准的问题。
+
+Dify 最新版本为此引入了两个新功能：
+
+- **对话变量（Conversation Variables）** 
+- **变量赋值节点（Variable Assigner nodes）**
+
+结合使用，可让基于 Chatflow 构建的 LLM 应用拥有更加灵活的记忆控制能力，支持读取与写入关键用户输入，从而提升 LLM 在生产环境中的实用性。
+
+## 1 对话变量：精准存储上下文信息
+
+允许 LLM 应用存储并引用上下文信息。开发者可在 Chatflow 会话中临时保存特定数据，如上下文内容、用户偏好，未来还将支持上传文件等内容。通过 **变量赋值节点**，可以在对话流程中的任意位置写入或更新这些变量。
+
+![](https://framerusercontent.com/images/1g1h1dXMj3bbNDJuZsNJuiMQM.png)
+
+### 优势
+
+- **精准的上下文管理：** 以变量为单位管理信息，而不仅仅是整个对话历史
+- **支持结构化数据：** 能处理字符串、数字、对象、数组等复杂数据类型
+- **便于流程集成：** 可在 Chatflow 的任何节点中写入或更新变量，供后续的 LLM 节点使用
+
+相比默认的对话历史机制，对话变量提供了更精细的信息管理方式。它让应用能够准确记住并调用特定信息，实现更加个性化的多轮对话体验。
+
+## 2 变量赋值节点：设置并写入对话变量
+
+要用于为可写变量（如对话变量）设置值。这类节点允许开发者将用户输入暂存，以供后续对话中引用。
+
+![](https://framerusercontent.com/images/pK0I2CwviMO3FH5hBBOHbXKE8y8.png)
+
+如在需要记录用户初始偏好的应用中，可结合使用对话变量和变量赋值节点来：
+
+- 存储用户的语言偏好
+- 在后续回复中持续使用该语言
+
+举例来说，若用户在对话开始时选择中文，变量赋值节点会将该偏好写入 `language` 对话变量。随后，LLM 就会依据该变量，在整个对话过程中持续使用中文。
+
+![](https://framerusercontent.com/images/iMhO0gdxvGAVyhT4ho0sYtid9M.png)
+
+这种做法简化了偏好的捕捉与应用流程，提升了对话的连贯性与用户体验。
+
+## 3 更多应用场景
+
+远不止于偏好存储，还可用于：
+
+- **患者接待助手：** 将用户输入的性别、年龄、症状等存入变量，用于推荐合适的就诊科室
+
+- **对话摘要生成器：** 通过变量赋值节点提取摘要，避免加载完整对话历史造成记忆超载
+
+- **数据分析助手：** 在对话中调取外部系统数据，并用于后续交互中
+
+- **创意写作工具：** 以对象数组形式动态存储和修改故事元素：
+
+  ```json
+  [
+    { "name": "Alice", "role": "主角", "trait": "勇敢" },
+    { "name": "神秘森林", "type": "场景", "atmosphere": "诡异" }
+  ]
+  ```
+
+这些示例展示了对话变量与变量赋值节点如何满足复杂应用对个性化记忆的需求，进一步提升 LLM 应用在实际场景中的能力与表现。
\ No newline at end of file
diff --git a/docs/md/AI/llm/introducing-parent-child-retrieval-for-enhanced-knowledge.md b/docs/md/AI/llm/introducing-parent-child-retrieval-for-enhanced-knowledge.md
new file mode 100644
index 000000000..61257c56c
--- /dev/null
+++ b/docs/md/AI/llm/introducing-parent-child-retrieval-for-enhanced-knowledge.md
@@ -0,0 +1,92 @@
+# v0.15.0：父子检索重磅上线，大幅提升 AI 回复的精准与深度
+
+## 0 前言
+
+v0.15.0新增父子检索功能，RAG系统中实现的一项先进技术，旨在增强信息访问和上下文理解。借助这项技术，Dify 现可通过提供更全面、更符合上下文的信息来提高 AI 生成回复的质量和准确性。
+
+## 1 语境与精确度的困境
+
+用知识检索系统时，用户常常面临令人沮丧的抉择，搜索结果：
+
+- 要么过于碎片化，缺乏必要的上下文信息来理解信息
+- 要么过于宽泛，牺牲了精准度，却充斥着过多无关的细节。这使得用户更难以高效地找到并使用所需的精准信息。
+
+所选的块大小显著影响系统生成准确全面响应的能力。因此，在精度和上下文之间找到理想的平衡对于提高知识检索过程的整体性能和可靠性至关重要。
+
+## 2 用于检索的子块和用于上下文的父块
+
+父子检索利用双层分层方法解决了上下文和精确度之间的矛盾，这种方法有效地平衡了 RAG 系统中精确匹配和全面上下文信息之间的权衡。这种结构化的双层信息访问的基本机制如下：
+
+### 带有子块的查询匹配
+
+- 使用小而集中的信息片段（通常简洁到段落中的单个句子）来匹配用户的查询。
+- 这些子块可以实现精确且相关的初始检索。
+
+### 使用父块进行上下文丰富
+
+- 然后检索包含匹配的子块的更大、更全面的部分（例如一个段落、一个部分，甚至整个文档）。
+- 这些父块为语言模型（LLM）提供了全面的上下文。
+
+
+
+![](https://framerusercontent.com/images/sKznH92du2qPB6JNFjAMfAL6VE.png)
+
+这种分层检索方法能够保留检索信息更广泛的叙述或背景，并降低在分块过程中忽略关键上下文细节的风险。例如，在客户支持方面，它使自动化系统能够通过参考全面的产品文档，提供更详细、更符合语境的响应。因此，在内容生成方面，它不仅提供精准的答案，还提供丰富的支持性背景信息，从而提升语言模型输出的质量。以下是使用同一文档对通用检索和父子检索进行对比的示例。
+
+![](https://framerusercontent.com/images/kocZcixfdwJ5d79FXzAQZ3yy0.png)
+
+## 3 亲子检索分步指南
+
+- **数据源：** 选择数据源并导入要用作知识的数据。
+- **块设置：** 选择常规或父子分块策略，设置参数以拆分和清理文档，并预览结果。
+
+在父子分块中，有两种模式来拆分父块： **段落**和**完整文档** 。
+
+  - **段落** ：此模式根据分隔符和最大块长度将文本拆分为段落，并使用拆分后的文本作为父块进行检索。此模式更适合段落清晰且相对独立的文本。
+  - **完整文档** ：将整个文档作为父块并直接检索。当需要在内聚上下文中检索整个文档时，完整文档更适用。
+
+在这两种模式下，子块都是通过根据分隔符和最大块长度进一步分割父块来生成的。
+
+![](https://framerusercontent.com/images/AwizCYhbTkm5Zi2GlFYFoenmhco.png)
+
+- Choose and configure **Index Method** and **Retrieval Setting**.
+  选择并配置**索引方法**和**检索设置** 。
+
+- Wait until processing completed and **go to documents**.
+  等待处理完成并**转到文档** 。
+
+- **Edit & Save Parent or Child chunks
+  编辑并保存父块或子块**
+
+  While allowing users to edit parent chunks and child chunks separately, we also retain the ability for parent chunks to regenerate child chunks. Its purpose is to allow users to improve retrieval efficiency by editing and adding child chunks as much as possible.
+  我们在允许用户分别编辑父块和子块的同时，也保留了父块重新生成子块的功能，目的是为了让用户尽可能地通过编辑和添加子块来提高检索效率。
+  If you edit parent chunks, there are two saving options:
+  如果您编辑父块，则有两个保存选项：
+
+  - Not regenerate the child chunks. (default)
+    不重新生成子块。（默认）
+  - Save and regenerate the child chunks. (with second confirmation)
+    保存并重新生成子块。（需第二次确认）
+
+编辑子块不会改变父块的内容。这样，用户可以将子块作为自定义标签来检索该父块。
+
+![](https://framerusercontent.com/images/5ujVdD4aZhDgz2Xq5W9rg9MiKQ.png)
+
+现在您可以将您的知识与您的应用程序集成在一起。🎉
+
+## 4 本次更新的其他亮点
+
+### 更人性化的父子 Chunk 关系展示
+
+作为低代码平台，Dify 致力于让没有技术背景的用户也能轻松理解和使用此功能。为此，我们为区块预览设计了全新的、用户友好的界面。
+
+- 每个父块都是一个单独的模块。子块在开头以灰色背景颜色和块编号标记。
+- 将鼠标悬停在子块上，它将以蓝色突出显示并显示字数信息。
+
+![](https://framerusercontent.com/images/kzCMSFolT4bU5uiTdTXVTkXU.png)
+
+为了预览检索测试，我们将父块放在弹出窗口的左侧，该弹出窗口包含命中子块的最高分数。所有命中的子块都列在右侧，并以蓝色突出显示，并显示相应的分数。
+
+![](https://framerusercontent.com/images/bjfnBy8UaK9SuYtPYmI3dnjkt2o.png)
+
+本次更新，Dify 的父子检索功能为用户提供更精准、更全面的搜索结果，提升信息获取的效率和准确率。如需了解更多详细操作，请参考[知识库｜Dify](https://docs.dify.ai/guides/knowledge-base) 文档获取详细说明，并在 Dify.AI 上亲身体验！
\ No newline at end of file
diff --git a/docs/md/AI/rag-introduction-tool-to-eliminate-llm-hallucinations.md b/docs/md/AI/rag-introduction-tool-to-eliminate-llm-hallucinations.md
new file mode 100644
index 000000000..40c644a63
--- /dev/null
+++ b/docs/md/AI/rag-introduction-tool-to-eliminate-llm-hallucinations.md
@@ -0,0 +1,317 @@
+# “消灭”LLM幻觉的利器 - RAG介绍
+
+## 1 LLM的问题
+
+### 1.1 幻觉
+
+LLM是预训练模型，已有一些知识储备，我们提的问题跟他的知识储备不相符时，就会产生幻觉，即看上去正确的回答。
+
+### 1.2 新鲜度
+
+LLM预训练后，不能感知到实时更新的业界发展数据，还有企业内部私域数据。
+
+### 1.3 数据安全
+
+LLM训练依赖很多训练数据集，为保证LLM效果更好，训练集质量及数据量越多，对LLM训练最终效果更好，但又期望LLM帮解决一些垂类问题，又希望在数据安全有些防范，如企业内部敏感数据不能暴露，让公有LLM去进行训练。
+
+## 2 RAG是啥？
+
+为解决以上问题，提出RAG，将企业私域数据和实时更新的公域数据，处理成可相似性搜索的向量数据，存储到向量数据库。
+
+和LLM交互时，用户提问。先在我们的相同数据库中进行相似性检索，检索与提问相关的知识内容，检索后交给LLM，连同用户的提问一起让 LLM 去生成回复。
+
+RAG帮助我们个人及用户去把企业内部的一些知识数据，很快构建出一个庞大知识库，然后结合目前已有LLM能力，可快速制作智能问答机器人应用。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/47ab7653f34a903658793e80be1d8489.png)
+
+### 小结
+
+为LLM提供来自外部知识源的额外信息的概念。这允许它们生成更准确和有上下文的答案，同时减少幻觉
+
+- 检索：外部相似搜索
+- 增强：提示词更新
+- 生成：更详细的提示词输入LLM
+
+### 应用场景
+
+开发者可以利用该技术低成本地构建：
+
+- AI 智能客服
+- 企业智能知识库
+- AI 搜索引擎等
+
+通过自然语言输入与各类知识组织形式进行对话。
+
+以一个有代表性的 RAG 应用为例：
+
+在下图中，当用户提问时 “美国总统是谁？” 时，系统并不是将问题直接交给大模型来回答，而是先将用户问题在知识库中（如下图中的维基百科）进行向量搜索，通过语义相似度匹配的方式查询到相关的内容（拜登是美国现任第46届总统…），然后再将用户问题和搜索到的相关知识提供给大模型，使得大模型获得足够完备的知识来回答问题，以此获得更可靠的问答结果。
+
+![RAG 基本架构](https://assets-docs.dify.ai/dify-enterprise-mintlify/zh_CN/learn-more/extended-reading/retrieval-augment/19b393464a4d0374498144502f024516.png)
+
+**为什么需要这样做呢？**
+
+我们可以把大模型比做是一个超级专家，他熟悉人类各个领域的知识，但他也有自己的局限性，比如他不知道你个人的一些状况，因为这些信息是你私人的，不会在互联网上公开，所以他没有提前学习的机会。
+
+当你想雇佣这个超级专家来充当你的家庭财务顾问时，需要允许他在接受你的提问时先翻看一下你的投资理财记录、家庭消费支出等数据。这样他才能根据你个人的实际情况提供专业的建议。
+
+**这就是 RAG 系统所做的事情：帮助大模型临时性地获得他所不具备的外部知识，允许它在回答问题之前先找答案。**
+
+根据上面这个例子，我们很容易发现 RAG 系统中最核心是外部知识的检索环节。专家能不能向你提供专业的家庭财务建议，取决于能不能精确找到他需要的信息，如果他找到的不是投资理财记录，而是家庭减肥计划，那再厉害的专家都会无能为力。
+
+## 3 RAG应用咋构建？
+
+### 3.1 无RAG的传统AI问答
+
+就像这样：
+
+```java
+public class TraditionalAI {
+    private StaticKnowledge knowledgeBase; // 训练时固化的知识
+    
+    public String answer(String question) {
+        // 只能基于内置知识回答
+        return knowledgeBase.search(question);
+    }
+}
+```
+
+**就像一个只依赖内存的Java应用：**
+
+- AI模型就像一个巨大的静态数据结构，所有知识都"硬编码"在模型参数中
+- 当用户问问题时，AI只能基于训练时学到的知识回答
+- 图中显示：对于OpenAI CEO的问题，没有RAG的系统回答"我无法提供评论...目前我没有关于CEO解雇和重新雇佣的信息"
+
+```java
+// 类比：没有RAG就像这样
+public class TraditionalAI {
+    private StaticKnowledge knowledgeBase; // 训练时固化的知识
+    
+    public String answer(String question) {
+        // 只能基于内置知识回答
+        return knowledgeBase.search(question);
+    }
+}
+```
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/6bc1a91e2ac250fa0558a52f89d48640.png)
+
+### 3.2 有RAG的知识库问答系统
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/74f210f06ba2acf4b91bb726e762ab39.png)
+
+RAG步骤：
+
+1. 知识切片成Chunk
+
+2. 向量化Chunk入库
+
+   > 前两步都是去知识库生成。
+
+3. Query检索知识Chunk
+
+4. 构建Prompts
+
+5. 调用LLM生成回答
+
+   > 后三步都是知识库生成后，在检索方面需要做的。
+
+就像一个连接了实时数据库的Java应用：
+
+#### ① 索引阶段（Indexing）
+
+```java
+// 类比：文档预处理和索引
+public class DocumentIndexer {
+    public void indexDocuments(List<Document> docs) {
+        for (Document doc : docs) {
+            // 1. 切分文档为chunks
+            List<String> chunks = splitIntoChunks(doc);
+            
+            // 2. 生成向量embeddings
+            for (String chunk : chunks) {
+                Vector embedding = embeddingModel.encode(chunk);
+                vectorDB.store(chunk, embedding);
+            }
+        }
+    }
+}
+```
+
+#### ② 检索阶段（Retrieval）
+
+```java
+public class RAGSystem {
+    private VectorDatabase vectorDB;
+    private LLM llm;
+    
+    public String answer(String question) {
+        // 1. 将问题转换向量
+        Vector questionVector = embeddingModel.encode(question);
+        
+        // 2. 向量数据库检索相关文档
+        List<String> relevantChunks = vectorDB.similaritySearch(
+            questionVector, topK = 3
+        );
+        
+        // 3. 结合检索到的信息和问题生成答案
+        String context = String.join("\n", relevantChunks);
+        String prompt = buildPrompt(question, context);
+        
+        return llm.generate(prompt);
+    }
+}
+```
+
+### 3.3 关键技术差异
+
+#### 向量化检索
+
+```java
+// RAG的核心：语义相似性搜索
+public List<String> findRelevantInfo(String query) {
+    Vector queryVector = embeddingModel.encode(query);
+    
+    // 不是关键词匹配，而是语义相似度
+    return vectorDB.cosineSearch(queryVector, threshold = 0.8);
+}
+```
+
+#### 动态上下文注入
+
+```java
+public String generateAnswer(String question, List<String> context) {
+    String prompt = String.format(
+        "基于以下信息回答问题：\n%s\n\n问题：%s", 
+        String.join("\n", context), 
+        question
+    );
+    return llm.complete(prompt);
+}
+```
+
+### 3.4 效果对比
+
+没有RAG：
+
+- ❌ 无法回答训练数据之后的新信息
+- ❌ 知识更新需要重新训练模型
+- ❌ 无法处理私有/企业内部数据
+
+有RAG：
+
+- ✅ 能够回答基于最新文档的问题
+- ✅ 图中显示：系统检索到相关的OpenAI新闻chunks，生成了详细分析
+- ✅ 可以随时更新知识库而不需要重训模型
+- ✅ 支持企业私有数据查询
+
+简单类比：
+
+- 没有RAG = 只能背书本的学生
+- 有RAG = 可随时查阅图书馆和互联网的学生
+
+因此RAG成为企业AI应用主流架构 - 让AI访问和利用实时、私有的数据源。
+
+- 使用RAG链路，用户先去构建好的知识库，即向量数据库里相似性检索，再带出一部分知识文档。这部分知识文档会跟用户的query结合
+- 再通过prompt技术组装成一个最终完成的一个输入给到LLM，让LLM回复
+
+最关键就是知识库生成这步，涉及把知识文档去做内容提取及拆分。还要进行量化，入库。
+
+## 4 基于Langchain构建 RAG 应用
+
+### 4.1 Langchain中RAG实现
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/08cc6cd9c8945bebc67d50fde04618f0.png)
+
+各种文档 - 各种 loader - 文本切片 - 嵌入向量化 - 向量存储 - 各种检索链。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/d23779a15d1e548c9fecfd3b501e8b3c.png)
+
+### 4.2 设计思想
+
+RAG五步拆成不同组件，再由不同节点处理。让用户去编写业务逻辑代码，再把这整个过程串起。
+
+### 4.3 优势
+
+- 可快速构建一个demo，助开发者理解RAG应用
+- 庞大社区支持，如一些插件或它的一个版本更新迭代都很快
+
+### 4.4 痛点
+
+本质上通用性很强。为保证强通用性，效果层面不一定做到最好，需企业或个人投入较大精力，把整体的RAG在召回层的效果提升到最佳。
+
+## 5 bad case
+
+构建整个RAG应用过程中会遇到的问题解决方案。
+
+### 5.1 拒答
+
+用户提问：请问A产品分析报告多久分析一次？
+
+召回的相关知识：A产品的分析报告信息近30天的数据分析结果。
+
+因为用户的问题，在相关知识没明确提到，只是有一定相似度，但跟我们用户问题不直接相关。这样的相关知识及用户问题，组装后交给LLM回答，本质上是人为制造干扰。
+
+对此，有个工程化实践叫拒答。
+
+### 5.2 消歧
+
+提问：A课程适合多大年龄小孩。
+
+知识库召回两条数据：
+
+- 其中一条是期望的一个知识，就在A课程文档，有一段话跟提问相关
+- 但还会召回其他的一个干扰知识。如其他文档里一些内容，像该课程适合3到7岁的小孩，适合6到8岁的女孩。这种知识内容也会被召回
+
+期望的召回内容携带一部分干扰信息，这干扰信息没有A课程这关键字，然后也不会召回。在这两个知识内容交给大源模型处理，他也无法理解哪个字内容正确。
+
+更希望在召回层，就有较好手段处理。工程化实践里，会对用户提问进行改写，增强query的一个效果。
+
+也用到类似BM25这种倒排索引，提升关键字的权重。如干扰知识里没生成这个关键字，其相似度分数较低，就不会召回。
+
+### 5.3 分类
+
+可能有用户的提问类似：服务器连接不上，应当如何解决？
+
+现在给知识库里面注入的文档，都是类似连接服务器应该有哪些步骤。
+
+将这些知识内容召回，交给LLM也能引导用户。但不能直切要害，用户更希望，我现在连接不上，有啥排查手段。更好的还是通过提供一些专门QA文档，增强整个知识召回内容准确性。
+
+用户可能问一些跟他实例相关的问题。如CPU占用变高或内存变高，实际响应可能是技术支持文档里的一些处理方案，就是我现在内存变更咋处理。但用户想知道为啥变高。有一个意图识别模型，判断用户他想要的问题具体是一个什么类的，需不需要用到RAG，也会判断他是否需要用到诊断引擎。类似问题2，需要用到诊断引擎，那我们会调用其他RAG无关的诊断相关技术为用户排查问题，并且给用户反馈一个结果。
+
+## 6 咋提升RAG应用效果？
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/436b65827d8f997647d25dc980076556.png)
+
+$$
+整体效果 = 文档处理效果 * Embedding效果 * Retrieval效果 * LLM效果
+$$
+demo易，但上手难，主要因为LangChain、LLamIndex框架盛行。很快接入就是初级的一个状态，可能只做到35%。
+
+想提高整体准确率，在拆分那儿会拆更合理、提取内容时，把整个内容提取更好。做向量化时，去选择我们的向量，更好的一个embedding模型。
+
+最终跟LLM交流时，选择效果更好的LLM，把这效果提升到更高。
+
+但60%的准确率还是达不到生产期望。希望准确率90%，在RAG应用构建各阶段，都有很多工程化手段。
+
+目前RAG整体应用在界内的比较关注的一个地方就是在召回。因为涉及知识文档，思考方向：
+
+- 优先保证召回率
+- 优先保证精度
+
+RAG召回是希望获得更多和用户提问相关的知识内容，还是只需更关键的知识内容排在最顶。某云厂商相关数据库AI套件选择前路，期望召回更多跟用户相关的提问的内容。
+
+精度尽量保证召回内容在top3、top5位置出现，因为召回的一些内容确实有一部分干扰信息。但目前LLM能力尚可，对这种干扰性信息的排除能力较好。
+
+## 7 RAG V.S 其它文本训练方案
+
+### 微调（Fine-tuning）
+
+在达到相似结果时，RAG 在成本效率和实时性能方面具有显著优势。同时，微调技术对于数据的质量和数量要求很高。并且应用程序在使用微调模型的可能也需要 RAG 技术的支持。
+
+### 长文本
+
+许多研究证实，LLM 在处理分析长文本时仍然面临着一个问题，即随着文本长度的增加，检索的准确性持续下降。因此，在任何情况下，都可以结合高精度搜索系统（RAG）。 LLM 的长文本能力和 RAG 可以完美地结合在一起，并且可以相互学习各自的长处，弥补各自的不足。
+
+## 8 总结
+
+整体而言，RAG 允许大模型访问外部最新信息的数据源，从而弥补相关领域的知识缺口，提升输出的回答与知识的相关性。RAG 能够帮助 LLM 与外部来源检索的可验证实时数据相结合，输出更加准确的答案，使结果变得真实可信，降低不必要的风险。
\ No newline at end of file
diff --git a/docs/md/RocketMQ/message-queues-more-than-app-communication.md b/docs/md/RocketMQ/message-queues-more-than-app-communication.md
new file mode 100644
index 000000000..434296af3
--- /dev/null
+++ b/docs/md/RocketMQ/message-queues-more-than-app-communication.md
@@ -0,0 +1,175 @@
+# 消息队列：不仅仅是应用间通信的工具
+
+见名知义，消息队列主要就是用来发送和接收处理消息，但它的作用可不仅解决应用间通信问题。
+
+## 1 MQ 的由来
+
+在工厂我们随处可见各种传送带，很多道工序都替代了人工一次次极大耗费劳动力的往返运动，而把一套业务分成若干部分，各流程之间传输所需材料即可。用编程思想，我们可以认为是传送带的发明解决了上下游工序间的“通信”问题。
+
+![](https://p.ipic.vip/iuxt5r.png)
+
+传送带的使用着实提高社会必要劳动生产时间，让人类工业社会效率显著提升。但就真的百利无一害了吗？
+我们会发现每道工序生产速度并不相同。有时上游的材料刚传送过来，工人可能正在处理上批材料，没有时间接收。不同工序的工人必须协调好什么时间往传送带上放置材料，若出现上下游工序速度不一致，上下游工人之间就得互相等待，确保不会出现传送带上的半成品材料挤压太多，无人接收！
+
+为解决该问题，在每组工序下游配备个暂存仓库，这样上游工人就不用等下游工人有空，任何时间都可把加工完成的半成品丢到传送带，无法接收的就被暂存在仓库，下游工人可随时来取。
+配备的仓库就起到了“通信”过程中“缓存”作用。
+
+这就是现实版MQ。
+
+## 2 消息队列适用场景
+
+### 2.1 异步
+
+跨系统的异步通信或应用内的同步变成异步。如秒杀系统，一个秒杀请求可能包含很多步骤：
+
+- 风控
+- 锁库存
+- 生成订单
+- 通知
+- 更新统计数据
+
+最低级的同步处理流程：App将请求发送给网关，依次调用上述流程，然后将结果返给APP。
+
+决定秒杀成功与否的实际上只有风控和锁库存。只要用户请求通过风控，并在Server完成库存锁定，就可给用户返回秒杀结果，对于后续生成订单、短信通知和更新统计数据等，并不一定要在秒杀请求中处理完。
+
+所以当服务端完成前2步，确定本次请求秒杀结果，即可给用户响应，然后把请求的数据放入MQ，由MQ异步执行后续操作。
+
+![](https://p.ipic.vip/op7zh8.png)
+
+五步变两，不仅响应更快，且在秒杀间，可把大量服务器资源用来处理秒杀请求。秒杀结束后再把资源用于处理后面步骤，榨干服务器资源。
+
+#### 优点
+
+- 更快地返回结果
+- 减少等待，自然实现了步骤之间的并发，提升系统总体的性能，集中力量办大事(同步部分)，碎片时间做小事(异步部分)
+
+#### 缺点
+
+- 降低数据一致性，如要保持强一致性，需高代价补偿（如分布式事务、对账）
+- 有数据丢失风险，如宕机重启，如要保证队列数据可用，需要额外机制保证(如双活容灾)
+
+### 2.2 流控
+
+#### 2.2.1 咋避免过多请求压垮秒杀系统？
+
+好程序有自我保护能力，即应该可在海量请求下，还能在自身能力范围尽可能多处理请求，拒绝处理不了的请求且保证自身运行正常，就像线程池一般顺畅。而不是像你我简单粗暴地直接拒绝请求并返回错误，这可不是啥好的用户体验。
+
+思路就是使用MQ隔离网关和后端服务，达成流控和保护后端服务。
+
+加入MQ，整个秒杀流程变为：
+
+1. 网关收到请求后，将请求放入请求MQ
+2. 后端服务从请求MQ获取APP请求，完成后续秒杀处理过程，然后返回结果
+
+![](https://p.ipic.vip/zs9o7a.png)
+
+秒杀开始后，当短时内大量秒杀请求到达网关，不会直接冲击后端秒杀服务，而是先堆积在MQ，后端服务尽力从MQ消费请求并处理。
+
+> 若消息量特大，消息适合存redis or rabbitmq？毕竟只是个小仓库，货量大了咋办？
+>
+> redis肯定不适合存消息，虽性能好，但那是和主流数据库比，大概几万tps；而现代消息队列都能很轻松做到几十万TPS性能。
+> 消息量特大时，需考虑使用有消息堆积能力的MQ，因为一旦消费慢，大量消息就会堆积到MQ，这时不太适合用RabbitMQ，可考虑RocketMQ、Kafka和Pulsar。
+
+对于超时请求可直接丢弃，APP将超时无响应请求处理为秒杀失败。运维人员还可随时增加秒杀服务的实例数量来水平扩容，无需对系统其他部分更改。
+
+#### 2.2.2 优点
+
+能根据下游的处理能力自动调节流量，削峰填谷。
+
+#### 2.2.3 缺点
+
+- 增加系统调用链环节，导致总体响应延时加长
+- 上下游系统都要将同步调用改为异步消息，增加系统复杂度
+
+
+有无简单点流控方式？若能预估秒杀服务的能力，就可用MQ实现个令牌桶，更简单流控。
+
+#### 2.2.4 令牌桶流控原理
+
+单位时间内，只发放固定数量令牌到桶里，规定服务在处理请求前，须先从令牌桶中取个令牌。若令牌桶中无令牌，则拒绝请求。
+
+这保证单位时间内，能处理请求不超过发放令牌数量，达成流控。
+
+##### 实现
+
+也简单，无需破坏原调用链，只要网关在处理APP请求时加个获取令牌流程。
+
+![](https://p.ipic.vip/4q8whj.png)
+
+令牌桶可简单地用一个有固定容量的消息队列加一个“令牌发生器”来实现：令牌发生器按照预估的处理能力，匀速生产令牌并放入令牌队列（如果队列满了则丢弃令牌），网关在收到请求时去令牌队列消费一个令牌，获取到令牌则继续调用后端秒杀服务，如果获取不到令牌则直接返回秒杀失败。
+
+> 令牌桶可用MQ或Redis实现，也可写一个简单的令牌桶服务，原理一样。
+
+以上常用的使用消息队列两种进行流量控制的设计方法，可根据各自的优缺点和不同的适用场景进行合理选择。
+
+### 2.3 服务解耦
+
+比如新订单创建时：
+
+1. 支付系统需要发起支付流程
+2. 风控系统需要审核订单的合法性
+3. 客服系统需要给用户发短信告知用户
+4. 经营分析系统需要更新统计数据；
+   …
+
+这些订单下游系统都需实时获得订单数据。随业务发展，订单下游不断变化，每个系统可能只需订单数据子集，订单服务团队不得不花精力，应对不断增变下游，不停修改订单系统与下游系统之间接口。任一下游系统接口变更，都需订单模块重上线，对核心的订单服务，这是不可接受的。
+
+所有的电商都选择用MQ解决类似的系统高耦合问题。
+订单服务在订单变化时发送一条消息到MQ的一个主题Order，所有下游系统都订阅该主题，这样每个下游系统都可获得一份实时完整订单数据。
+
+无论增加、减少下游系统或是下游系统需求如何变化，订单服务无需更改，实现了订单服务与下游服务解耦。
+
+#### 优点
+
+- 可在模块、服务、接口等不同粒度上实现解耦
+- 订阅/消费模式也可在数据粒度上解耦
+
+## 3 基于发布/订阅模型实现的事件驱动
+
+- 原使用 ETL、HTTP 调用 API方式
+- 现使用 MQ 定时任务去拉取数据
+
+再如实现一个微服务系统间的观察者模式。
+
+## 4 实现事务的最终一致性
+
+比如使用 rabbitmq 和 rocketmq。
+
+其他适用场景还有比如连接流计算任务和数据、将消息广播给大量接收者。
+
+在单体应用里需要用队列解决的，在分布式系统中大都可用MQ解决。
+MQ适用场景还是很多的，如秒杀、发邮件、发短信、高并发订单等。
+注意
+
+## 5 不适合 MQ 的场景
+
+如银行转账、电信开户、第三方支付等。
+关键还是要意识到消息队列的优劣点，然后分析场景是否适用。
+
+## FAQ
+
+Q：是否可用共享内存、RDMA提高MQ性能？
+
+A：若共享内存指PageCache，很多MQ会用，RDMA常见MQ都还没用。像Kafka消费时，直接用Zero Copy，数据直接从PageCache写到NIC的缓冲区，无需进入应用内存空间。
+
+现代MQ瓶颈不在本机内存数据交换，主要还是受限于网卡带宽或磁盘IO。Kafka这些MQ，都能打满万兆网卡或磁盘读写速度。
+
+---
+
+Q：APP⇆网关--生产-->消息队列--消费-->秒杀服务问题。海量请求都放在MQ，其整体容量咋衡量？MQ不可能能存放无限消息，MQ满了应该也会有拒绝策略，类似线程池？
+
+A：实际上，只要有足够磁盘容量，MQ确实可存放无限消息。像秒杀请求这种数据，峰值并发高，但总数据量不大，所以，堆积在MQ没问题。
+
+---
+
+Q：APP响应超时，即网关超时未返回。但消息还在任务队列，最终还会被秒杀服务处理，这样的话，返回给APP秒杀失败，但秒杀服务其实已消费消息？后续难道在网关做补偿？若连接已断开，将秒杀服务对此消息的处理做回滚操作？
+
+A：都按秒杀失败处理。
+
+---
+
+Q：网关和秒杀服务通过MQ通信，那响应消息也通过队列返回？队列中有APP对应的地址如IP？这样的话，APP的海量连接都同时连接网关，会有问题？
+
+A：响应一般用RPC实现。超时或返回秒杀结果前，网关和APP确实要保持连接，HTTP协议决定的。
+
+网关能不能承受海量APP连接？网关作用就是用来抗海量连接！
\ No newline at end of file
diff --git a/docs/md/design/flyweight-pattern.md b/docs/md/design/flyweight-pattern.md
new file mode 100644
index 000000000..bf676dd02
--- /dev/null
+++ b/docs/md/design/flyweight-pattern.md
@@ -0,0 +1,633 @@
+# 享元模式（Flyweight Pattern）
+
+## 1 简介
+
+结构型模式。“享元”，被共享的单元，即通过复用对象而节省内存，注意前提是享元对象是不可变对象。
+
+用于减少创建对象的数量，以减少内存占用和提高性能。尝试复用现有同类对象，若未找到匹配对象，则创建新对象。
+
+### 意图
+
+运用共享技术有效地支持大量细粒度的对象。
+
+### 主要解决
+
+在有大量对象时，有可能会造成内存溢出，我们把其中共同的部分抽象出来，如果有相同的业务请求，直接返回在内存中已有的对象，避免重新创建。
+
+## 2 优点
+
+大大减少对象的创建，降低系统的内存，使效率提高。
+
+## 3 缺点
+
+提高系统复杂度，需分离出外部状态、内部状态，且外部状态具有固有化的性质，不应随内部状态变化而变化，否则会造成系统混乱。
+
+## 4 适用场景
+
+- 系统中有大量对象
+
+- 这些对象消耗大量内存
+
+- 这些对象的状态大部分可外部化
+
+- 这些对象可以按照内蕴状态分为很多组，当把外蕴对象从对象中剔除出来时，每一组对象都可以用一个对象来代替
+
+- 系统不依赖于这些对象身份，这些对象是不可分辨的
+
+- 系统有大量相似对象
+
+- 需要缓冲池的场景
+
+这些类必须有一个工厂对象加以控制。
+
+### 如何解决
+
+用唯一标识码判断，如果在内存中有，则返回这个唯一标识码所标识的对象。
+
+### 关键代码
+
+用 HashMap 存储这些对象。
+
+### 应用实例
+
+- String，若有则返回，无则创建一个字符串保存在字符串缓存池
+- 数据库的数据池
+
+## 5 原理
+
+当一个系统中存在大量重复对象，若这些重复对象是【不可变】对象，就能用该模式将对象设计成享元，在内存中只保留一份实例供引用。减少了内存中对象数量，最终节省内存。
+
+不仅是相同对象，相似对象也能提取对象中的相同部分（字段）设计成享元。
+
+### “不可变对象”
+
+一旦构造器初始化完成后，其状态（对象的成员变量或属性）就不会再被修改。所以，不可变对象不能暴露任何set()等修改内部状态的方法。之所以要求享元是不可变对象，是因为它会被多处代码共享使用，避免一处代码修改享元，影响到其他使用它的代码。
+
+### 实现
+
+主要通过工厂模式，在工厂类中，通过一个Map或List缓存已创建好的享元对象，以复用。
+
+## 6 案例
+
+### 6.1 象棋
+
+一个游戏厅中有成千上万个“房间”，每个房间对应一个棋局。棋局要保存每个棋子的数据，比如：棋子类型（将、相、士、炮等）、棋子颜色（红方、黑方）、棋子在棋局中的位置。利用这些数据，我们就能显示一个完整的棋盘给玩家。具体的代码如下所示:
+
+- ChessPiece类表示棋子
+- ChessBoard类表示一个棋局，里面保存了象棋中30个棋子的信息
+
+```java
+/**
+ * 棋子
+ *
+ * @author JavaEdge
+ * @date 2022/5/28
+ */
+@AllArgsConstructor
+@Getter
+@Setter
+public class ChessPiece {
+
+    private int id;
+
+    private String text;
+
+    private Color color;
+
+    private int positionX;
+
+    private int positionY;
+
+    public static enum Color {
+        RED, BLACK
+    }
+}
+```
+
+```java
+/**
+ * 棋局
+ */
+public class ChessBoard {
+    private Map<Integer, ChessPiece> chessPieces = new HashMap<>();
+
+    public ChessBoard() {
+        init();
+    }
+
+    private void init() {
+        chessPieces.put(1, new ChessPiece(1, "車", ChessPiece.Color.BLACK, 0, 0));
+        chessPieces.put(2, new ChessPiece(2, "馬", ChessPiece.Color.BLACK, 0, 1));
+        //...省略摆放其他棋子的代码...
+    }
+
+    public void move(int chessPieceId, int toPositionX, int toPositionY) {
+        //...省略...
+    }
+}
+```
+
+为记录每个房间当前的棋局情况，要给每个房间都创建一个ChessBoard棋局对象。因为游戏大厅中有成千上万房间，保存这么多棋局对象就会消耗大量内存。咋节省内存？
+
+就得用上享元模式。在内存中有大量相似对象。这些相似对象的id、text、color都一样，仅positionX、positionY不同。将棋子的id、text、color属性拆出设计成独立类，并作为享元供多个棋盘复用。棋盘只需记录每个棋子的位置信息：
+
+```java
+/**
+ * 享元类
+ */
+public class ChessPieceUnit {
+
+    private int id;
+
+    private String text;
+
+    private Color color;
+
+    public static enum Color {
+        RED, BLACK
+    }
+}
+```
+
+```java
+public class ChessPieceUnitFactory {
+
+    private static final Map<Integer, ChessPieceUnit> PIECES = new HashMap<>();
+
+    static {
+        PIECES.put(1, new ChessPieceUnit(1, "車", ChessPieceUnit.Color.BLACK));
+        PIECES.put(2, new ChessPieceUnit(2, "馬", ChessPieceUnit.Color.BLACK));
+        //...省略摆放其他棋子的代码...
+    }
+
+    public static ChessPieceUnit getChessPiece(int chessPieceId) {
+        return PIECES.get(chessPieceId);
+    }
+}
+```
+
+```java
+@AllArgsConstructor
+@Data
+public class NewChessPiece {
+
+    private ChessPieceUnit chessPieceUnit;
+
+    private int positionX;
+
+    private int positionY;
+}
+```
+
+```java
+/**
+ * 棋局
+ */
+public class NewChessBoard {
+
+    private Map<Integer, NewChessPiece> chessPieces = new HashMap<>();
+
+    public NewChessBoard() {
+        init();
+    }
+
+    private void init() {
+        chessPieces.put(1, new NewChessPiece(
+                ChessPieceUnitFactory.getChessPiece(1), 0, 0));
+        chessPieces.put(1, new NewChessPiece(
+                ChessPieceUnitFactory.getChessPiece(2), 1, 0));
+        //...摆放其他棋子
+    }
+
+    public void move(int chessPieceId, int toPositionX, int toPositionY) {
+        //...
+    }
+}
+```
+
+利用工厂类缓存ChessPieceUnit信息（id、text、color）。通过工厂类获取到的ChessPieceUnit就是享元。所有ChessBoard对象共享这30个ChessPieceUnit对象（因为象棋中只有30个棋子）。在使用享元模式之前，记录1万个棋局，我们要创建30万（30*1万）个棋子的ChessPieceUnit对象。利用享元模式，只需创建30个享元对象供所有棋局共享使用即可，大大节省内存。
+
+主要通过工厂模式，在工厂类中，通过Map缓存已创建过的享元对象，达到复用。
+
+###  6.2 文本编辑器
+
+若文本编辑器只实现文字编辑功能，不包含图片、表格编辑。简化后的文本编辑器，要在内存表示一个文本文件，只需记录文字、格式两部分信息。格式又包括字体、大小、颜色。
+
+一般按文本类型（标题、正文……）设置文字格式，标题是一种格式，正文是另一种。但理论上可给文本文件中的每个文字都设置不同格式。为实现如此灵活格式设置，且代码实现又不复杂，把每个文字都当作一个独立对象，并在其中包含它的格式信息：
+
+```java
+/**
+ * 文字
+ */
+@AllArgsConstructor
+@Data
+public class Character {
+
+    private char c;
+
+    private Font font;
+
+    private int size;
+
+    private int colorRGB;
+}
+```
+
+```java
+public class Editor {
+
+    private List<Character> chars = new ArrayList<>();
+
+    public void appendCharacter(char c, Font font, int size, int colorRGB) {
+        Character character = new Character(c, font, size, colorRGB);
+        chars.add(character);
+    }
+}
+```
+
+文本编辑器中，每敲一个字，就调Editor#appendCharacter()，创建一个新Character对象，保存到chars数组。若一个文本文件中，有上万、十几万、几十万的文字，就得在内存存储大量Character对象，咋节省内存？
+
+一个文本文件用到的字体格式不多，毕竟不可能有人把每个文字都置不同格式。所以，字体格式可设计成享元，让不同文字共享：
+
+```java
+public class CharacterStyle {
+  
+  private Font font;
+  
+  private int size;
+  
+  private int colorRGB;
+
+  @Override
+  public boolean equals(Object o) {
+    CharacterStyle otherStyle = (CharacterStyle) o;
+    return font.equals(otherStyle.font)
+            && size == otherStyle.size
+            && colorRGB == otherStyle.colorRGB;
+  }
+}
+
+public class CharacterStyleFactory {
+  private static final List<CharacterStyle> styles = new ArrayList<>();
+
+  public static CharacterStyle getStyle(Font font, int size, int colorRGB) {
+    CharacterStyle newStyle = new CharacterStyle(font, size, colorRGB);
+    for (CharacterStyle style : styles) {
+      if (style.equals(newStyle)) {
+        return style;
+      }
+    }
+    styles.add(newStyle);
+    return newStyle;
+  }
+}
+
+public class Character {
+  
+  private char c;
+  
+  private CharacterStyle style;
+}
+
+public class Editor {
+  private List<Character> chars = new ArrayList<>();
+
+  public void appendCharacter(char c, Font font, int size, int colorRGB) {
+    Character character = new Character(c, CharacterStyleFactory.getStyle(font, size, colorRGB));
+    chars.add(character);
+  }
+}
+```
+
+### 6.3 Shape
+
+无论何时接收到请求，都会创建一个特定颜色的圆。
+
+它将向 ShapeFactory 传递信息（red / green / blue/ black / white），以便获取它所需对象的颜色。
+
+![](https://p.ipic.vip/jtnqze.png)
+
+步骤 1：创建一个接口。
+
+```java
+public interface Shape {
+   void draw();
+}
+```
+
+步骤 2：创建实现接口的实体类。
+
+```java
+public class Circle implements Shape {
+    private String color;
+    private int x;
+    private int y;
+    private int radius;
+
+    public Circle(String color) {
+        this.color = color;
+    }
+
+    @Override
+    public void draw() {
+        System.out.println("Circle: Draw() [Color : " + color
+                + ", x : " + x + ", y :" + y + ", radius :" + radius);
+    }
+}
+```
+
+步骤 3：创建一个工厂，生成基于给定信息的实体类的对象。
+
+```java
+public class ShapeFactory {
+    private static final HashMap<String, Shape> circleMap = new HashMap<>();
+
+    public static Shape getCircle(String color) {
+        Circle circle = (Circle) circleMap.get(color);
+
+        if (circle == null) {
+            circle = new Circle(color);
+            circleMap.put(color, circle);
+            System.out.println("Creating circle of color : " + color);
+        }
+        return circle;
+    }
+}
+```
+
+步骤 4：使用该工厂，通过传递颜色信息来获取实体类的对象。
+
+```java
+public class FlyweightPatternDemo {
+    private static final String colors[] =
+            {"Red", "Green", "Blue", "White", "Black"};
+
+    public static void main(String[] args) {
+
+        for (int i = 0; i < 20; ++i) {
+            Circle circle =
+                    (Circle) ShapeFactory.getCircle(getRandomColor());
+            circle.setX(getRandomX());
+            circle.setY(getRandomY());
+            circle.setRadius(100);
+            circle.draw();
+        }
+    }
+
+    private static String getRandomColor() {
+        return colors[(int) (Math.random() * colors.length)];
+    }
+
+    private static int getRandomX() {
+        return (int) (Math.random() * 100);
+    }
+
+    private static int getRandomY() {
+        return (int) (Math.random() * 100);
+    }
+}
+```
+
+步骤 5：执行程序，输出结果。
+
+### 6.4 Integer
+
+```java
+Integer i1 = 56;
+Integer i2 = 56;
+Integer i3 = 129;
+Integer i4 = 129;
+System.out.println(i1 == i2);
+System.out.println(i3 == i4);
+```
+
+Java为基本数据类型提供了对应包装器：
+
+| 基本数据类型 | 对应的包装器类型 |
+| ------------ | ---------------- |
+| int          | Integer          |
+| long         | Long             |
+| float        | Float            |
+| double       | Double           |
+| boolean      | Boolean          |
+| short        | Short            |
+| byte         | Byte             |
+| char         | Character        |
+
+```java
+Integer i = 56; //自动装箱
+int j = i; //自动拆箱
+```
+
+数值56是基本数据类型int，当赋值给包装器类型（Integer）变量的时候，触发自动装箱操作，创建一个Integer类型的对象，并且赋值给变量i。底层相当于执行：
+
+```java
+// 底层执行了：Integer i = Integer.valueOf(59);
+Integer i = 59;
+```
+
+反过来，当把包装器类型的变量i，赋值给基本数据类型变量j的时候，触发自动拆箱操作，将i中的数据取出，赋值给j。其底层相当于执行了下面这条语句：
+
+```java
+// 底层执行了：int j = i.intValue();
+int j = i;
+```
+
+#### Java对象在内存的存储
+
+```java
+User a = new User(123, 23); // id=123, age=23
+```
+
+内存存储结构图：a存储的值是User对象的内存地址，即a指向User对象
+
+![](https://p.ipic.vip/43t0tq.png)
+
+通过“==”判定相等时，实际上是在判断两个局部变量存储的地址是否相同，即判断两个局部变量是否指向相同对象。
+
+```java
+Integer i1 = 56;
+Integer i2 = 56;
+Integer i3 = 129;
+Integer i4 = 129;
+System.out.println(i1 == i2);
+System.out.println(i3 == i4);
+```
+
+前4行赋值语句都会触发自动装箱操作，即创建Integer对象并赋值给i1、i2、i3、i4变量。i1、i2尽管存储数值相同56，但指向不同Integer对象，所以通过`==`来判定是否相同的时候，会返回false。同理，i3==i4判定语句也会返回false。
+
+不过，上面的分析还是不对，答案并非是两个false，而是一个true，一个false。因为Integer用了享元模式复用对象，才导致这样的运行差异。通过自动装箱，即调用valueOf()创建Integer对象时，如果要创建的Integer对象的值在-128到127之间，会从IntegerCache类中直接返回，否则才调用new方法创建：
+
+```java
+public static Integer valueOf(int i) {
+    if (i >= IntegerCache.low && i <= IntegerCache.high)
+        return IntegerCache.cache[i + (-IntegerCache.low)];
+    return new Integer(i);
+}
+```
+
+实际上，这里的IntegerCache相当于，我们上一节课中讲的生成享元对象的工厂类，只不过名字不叫xxxFactory而已。我们来看它的具体代码实现。这个类是Integer的内部类，你也可以自行查看JDK源码。
+
+```java
+/**
+ * Cache to support the object identity semantics of autoboxing for values between
+ * -128 and 127 (inclusive) as required by JLS.
+ *
+ * The cache is initialized on first usage.  The size of the cache
+ * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
+ * During VM initialization, java.lang.Integer.IntegerCache.high property
+ * may be set and saved in the private system properties in the
+ * sun.misc.VM class.
+ */
+private static class IntegerCache {
+    static final int low = -128;
+    static final int high;
+    static final Integer cache[];
+
+    static {
+        // high value may be configured by property
+        int h = 127;
+        String integerCacheHighPropValue =
+            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
+        if (integerCacheHighPropValue != null) {
+            try {
+                int i = parseInt(integerCacheHighPropValue);
+                i = Math.max(i, 127);
+                // Maximum array size is Integer.MAX_VALUE
+                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
+            } catch( NumberFormatException nfe) {
+                // If the property cannot be parsed into an int, ignore it.
+            }
+        }
+        high = h;
+
+        cache = new Integer[(high - low) + 1];
+        int j = low;
+        for(int k = 0; k < cache.length; k++)
+            cache[k] = new Integer(j++);
+
+        // range [-128, 127] must be interned (JLS7 5.1.7)
+        assert IntegerCache.high >= 127;
+    }
+
+    private IntegerCache() {}
+}
+```
+
+Q：为啥IntegerCache只缓存-128到127之间整型值？
+
+IntegerCache类被加载时，缓存的享元对象会被集中一次性创建好。整型值太多，不可能IntegerCache类预先创建好所有，既占太多内存，也使加载IntegerCache类时间过长。只能选择缓存对大部分应用来说最常用整型值，即一个字节大小（-128到127之间数据）。
+
+JDK也提供方法可自定义缓存最大值，两种方式：
+
+如果你通过分析应用的JVM内存占用情况，发现-128到255之间的数据占用的内存比较多，可将缓存最大值从127调到255，但JDK没有提供设置最小值方法。
+
+```bash
+# 方法一
+-Djava.lang.Integer.IntegerCache.high=255
+# 方法二
+-XX:AutoBoxCacheMax=255
+```
+
+因为56处于-128和127之间，i1和i2会指向相同的享元对象，所以`i1==i2`返回true。而129大于127，并不会被缓存，每次都会创建一个全新的对象，也就是说，i3和i4指向不同的Integer对象，所以i3==i4返回false。
+
+实际上，除了Integer类型之外，其他包装器类型，比如Long、Short、Byte等，也都利用了享元模式来缓存-128到127之间的数据。比如，Long类型对应的LongCache享元工厂类及valueOf()函数代码如下所示：
+
+```java
+private static class LongCache {
+    private LongCache(){}
+
+    static final Long cache[] = new Long[-(-128) + 127 + 1];
+
+    static {
+        for(int i = 0; i < cache.length; i++)
+            cache[i] = new Long(i - 128);
+    }
+}
+
+public static Long valueOf(long l) {
+    final int offset = 128;
+    if (l >= -128 && l <= 127) { // will cache
+        return LongCache.cache[(int)l + offset];
+    }
+    return new Long(l);
+}
+```
+
+平时开发对下面这样三种创建整型对象的方式，优先用后两种：
+
+```java
+// 第一种创建方式不会用到IntegerCache
+Integer a = new Integer(123);
+// 后两种创建方法可用IntegerCache缓存，返回共享对象
+Integer a = 123;
+Integer a = Integer.valueOf(123);
+```
+
+极端案例：
+
+若程序需创建1万个 `-128~127` 之间的Integer对象：
+
+- 使用第一种创建方式，需分配1万个Integer对象的内存空间
+- 使用后两种创建方式，最多只需分配256个Integer对象的内存空间
+
+### 6.5 String
+
+```java
+String s1 = "JavaEdge";
+String s2 = "JavaEdge";
+String s3 = new String("JavaEdge");
+
+// true
+System.out.println(s1 == s2);
+// false
+System.out.println(s1 == s3);
+```
+
+跟Integer设计相似，String利用享元模式复用相同字符串常量（即“JavaEdge”）。JVM会专门开辟一块存储区来存储字符串常量，即“字符串常量池”，对应内存存储结构示意图：
+
+![](https://p.ipic.vip/hynfbg.png)
+
+不同点：
+
+- Integer类要共享对象，是在类加载时，一次性全部创建好
+- 字符串，没法预知要共享哪些字符串常量，所以无法事先创建，只能在某字符串常量第一次被用到时，存储到常量池，再用到时，直接引用常量池中已存在的
+
+## 7 竞品
+
+### 7.1 V.S 单例
+
+- 单例模式，一个类只能创建一个对象
+- 享元模式，一个类可创建多个对象，每个对象被多处代码引用共享。类似单例的变体：多例。
+
+还是要看设计意图，即要解决啥问题：
+
+- 享元模式是为对象复用，节省内存
+- 单例模式是为限制对象个数
+
+### 7.2 V.S 缓存
+
+享元模式得实现，通过工厂类“缓存”已创建好的对象。“缓存”实际上是“存储”，跟平时说的“数据库缓存”、“CPU缓存”、“MemCache缓存”是两回事。平时所讲的缓存，主要为提高访问效率，而非复用。
+
+### 7.3  V.S 对象池
+
+C++内存管理由程序员负责。为避免频繁地进行对象创建和释放导致内存碎片，可以预先申请一片连续的内存空间，即对象池。每次创建对象时，我们从对象池中直接取出一个空闲对象来使用，对象使用完成之后，再放回到对象池中以供后续复用，而非直接释放掉。
+
+![](https://img-blog.csdnimg.cn/2eddeff69489437797bf59b07d1219a2.png)
+
+虽然对象池、连接池、线程池、享元模式都是为复用，但对象池、连接池、线程池等池化技术中的“复用”和享元模式中的“复用”是不同概念：
+
+- 池化技术中的“复用”可以理解为“重复使用”，主要目的是节省时间（比如从数据库池中取一个连接，不需要重新创建）。在任意时刻，每一个对象、连接、线程，并不会被多处使用，而是被一个使用者独占，当使用完成之后，放回到池中，再由其他使用者重复利用
+- 享元模式中的“复用”可以理解为“共享使用”，在整个生命周期中，都是被所有使用者共享的，主要目的是节省空间
+
+## X 总结
+
+- 单例模式是为保证对象全局唯一
+- 享元模式是为实现对象复用，节省内存。缓存是为提高访问效率，而非复用
+- 池化技术中的“复用”理解为“重复使用”，主要为节省时间
+
+Integer的-128到127之间整型对象会被事先创建好，缓存在IntegerCache类。当使用自动装箱或valueOf()创建这个数值区间的整型对象时，会复用IntegerCache类事先创建好的对象。IntegerCache类就是享元工厂类，事先创建好的整型对象就是享元对象。
+
+String类，JVM开辟一块存储区（字符串常量池）存储字符串常量，类似Integer的IntegerCache。但并非事先创建好需要共享的对象，而是在程序运行期间，根据需要创建和缓存字符串常量
+
+享元模式对GC不友好。因为享元工厂类一直保存对享元对象的引用，导致享元对象在无任何代码使用时，也不会被GC。因此，某些情况下，若对象生命周期很短，也不会被密集使用，利用享元模式反倒浪费更多内存。务必验证享元模式真的能大大节省内存吗。
\ No newline at end of file
diff --git a/docs/md/es/building-product-search-system-with-es.md b/docs/md/es/building-product-search-system-with-es.md
new file mode 100644
index 000000000..60d6b32e3
--- /dev/null
+++ b/docs/md/es/building-product-search-system-with-es.md
@@ -0,0 +1,254 @@
+# ES实战从零搭建高性能商品搜索系统
+
+搜索这个特性可以说是无处不在，现在很少有网站或者系统不提供搜索功能了，所以，即使你不是一个专业做搜索的程序员，也难免会遇到一些搜索相关的需求。搜索这个东西，表面上看功能很简单，就是一个搜索框，输入关键字，然后搜出来想要的内容就好了。
+
+## 搜索背后的实现
+
+- 可以非常简单，用一个SQL，LIKE一下就能实现
+- 也可很复杂，不说百度谷歌这种专业做搜索的公司，其他非专业做搜索的互联网大厂，搜索团队大多是千人规模，这里面不仅有程序员，还有算法工程师、业务专家等等
+
+区别仅是搜索速度快慢及搜出来的内容好坏。
+
+## 倒排索引（Inverted Index）
+
+数据大多存数据库，用SQL的LIKE也能实现匹配搜出结果，为啥还专门做搜索系统？
+
+### 为啥数据库不适合做搜索？
+
+搜索的核心需求是全文匹配，对此，数据库索引派不上用场，那只能全表扫描。全表扫描慢，还需要在每条记录上做全文匹配，即一个字一个字比对，就更慢。所以，使用数据做搜索，性能差。
+
+ES咋解决搜索问题？假设两个商品：
+
+- 烟台红富士苹果
+- 苹果手机iPhone XS Max
+
+| DOCID | SKUID        | 标题                                                         |
+| ----- | ------------ | ------------------------------------------------------------ |
+| 666   | 100002860826 | 烟台红富士苹果 5kg 一级铂金大果 单果230g以上 新鲜水果        |
+| 888   | 100000177760 | 苹果 Apple iPhone XS Max (A2104) 256GB 金色 移动联通电信4G手机 双卡双待 |
+
+DOCID就是唯一标识一条记录的ID，类似数据库主键。为支持快速全文搜索，ES对文本采用倒排索引。ES中这两条商品数据倒排索引：
+
+| TERM   | DOCID   |
+| ------ | ------- |
+| 烟台   | 666     |
+| 红富士 | 666     |
+| 苹果   | 666,888 |
+| 5kg    | 666     |
+| 一级   | 666     |
+| 铂金   | 666     |
+| 大果   | 666     |
+| Apple  | 888     |
+| iphone | 888     |
+| XS     | 888     |
+| Max    | 888     |
+| 手机   | 888     |
+| ...    | ...     |
+
+倒排索引表，以单词作为索引的K，每个单词的倒排索引的值是一个列表，这个列表的元素就是含有这个单词的商品记录的DOCID。
+
+### 倒排索引构建
+
+往ES写商品记录时，ES先对需搜索的字段（商品标题）进行分词，即把一段连续文本按语义拆成多个单词。然后ES按单词给商品记录做索引，就形成上表的倒排索引。
+
+搜“苹果手机”时，ES对关键字也进行分词，如“苹果手机”分为“苹果”、“手机”。然后，ES在倒排索引搜索输入的每个关键字分词，搜索结果：
+
+| TERM | DOCID   |
+| ---- | ------- |
+| 苹果 | 666,888 |
+| 手机 | 888     |
+
+666、888两条记录都能匹配上搜索的关键词，但888商品比666这商品匹配度更高，因为它两个单词都能匹配上，所以按匹配度把结果做一个排序，最终返回的搜索结果：
+
+- 苹果Apple iPhone XS Max (A2104) 256GB 金色 移动联通电信4G手机双卡双待
+- 烟台红富士苹果5kg 一级铂金大果 单果230g以上 新鲜水果
+
+### 为何倒排索引能做到快速搜索
+
+这搜索过程是对上面的倒排索引做二次查找，一次找“苹果”，一次找“手机”。
+
+整个搜索过程，没有做过任何文本模糊匹配。ES的存储引擎存储倒排索引时，肯定不是像我们上面表格中展示那样存成一个二维表，实际上它的物理存储结构和InnoDB索引差不多，都是一颗查找树。
+
+对倒排索引做两次查找，即对树进行二次查找，时间复杂度类似MySQL二次命中索引的查找。这查找速度比用MySQL全表扫描+模糊匹配，快好几个数量级。
+
+## 如何在ES中构建商品的索引?
+
+用ES构建一个商品索引，实现一个商品搜索系统。ES为搜索而生，但本质仍是个存储系统：
+
+| ElasticSearch | RDBMS  |
+| ------------- | ------ |
+| INDEX         | 表     |
+| DOCUMENT      | 行     |
+| FIELD         | 列     |
+| MAPPING       | 表结构 |
+
+ES数据的逻辑结构类似MongoDB，每条数据称为一个DOCUMENT，简称DOC，是个JSON对象，DOC中的每个JSON字段，在ES中称为FIELD，把一组具有相同字段的DOC存放在一起，存放它们的逻辑容器叫INDEX，这些DOC的JSON结构称为MAPPING。
+
+这里面最不好理解的就是这INDEX，类似MySQL表，而不是通常理解的用于查找数据的索引。
+
+为让ES支持中文分词，需要给ES安装一个中文的分词插件IK Analysis for Elasticsearch，告诉ES怎么对中文文本分词。
+
+直接执行下面的命令自动下载并安装：
+
+```bash
+$elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.6.0/elasticsearch-analysis-ik-7.6.0.zip
+```
+
+安装完成后，需要重启ES，验证一下是否安装成功：
+
+```json
+curl -X POST "localhost:9200/_analyze?pretty" -H 'Content-Type: application/json' -d '{ "analyzer": "ik_smart", "text": "JavaEdge" }'
+{
+  "tokens" : [
+    {
+      "token" : "极",
+      "start_offset" : 0,
+      "end_offset" : 1,
+      "type" : "CN_CHAR",
+      "position" : 0
+    },
+    {
+      "token" : "客",
+      "start_offset" : 1,
+      "end_offset" : 2,
+      "type" : "CN_CHAR",
+      "position" : 1
+    },
+    {
+      "token" : "天地",
+      "start_offset" : 2,
+      "end_offset" : 4,
+      "type" : "CN_WORD",
+      "position" : 2
+    }
+  ]
+}
+```
+
+这分词器把“极客天地”分成“极”、“客”和“天地”，没认出来“极客”，有改进空间。
+
+为实现商品搜索，需先把商品信息存放到ES。先定义存放在ES中商品的数据结构，即MAPPING：
+
+| Field  | Datatype | 说明     |
+| ------ | -------- | -------- |
+| sku_id | long     | 商品ID   |
+| title  | text     | 商品标题 |
+
+这MAPPING只需两个字段：
+
+- sku_id
+- title
+
+用户搜索商品时，在ES中匹配商品标题，返回符合条件商品的sku_ids。ES默认提供标准RESTful接口，直接HTTP访问即可。
+
+使用上面这MAPPING创建INDEX，类似MySQL创建一个表：
+
+```json
+// INDEX的名称是“sku”
+curl -X PUT "localhost:9200/sku" -H 'Content-Type: application/json' -d '{
+        "mappings": {
+                "properties": {
+                        "sku_id": {
+                                "type": "long"
+                        },
+                  		  // 要在title字段进行全文搜索
+                        "title": {
+                                "type": "text",
+                          			 // 中文分词插件IK
+                                "analyzer": "ik_max_word",
+                                "search_analyzer": "ik_max_word"
+                        }
+                }
+        }
+}'
+```
+
+往INDEX写两条商品数据：
+
+```json
+curl -X POST "localhost:9200/sku/_doc/" -H 'Content-Type: application/json' -d '{
+        "sku_id": 100002860826,
+        "title": "烟台红富士苹果 5kg 一级铂金大果 单果230g以上 新鲜水果"
+}'
+
+{"_index":"sku","_type":"_doc","_id":"yxQVSHABiy2kuAJG8ilW","_version":1,"result":"created","_shards":{"total":2,"successful":1,"failed":0},"_seq_no":0,"_primary_term":1}
+
+
+curl -X POST "localhost:9200/sku/_doc/" -H 'Content-Type: application/json' -d '{
+        "sku_id": 100000177760,
+        "title": "苹果 Apple iPhone XS Max (A2104) 256GB 金色 移动联通电信4G手机 双卡双待"
+}'
+```
+
+HTTP GET商品搜索：
+
+```bash
+curl -X GET 'localhost:9200/sku/_search?pretty' -H 'Content-Type: application/json' -d '{
+  "query" : { "match" : { "title" : "苹果手机" }}
+}'
+{
+  "took" : 23,
+  "timed_out" : false,
+  "_shards" : {
+    "total" : 1,
+    "successful" : 1,
+    "skipped" : 0,
+    "failed" : 0
+  },
+  "hits" : {
+    "total" : {
+      "value" : 2,
+      "relation" : "eq"
+    },
+    "max_score" : 0.8594865,
+    "hits" : [
+      {
+        "_index" : "sku",
+        "_type" : "_doc",
+        "_id" : "zBQWSHABiy2kuAJGgim1",
+        "_score" : 0.8594865,
+        "_source" : {
+          "sku_id" : 100000177760,
+          "title" : "苹果 Apple iPhone XS Max (A2104) 256GB 金色 移动联通电信4G手机 双卡双待"
+        }
+      },
+      {
+        "_index" : "sku",
+        "_type" : "_doc",
+        "_id" : "yxQVSHABiy2kuAJG8ilW",
+        "_score" : 0.18577608,
+        "_source" : {
+          "sku_id" : 100002860826,
+          "title" : "烟台红富士苹果 5kg 一级铂金大果 单果230g以上 新鲜水果"
+        }
+      }
+    ]
+  }
+}
+```
+
+请求中的URL:
+
+- “sku”代表要在sku这个INDEX内进行查找
+- “_search”是一个关键字，表示要进行搜索
+- pretty表示格式化返回的JSON
+
+请求BODY的JSON，query中的match表示要进行全文匹配，匹配的字段就是title，关键字是“苹果手机”。返回结果中匹配到2条商品记录。
+
+## 总结
+
+ES构建商品搜索服务：
+
+- 先安装ES并启动服务
+- 创建一个INDEX，定义MAPPING
+- 写入数据后，执行查询并返回查询结果
+
+类似数据库先建表、插入数据然后查询。把ES当做一个支持全文搜索的数据库即可。
+
+ES本质是支持全文搜索的分布式内存数据库，适用于构建搜索系统。全文搜索性能最关键是采用倒排索引，一种特别为搜索而设计的索引结构：
+
+- 先对需索引的字段进行分词
+- 再以分词为索引组成一个查找树
+- 就把一个全文匹配的查找转换成对树的查找
+
+这是倒排索引能够快速进行搜索的根本原因。但倒排索引相比B树索引，写和更新性能较差，只适合全文搜索，不适合更新频繁的交易数据。
\ No newline at end of file
diff --git a/docs/md/jvm/deep-dive-into-jvm-runtime-data-areas-from-pc-to-metaspace.md b/docs/md/jvm/deep-dive-into-jvm-runtime-data-areas-from-pc-to-metaspace.md
new file mode 100644
index 000000000..770584e4e
--- /dev/null
+++ b/docs/md/jvm/deep-dive-into-jvm-runtime-data-areas-from-pc-to-metaspace.md
@@ -0,0 +1,525 @@
+# 深入剖析JVM运行时数据区：从程序计数器到元空间
+
+## 0 前言
+
+内存是非常重要的系统资源，是硬盘和CPU的中间仓库及桥梁，承载着os和应用程序的实时运行。
+
+JVM内存布局规定Java在运行过程中内存申请、分配、管理的策略，保证JVM高效稳定运行。不同JVM内存划分方式和管理机制存异。结合JVM虚拟机规范，本文探讨经典JVM内存布局。
+
+### JVM运行时数据区
+
+![](https://p.ipic.vip/0p3h6i.png)
+
+- 线程独占：
+  每个线程都会有它独立的空间，随线程生命周期而创建和销毁
+- 线程共享：所有线程能访问这块内存数据，随虚拟机或者GC而创建和销毁
+
+
+- JDK8的JVM内存模型：
+  ![](/Users/sss/Library/Application Support/typora-user-images/image-20220118015949155.png)
+
+![](https://p.ipic.vip/nintb9.png)
+
+## 1 程序计数寄存器
+
+Program Counter Register，后文简称PCR：
+
+![](https://p.ipic.vip/cnihpb.png)
+
+Register名源于CPU的寄存器，CPU只有把数据装载到寄存器才能运行。
+
+寄存器存储指令相关的现场信息，由于CPU时间片轮限制，众多线程在并发执行过程中，任何一个确定时刻，一个或多核处理器中的一个内核，只会执行某个线程中的一条指令。这样必然导致经常中断或恢复，如何保证分毫无差呢?
+每个线程在创建后，都会产生自己的程序计数器和栈帧，程序计数器用来存放执行指令的偏移量和行号指示器等，线程执行或恢复都要依赖程序计数器。程序计数器在各个线程之间互不影响，此区域也不会发生内存溢出异常。
+
+### 1.1. 定义
+
+可看作当前线程正在执行的字节码的行号指示器。如当前线程正在执行：
+
+- Java方法：记录值是当前线程正在执行的字节码指令的地址
+- 本地方法：记录值为undefined                   
+
+### 1.2. 作用
+
+- 字节码解释器通过改变PCR，依次读取指令，实现代码的流程控制，如顺序执行、选择、循环、异常处理
+- 多线程下，PCR记录当前线程执行的位置，从而当线程被切换回来的时候能够知道该线程上次运行到哪了
+
+### 1.3. 特点
+
+一块较小的内存空间，【线程私有】。每条线程都有一个独立的程序计数器。
+
+唯一不会OOM的内存区域。
+
+## 2 Java虚拟机栈（JVM Stack）
+
+![](/Users/sss/Library/Application Support/typora-user-images/image-20220118015846084.png)
+
+### 2.1 定义
+
+相比基于寄存器的运行环境，JVM是基于栈结构的运行环境。栈结构移植性更好，可控性更强。
+
+JVM的虚拟机栈是描述Java方法执行的内存区域，【线程私有】。
+
+栈中的元素用于支持虚拟机进行方法调用，每个方法从开始调用到执行完成的过程，就是栈帧从入栈到出栈过程。
+
+### 2.2 结构
+
+栈帧，方法运行的基本结构：
+
+- 在活动线程中，位于栈顶的帧才有效，即【当前栈帧】
+- 正在执行的方法称为【当前方法】
+
+在执行引擎运行时，所有指令都只能针对当前栈帧操作，StackOverflowError表示请求的栈溢出，导致内存耗尽，通常出现在递归方法。
+
+当前方法的栈帧，都是正在战斗的战场，其中的操作栈是参与战斗的士兵
+
+#### 2.3.0 操作栈的压栈与出栈
+
+![](https://p.ipic.vip/81iasd.png)
+
+虚拟机栈通过压/出栈，对每个方法对应的活动栈帧进行运算处理，方法正常执行结束，跳转到另一个栈帧上。
+
+执行过程中，若出现异常，会进行异常回溯，返回地址通过异常处理表确定。
+
+栈帧内部包括：
+
+#### 2.3.1 局部变量表
+
+存放方法参数和局部变量。
+
+相对于类属性变量的准备阶段和初始化阶段，局部变量没有准备阶段，须显式初始化。
+
+若是非静态方法，则在index[0]位置上存储的是方法所属对象的实例引用，随后存储的是参数和局部变量。
+
+字节码指令中的STORE指令就是将操作栈中计算完成的局部变量写回局部变量表的存储空间内。
+
+####  2.3.2 操作数栈
+
+一个初始状态为空的桶式结构栈。由于 Java 没有寄存器，所有参数传递使用操作数栈。在方法执行过程中，会有各种指令往栈中写入和提取信息。JVM的执行引擎是基于栈的执行引擎，其中的栈指的就是操作栈。
+
+字节码指令集的定义都是基于栈类型的，栈的深度在方法元信息的stack属性中。
+
+##### 操作栈与局部变量表交互
+
+```java
+public int simpleMethod() {
+    int x = 13;
+    int y = 14;
+    int z = x + y;
+    return z;
+}
+```
+
+详细的字节码操作顺序：
+
+```java
+public int simpleMethod();
+descriptor: ()I
+flags: ACC_PUBLIC
+Code:
+    stack=2, locals=4, args_size=1 // 最大栈深度为2，局部变量个数为4
+    0: bipush 13 // 常量13压入操作栈
+    2: istore_1 // 并保存到局部变量表的slot_1中（第1处）
+    3: bipush 14 // 常量14压入操作栈
+    5: istore_2 // 并保存到局部变量表的slot_2中
+    6: iload_1 // 把局部变量表的slot_1元素(int x)压入操作栈
+    7: iload_2 // 把局部变量表的slot_2元素(int y)压入操作栈
+    8: iadd // 把上方的两个数都取出来，在CPU里加一下，并压回操作栈的栈顶
+    9: istore_3 // 把栈顶的结果存储到局部变量表的slot_3中
+   10: iload_3 // 返回栈顶元素值
+   11: ireturn
+```
+
+局部变量表像中药柜，有很多抽屉，依次编号0、1、2、3、... n。
+
+字节码指令`istore_ 1`就是打开1号抽屉，把栈顶中的数13存进去。
+
+栈是一个很深的竖桶，只能对桶口元素进行操作，数据只能在栈顶执行存取。
+
+某些指令可直接在抽屉里进行，如`inc`指令，直接对抽屉里的数值进行+1。
+
+##### i++ V.S ++i
+
+可从字节码对比：
+
+| a=i++                                     | a=++i                                          |
+| ----------------------------------------- | ---------------------------------------------- |
+| 0: iload_1<br>1: iinc 1, 1<br>4: istore_2 | 0: iinc 1, 1<br>3: iload_1    <br> 4: istore_2 |
+
+- `iload_ 1` ，从局部变量表的1号抽屉取出一个数，压入栈顶，下一步直接在抽屉里实现+1，而这个操作对栈顶元素值无影响。所以istore_ 2只是把栈顶元素赋值给a
+
+- 表格右列，先在1号抽屉执行+1，再通过`iload_1`把1号抽屉的数压入栈顶，所以istore_2存入+1后的值
+
+i++并非原子操作，即使volatile修饰，多个线程同时写时，也会产生数据互相覆盖的问题。
+
+####  2.3.3 动态连接
+
+每个栈帧中包含一个在常量池中对当前方法的引用，目的是支持方法调用过程的动态连接。
+
+####  2.3.4 方法返回地址
+
+方法执行时有两种退出情况：
+
+- 正常退出
+  正常执行到任何方法的返回字节码指令，如RETURN、IRETURN、ARETURN等。
+- 异常退出
+
+无论何种，都将返回至方法当前被调用的位置。方法退出的过程相当于弹出当前栈帧。
+
+退出可能有三种方式:
+
+- 返回值压入，上层调用栈帧
+- 异常信息抛给能够处理的栈帧
+- PC计数器指向方法调用后的下一条指令
+
+Java虚拟机栈是描述Java方法运行过程的内存模型。Java虚拟机栈会为每一个即将运行的Java方法创建“栈帧”。用于存储该方法在运行过程中所需要的一些信息。
+
+- 局部变量表 
+  存放基本数据类型变量、引用类型的变量、returnAddress类型的变量
+- 操作数栈
+- 动态链接
+- 当前方法的常量池指针
+- 当前方法的返回地址
+- 方法出口等信息
+
+每一个方法从被调用到执行完成的过程,都对应着一个个栈帧在JVM栈中的入栈和出栈过程
+
+> 注意：人们常说，Java的内存空间分为“栈”和“堆”，栈中存放局部变量，堆中存放对象。 
+> 这句话不完全正确！这里的“堆”可以这么理解，但这里的“栈”就是现在讲的虚拟机栈,或者说Java虚拟机栈中的局部变量表部分.
+> 真正的Java虚拟机栈是由一个个栈帧组成，而每个栈帧中都拥有：局部变量表、操作数栈、动态链接、方法出口信息.
+
+### 特点
+
+局部变量表的创建是在方法被执行的时候，随栈帧创建而创建。
+表的大小在编译期就确定，在创建的时候只需分配事先规定好的大小即可。在方法运行过程中，表的大小不会改变。Java虚拟机栈会出现两种异常：
+
+- **StackOverFlowError**
+  若Java虚拟机栈的内存大小不允许动态扩展,那么当线程请求的栈深度大于虚拟机允许的最大深度时(但内存空间可能还有很多),就抛出此异常 
+  栈内存默认最大是1M,超出则抛出StackOverflowError
+
+- **OutOfMemoryError**
+  若Java虚拟机栈的内存大小允许动态扩展,且当线程请求栈时内存用完了,无法再动态扩展了,此时抛出OutOfMemoryError异常
+
+Java虚拟机栈也是线程私有的，每个线程都有各自的Java虚拟机栈，而且随着线程的创建而创建，随线程的死亡而死亡。
+
+## 3 本地方法栈
+
+Native Method Stack，类似虚拟机栈，虚拟机栈是为虚拟机执行JAVA方法而准备。虚拟机规范并未规定具体实现，不同虚拟机厂商自行实现。HotSpot虚拟机中虚拟机栈和本地方法栈的实现一样。
+
+本地方法栈和Java虚拟机栈实现的功能与抛出异常几乎相同，只是：
+
+- 虚拟机栈是为虚拟机执行Java方法(也就是字节码)服务
+- 本地方法栈则为虚拟机使用到的Native方法服务
+
+在JVM内存布局中，也是线程对象私有的，但是虚拟机栈“主内”，而本地方法栈“主外”。
+这个“内外”是针对JVM来说的，本地方法栈为Native方法服务线程开始调用本地方法时，会进入一个不再受JVM约束的世界。本地方法可以通过JNI(Java Native Interface)访问虚拟机运行时的数据区，甚至可以调用寄存器,具有和JVM相同的能力和权限。
+
+当大量本地方法出现时，势必会削弱JVM对系统的控制力，因为它的出错信息都比较黑盒。对于内存不足的情况，本地方法栈还是会拋出native heap OutOfMemory。
+
+最著名的本地方法应该是`System.currentTimeMillis()`，JNI 使Java深度使用OS的特性功能，复用非Java代码。但在项目过程中，如果大量使用其他语言来实现JNI,就会丧失跨平台特性，威胁到程序运行的稳定性。假如需要与本地代码交互，就可以用中间标准框架进行解耦，这样即使本地方法崩溃也不至于影响到JVM的稳定。当然，如果要求极高的执行效率、偏底层的跨进程操作等，可以考虑设计为JNI调用方式。
+
+## 4 Java堆（Heap）
+
+JVM启动时创建，存放所有的类实例及数组对象。
+除实例数据，还保存对象的其他信息，如Mark Word（存储对象哈希码，GC标志，GC年龄，同步锁等信息），Klass Pointy(指向存储类型元数据的指针）及一些字节对齐补白的填充数据（若实例数据刚好满足8字节对齐，则可不存在补白）。
+
+
+垃圾回收器主要就是管理堆内存。
+Heap是OOM主要发源地，它存储着几乎所有的实例对象，堆由垃圾收集器自动回收，由各子线程共享使用。通常它占用的空间是所有内存区域中最大的，但若无节制创建大量对象，也容易消耗完所有空间。
+
+堆的内存空间，既可以固定大小，也可运行时动态调整，通过如下参数设定初始值和最大值，比如
+
+```bash
+-Xms 256M
+-Xmx 1024M
+```
+
+其中-X表示它是JVM运行参数
+
+- ms是memorystart的简称，最小堆容量
+- mx是memory max的简称，最大堆容量
+
+通常情况下，服务器在运行过程中，堆空间不断地扩容与回缩，势必形成不必要系统压力，所以在线上生产环境中，JVM的Xms和Xmx设置成一样大小，避免在GC后调整堆大小时带来的额外压力。
+
+堆分成两大块：新生代和老年代
+对象产生之初在新生代，步入暮年时进入老年代，但是老年代也接纳在新生代无法容纳的超大对象。
+
+### 新生代
+
+1个Eden区+2个Survivor区。大部分对象在Eden区生成，当Eden区填满，触发Young GC（后文简称YGC）。GC时，Eden区实现清除策略，没被引用的对象直接回收。存活对象复制到Survivor区。
+
+Q：Survivor区分S0、S1，送到哪块呢？
+A：每次YGC时，将存活对象复制到未使用的那块空间，再将当前正在使用的空间完全清除，交换两块空间的使用状态。
+
+若：
+
+```java
+【YGC要移送的对象】 ＞ 【Survivor区容量上限】
+```
+
+则直接移交老年代。每个对象都有一个计数器，每次YGC都会加1。
+
+```bash
+-XX:MaxTenuringThreshold
+```
+
+参数能配置计数器的值到达某个阈值时，对象从新生代晋升至老年代。若该参数配置为1，则从新生代的Eden区直接移至老年代。
+
+默认值15：
+
+```c++
+gc_globals.hpp
+
+product(uintx, MaxTenuringThreshold, 15,
+        "Maximum value for tenuring threshold")
+        range(0, markOopDesc::max_age + 1)
+        constraint(MaxTenuringThresholdConstraintFunc, AfterErgo)
+```
+
+可在Survivor区交换14次后，晋升至老年代。
+
+### 对象分配与GC流程
+
+![](https://p.ipic.vip/5rahau.png)
+
+若`Survivor`区无法放下，或超大对象的阈值超过上限，则尝试在老年代中进行分配。
+若老年代也无法放下，则会触发Full Garbage Collection(Full GC)，若依然无法放下，则抛OOM。
+
+堆出现OOM的概率是所有内存耗尽异常中最高的，出错时的堆内信息对解决问题非常有帮助，所以给JVM设置运行参数
+
+```bash
+-XX:+HeapDumpOnOutOfMemoryError
+```
+
+让JVM遇到OOM异常时能输出堆内信息。
+
+>在不同的JVM实现及不同的回收机制中，堆内存的划分方式是不一样的。
+
+### 特点
+
+Java虚拟机所需要管理的内存中最大的一块. 
+
+堆内存物理上不一定要连续,只需要逻辑上连续即可,就像磁盘空间一样.
+堆是垃圾回收的主要区域,所以也被称为GC堆.
+
+堆的大小既可以固定也可以扩展,但主流的虚拟机堆的大小是可扩展的(通过-Xmx和-Xms控制),因此当线程请求分配内存,但堆已满,且内存已满无法再扩展时,就抛出OutOfMemoryError.
+
+线程共享 
+整个Java虚拟机只有一个堆,所有的线程都访问同一个堆.
+它是被所有线程共享的一块内存区域,在虚拟机启动时创建.
+而程序计数器、Java虚拟机栈、本地方法栈都是一个线程对应一个
+
+## 5 方法区
+
+### 5.1 定义
+
+Java虚拟机规范中定义方法区是堆的一个逻辑区划部分，具体实现根据不同虚拟机来实现。
+HotSpot在：
+
+- JDK7时，方法区放在永久代
+- JDK8时，方法区放在元空间，通过GC对该区域进行管理
+
+别名Non-Heap(非堆)，以与Java堆区分。
+
+方法区主要存放已经被虚拟机加载的类型的相关信息：                                                                                                                                                                                                                                                                                                                                                                                                                   
+
+- 类信息
+  类名、访问修饰符、字段描述、方法描述
+- 运行时常量池
+  常量存储在【运行时常量池】
+- 静态变量
+- 即时编译器JIT编译后的代码等数据
+
+### 5.2 特点
+
+- 线程共享 
+  方法区是堆的一个逻辑部分，因此和堆一样，线程共享。整个虚拟机只有一个方法区。
+- 永久代 
+  方法区中的信息一般需长期存在，且又是堆的逻辑分区，因此用堆的划分方法，把方法区称为永久代
+- 内存回收效率低 
+  Java虚拟机规范对方法区的要求比较宽松，可不实现GC。方法区中的信息一般需长期存在，回收一遍内存后，可能只有少量信息无效。对方法区的内存回收的主要目标是：
+  - 常量池的回收
+  - 类型的卸载
+
+和堆一样，允许固定大小，也可扩展大小，还允许不实现GC。 
+
+当方法区内存空间无法满足内存分配需求时,将抛出OutOfMemoryError异常。
+
+### 5.3  运行时常量池(Runtime Constant Pool)
+
+#### 5.3.1 定义
+
+方法区的一部分。
+`.java`文件被编译后生成的`.class`文件中除了包含：类的版本、字段、方法、接口等描述信息外，还有常量池。
+
+常量池用于存放编译时期产生的各种：
+
+- 字面量
+
+- 符号引用
+
+  用【字符串】符号的形式来表示引用，其实被引用的类、方法或变量还没有被加载到内存
+
+`.class`文件中的常量池中的所有的内容，在类被加载后，存放到方法区的运行时常量池中。 
+
+```java
+// age 是个变量，可被赋值
+// 21 是个字面值常量，不能被赋值
+int age = 21; 
+// pai 是个符号引用常量，一旦被赋值后，不能被修改
+int final pai = 3.14;
+```
+
+JDK6、7、8三个版本中， 运行时常量池的所处区域一直在不断变化：
+
+- 6时，是方法区的一部分
+- 7时，又放到堆内存
+- 8时，出现了元空间，又回到方法区
+
+这也说明官方对“永久代”的优化从7就已经开始。
+
+### 5.3.2 特性
+
+**运行时常量池**相比**class文件常量池**的另外一个特性是具备**动态性**，Java语言并不要求常量一定只有编译器才产生，即并非预置入class文件中常量池的内容才能进入方法区运行时常量池，运行期间也可能将新的常量放入池。
+
+String类的intern()方法就采用了运行时常量池的动态性。调用 intern 时，看池中是否已包含等于此 String 对象的字符串：
+
+- 是 
+  返回池中的字符串
+- 否
+  将此 String 对象添加到池中，并返回此 String 对象的引用
+
+### 5.3.3 可能抛出的异常 
+
+运行时常量池是方法区的一部分，所以会受到方法区内存的限制，因此当常量池无法再申请到内存时，就会抛OutOfMemoryError异常。
+
+一般在一个类中通过public static final声明一个常量。该类被编译后便生成Class文件，该类的所有信息都存储在这个class文件中。当这个类被JVM加载后，class文件中的常量就存放在方法区的运行时常量池。当运行时常量池中的某些常量没有被对象引用，同时也没有被变量引用，那么就需要垃圾收集器回收。 
+
+## 6 直接内存（Direct Memory）
+
+不是虚拟机运行时数据区的一部分，也不是JVM规范中定义的内存区域，但在JVM的实际运行过程中会频繁地使用这块区域，而且也会抛OOM。
+
+JDK 1.4引入NIO(New Input／Output)类，基于管道和缓冲区的I/O方式，可使用Native函数库直接分配堆外内存，然后通过一个存储在堆里的`DirectByteBuffer`对象作为这块内存的引用来操作堆外内存中的数据。
+这样能在一些场景中显著提升性能，因为避免了在Java堆和Native堆中来回复制数据。
+
+### 小结
+
+综上，程序计数器、Java虚拟机栈、本地方法栈都是线程私有，即每个线程都拥有各自程序计数器、Java虚拟机栈、本地方法区。且他们的生命周期和所属线程一样。
+
+而堆、方法区是线程共享，JVM只有一个堆、一个方法栈。并在JVM启动时就创建，JVM停止才销毁。
+
+## 7 元空间
+
+Metaspace，到JDK8，元空间前身Perm区（永久代）淘汰，≤JDK7时，仅Hotspot有Perm区，它在启动时固定大小，难调优，且Full GC时会移动类元信息。
+
+某些场景下，若动态加载的类过多，容易产生Perm区OOM。如某工程因为功能点较多，运行过程中，要不断动态加载很多类，经常出现：
+
+```bash
+Exception in thread ‘dubbo client x.x connector' 
+java.lang.OutOfMemoryError: PermGenspac
+```
+
+为解决该问题，需设定运行参数
+
+```bash
+-XX:MaxPermSize=1280m
+```
+
+若部署到新机器，往往因为JVM参数没有修改导致故障再现。不熟悉此应用的人排查问题时都苦不堪言。此外，永久代在GC过程中还存在诸多问题。
+
+所以，JDK8使用元空间替换永久代。不同于永久代，元空间在本地内存中分配。只要本地内存足够，就不会出现类似永久代的`java.lang.OutOfMemoryError: PermGen space`
+
+对永久代的设置参数 `PermSize` 和` MaxPermSize `也失效了。在JDK8及以上版本，设定`MaxPermSize`参数，JVM在启动时并不会报错，但提示:
+
+```bash
+Java HotSpot 64Bit Server VM warning:ignoring option MaxPermSize=2560m; support was removed in 8.0
+```
+
+默认情况下，“元空间”大小：
+
+- 可动态调整
+- 或使用新参数`MaxMetaspaceSize `限制本地内存分配给类元数据的大小
+
+在JDK8，Perm区所有内容中的：
+
+- 字符串常量，移至堆内存
+- 其他内容，包括类元信息、字段、静态属性、方法、常量等，移动至元空间
+
+```java
+Constant pool:
+    #1 = Methodref #6.#28 	// java/lang/Object."<init>":()V
+    #2 = Fieldref #29.#30 	// java/lang/System.out:Ljava/io/PrintStream;
+    #3 = String #31 				// hello Jdk11...
+    #4 = Methodref #32.#33 // java/io/PrintStream.println:(Ljava/lang/String;)V
+    #5 = Integer 10000000
+    #6 = Class #34 					// java/lang/Object
+```
+
+如上图的Object类元信息、静态属性System.out、整型常量1000000等，图中显示在常量池中的String，其实际对象保存在堆内存。
+
+### 特点
+
+- 充分利用Java语言规范：类及相关元数据的生命周期与类加载器一致
+- 每个类加载器都有其内存区域-元空间
+- 只进行线性分配
+- 不会单独回收某个类（除了重定义类 RedefineClasses 或类加载失败）
+- 无GC扫描或压缩
+- 元空间里的对象不会被转移
+- 若GC发现某个类加载器不再存活，会对整个元空间进行集体回收
+
+### GC
+
+- Full GC时，指向元数据指针都不用再扫描，减少Full GC时间
+- 很多复杂的元数据扫描的代码（尤其是CMS里面的那些）都删除了
+- 元空间只有少量指针指向Java堆
+  这包括：类的元数据中指向java.lang.Class实例的指针；数组类的元数据中，指向java.lang.Class集合的指针
+- 无元数据压缩的开销
+- 减少了GC Root的扫描（不在扫描虚拟机里面的已加载类的目录和其它的内部哈希表）
+- G1中，并发标记阶段完成后就可以进行类的卸载
+
+### 元空间内存分配模型
+
+*   绝大多数的类元数据的空间都在本地内存中分配
+*   用来描述类元数据的对象也被移除
+*   为元数据分配了多个映射的虚拟内存空间
+*   为每个类加载器分配一个内存块列表
+    *   块的大小取决于类加载器的类型
+    *   Java反射的字节码存取器（sun.reflect.DelegatingClassLoader ）占用内存更小
+*   空闲块内存返还给块内存列表
+*   当元空间为空，虚拟内存空间会被回收
+*   减少了内存碎片
+
+
+从线程共享角度来看
+
+- 堆和元空间，线程共享
+- 虚拟机栈、本地方法栈、程序计数器，线程私有
+
+从这角度看Java内存结构，Java 的线程与内存：
+
+![](https://p.ipic.vip/m2cqru.png)
+
+## 8 从GC角度看Java堆
+
+堆和方法区都是线程共享的区域，主要用来存放对象相关信息。一个接口中的多个实现类需要的内存可能不一样，一个方法中的多个分支需要的内存也可能不一样，程序运行期间才知道创建哪些对象，因此， 这部分的内存和回收都是动态的，垃圾收集器关注的就是这部分内存（本节后续所说的“内存”分配与回收也仅指这部分内存）。而在JDK1.7和1.8对这部分内存的分配也有所不同：
+
+Java8中堆内存分配：
+
+![](https://p.ipic.vip/ihxpvk.png)
+
+## 9 JVM关闭
+
+- 正常关闭：当最后一个非守护线程结束或调用了System.exit或通过其他特定于平台的方式,比如ctrl+c。
+- 强制关闭：调用Runtime.halt方法，或在操作系统中直接kill（发送single信号）掉JVM进程。
+- 异常关闭：运行中遇到RuntimeException 异常等
+
+在某些情况下，我们需要在JVM关闭时做一些扫尾的工作，比如删除临时文件、停止日志服务。为此JVM提供了关闭钩子（shutdown hocks）来做这些事件。 
+
+Runtime类封装java应用运行时的环境，每个java应用程序都有一个Runtime类实例，使用程序能与其运行环境相连。
+
+关闭钩子本质上是一个线程（也称为hock线程），可通过Runtime的addshutdownhock （Thread hock）向主jvm注册一个关闭钩子。hock线程在jvm正常关闭时执行，强制关闭不执行。 
+
+对于在JVM中注册的多个关闭钩子，他们会并发执行，JVM并不能保证他们的执行顺序。 
+
+参考：
+
+- 《码出高效》
\ No newline at end of file
diff --git a/docs/md/netty/java-lock-optimization-practice-netty-examples_boost-concurrency-performance.md b/docs/md/netty/java-lock-optimization-practice-netty-examples_boost-concurrency-performance.md
new file mode 100644
index 000000000..1bc769fcb
--- /dev/null
+++ b/docs/md/netty/java-lock-optimization-practice-netty-examples_boost-concurrency-performance.md
@@ -0,0 +1,124 @@
+# Java锁优化实战：从Netty案例学提升并发性能
+
+## 1 锁的对象和范围
+
+缩小粒度：
+
+```java
+public class ServerBootstrap extends AbstractBootstrap<ServerBootstrap, ServerChannel> {
+
+  	@Override
+    void init(Channel channel) {
+      	// 注意newOptionsArray
+        setChannelOptions(channel, newOptionsArray(), logger);
+        setAttributes(channel, newAttributesArray());
+```
+
+```java
+public abstract class AbstractBootstrap {
+
+    static Map.Entry<ChannelOption<?>, Object>[] newOptionsArray(Map<ChannelOption<?>, Object> options) {
+      // see!
+      synchronized (options) {
+          return new LinkedHashMap<ChannelOption<?>, Object>(options).entrySet().toArray(EMPTY_OPTION_ARRAY);
+      }
+  }
+```
+
+## 2 锁的对象本身大小
+
+减少空间占用：
+
+```java
+public final class ChannelOutboundBuffer {
+  
+  private static final AtomicLongFieldUpdater<ChannelOutboundBuffer> TOTAL_PENDING_SIZE_UPDATER =
+            AtomicLongFieldUpdater.newUpdater(ChannelOutboundBuffer.class, "totalPendingSize");
+```
+
+### 2.1 AtomicLong V.S long
+
+前者是对象，包含对象头（object header）以保存hashcode、lock等信息，64位系统下：
+
+- volatile long = 8bytes
+- AtomicLong = 8bytes（volatile long）+ 16bytes（对象头）+ 8 bytes（引用）= 32 bytes，至少节约24字节
+
+所以 Atomic* objects =》 Volatile primary type + Static Atomic*FieldUpdater
+
+## 3 锁的速度
+
+提高并发性。
+
+### 3.1 LongCounter
+
+记录内存分配字节数等功能用到的。
+高并发下: java.util.concurrent.atomic.AtomicLong => java.util.concurrent.atomic.LongAdder
+
+```java
+// 为当前平台创建新的最快的LongCounter实现
+public final class PlatformDependent {
+  
+  public static LongCounter newLongCounter() {
+      if (javaVersion() >= 8) {
+          return new LongAdderCounter();
+      } else {
+          return new AtomicLongCounter();
+      }
+  }
+```
+
+及时衡量、使用JDK最新功能。
+
+### 3.2 根据不同情况，选择不同的并发包实现
+
+JDK < 1.8考虑ConcurrentHashMapV8（ConcurrentHashMap在JDK8中的版本）：
+
+![](https://p.ipic.vip/besi8s.png)
+
+## 4 不同场景选择不同的并发类
+
+因需而变。关闭和等待关闭事件执行器( Event Executor)：
+Object.wait/ notify =》 CountDownLatch
+
+```java
+private final CountDownLatch threadLock = new CountDownLatch(1);
+```
+
+Nio Event loop中负责存储task的Queue，JDK's LinkedBlockingQueue (MPMC，多生产者多消费者) -> jctools' MPSC。io.netty.util.internal.PlatformDependent.Mpsc#newMpscQueue(int)：
+
+```java
+public final class PlatformDependent {
+  
+  static <T> Queue<T> newChunkedMpscQueue(final int chunkSize, final int capacity) {
+            return USE_MPSC_CHUNKED_ARRAY_QUEUE ? new MpscChunkedArrayQueue<T>(chunkSize, capacity)
+                    : new MpscChunkedAtomicArrayQueue<T>(chunkSize, capacity);
+        }
+```
+
+```java
+public class MpscUnboundedArrayQueue<E> extends BaseMpscLinkedArrayQueue<E>
+{
+  
+  	public MpscUnboundedArrayQueue(int chunkSize) {
+        super(chunkSize);
+    }
+```
+
+## 5 锁的价值
+
+能不用则不用。Netty应用场景下：
+
+```java
+局部串行+整体并行   > 一个队列+多个线程模式
+```
+
+- 降低用户开发难度、逻辑简单、提升处理性能
+- 避免锁带来的上下文切换和并发保护等额外开销
+
+避免用锁：ThreadLocal避免资源争用，如Netty轻量级的线程池实现
+
+```java
+public abstract class Recycler<T> {
+  
+  private final FastThreadLocal<Stack<T>> threadLocal = new FastThreadLocal<Stack<T>>() {
+```
\ No newline at end of file
diff --git a/docs/md/netty/use-netty-to-handle-large-data-efficiently.md b/docs/md/netty/use-netty-to-handle-large-data-efficiently.md
new file mode 100644
index 000000000..cae728db8
--- /dev/null
+++ b/docs/md/netty/use-netty-to-handle-large-data-efficiently.md
@@ -0,0 +1,277 @@
+# 11-5-"超越极限 - 如何使用 Netty 高效处理大型数据？" - 掌握 Netty 技巧，轻松应对海量数据处理！
+
+## 1 写大型数据
+
+因为网络饱和的可能性，如何在异步框架中高效地写大块的数据是特殊问题。由于写操作是非阻塞的，所以即使没有写出所有的数据，写操作也会在完成时返回并通知 ChannelFuture。当这种情况发生时，如果仍然不停地写入，就有内存耗尽的风险。所以在写大型数据时，需要准备好处理到远程节点的连接是慢速连接的情况，这种情况会导致内存释放的延迟。
+
+考虑下将一个文件内容写出到网络。讨论传输（见 4.2 节）的过程中，提到 NIO 的零拷贝，这消除了将文件内容从文件系统移动到网络栈的复制过程。所有的这一切都发生在 Netty 的核心中，所以应用程序所有需要做的就是使用FileRegion接口实现，其在 Netty 的 API 文档中的定义是： “通过支持零拷贝的文件传输的 Channel 来发送的文件区域。”
+
+如下展示如何通过从FileInputStream创建一个DefaultFileRegion，并将其写入Channel（甚至可利用 io.netty.channel.ChannelProgressivePromise实时获取传输的进度），利用零拷贝传输一个文件的内容。
+
+```java
+package io.netty.example.cp11;
+
+import io.netty.channel.*;
+import io.netty.channel.socket.nio.NioSocketChannel;
+
+import java.io.File;
+import java.io.FileInputStream;
+
+/**
+ * 使用 FileRegion 传输文件的内容
+ */
+public class FileRegionWriteHandler extends ChannelInboundHandlerAdapter {
+    private static final Channel CHANNEL_FROM_SOMEWHERE = new NioSocketChannel();
+    private static final File FILE_FROM_SOMEWHERE = new File("");
+
+    @Override
+    public void channelActive(final ChannelHandlerContext ctx) throws Exception {
+        File file = FILE_FROM_SOMEWHERE;
+        Channel channel = CHANNEL_FROM_SOMEWHERE;
+        //...
+        FileInputStream in = new FileInputStream(file);
+
+        // 以该文件的完整长度创建一个新的 DefaultFileRegion
+        FileRegion region = new DefaultFileRegion(in.getChannel(), 0, file.length());
+        // 发送该 DefaultFileRegion，并注册一个ChannelFutureListener
+        channel.writeAndFlush(region).addListener(
+                new ChannelFutureListener() {
+                    @Override
+                    public void operationComplete(ChannelFuture future) throws Exception {
+                        if (!future.isSuccess()) {
+                            // 处理失败
+                            Throwable cause = future.cause();
+                            // Do something
+                        }
+                    }
+                });
+    }
+}
+```
+
+该示例只适用于文件内容的直接传输，不包括应用程序对数据的任何处理。在需要将数据从文件系统复制到用户内存中时，可以使用 ChunkedWriteHandler，它支持异步写大型数据流，而又不会导致大量内存消耗。
+
+关键是 interface ChunkedInput<B>，类型参数 B 是 readChunk()方法返回的类型。Netty 预置该接口的 4 个实现，如下表ChunkedInput的实现：
+
+| 名称             | 描述                                                         |
+| ---------------- | ------------------------------------------------------------ |
+| ChunkedFile      | 从文件中逐块获取数据，当你的平台不支持零拷贝或者你需要转换数据时使用 |
+| ChunkedNioFile   | 和 ChunkedFile 类似，只是它使用了 FileChannel                |
+| ChunkedStream    | 从 InputStream 中逐块传输内容                                |
+| ChunkedNioStream | 从 ReadableByteChannel 中逐块传输内容                        |
+
+每个都代表了一个将由 ChunkedWriteHandler 处理的不定长度的数据流。
+
+代码清单 11-12 说明 ChunkedStream 用法，最常用的实现。所示类使用File及SslContext进行实例化。当initChannel()被调用，它将使用所示的 ChannelHandler 链初始化该 Channel。
+
+ChunkedInput的实现：
+
+| 名称             | 描述                                                         |
+| ---------------- | ------------------------------------------------------------ |
+| ChunkedFile      | 从文件中逐块获取数据，当你的平台不支持零拷贝或者你需要转换数据时使用 |
+| ChunkedNioFile   | 和 ChunkedFile 类似，只是它使用了 FileChannel                |
+| ChunkedStream    | 从 InputStream 中逐块传输内容                                |
+| ChunkedNioStream | 从 ReadableByteChannel 中逐块传输内容                        |
+
+当 Channel 的状态变为活动的时，WriteStreamHandler 将会逐块地把来自文件中的数据作为 ChunkedStream 写入。数据在传输之前将会由 SslHandler 加密。
+
+```java
+package io.netty.example.cp11;
+
+import io.netty.channel.*;
+import io.netty.handler.ssl.SslContext;
+import io.netty.handler.ssl.SslHandler;
+import io.netty.handler.stream.ChunkedStream;
+import io.netty.handler.stream.ChunkedWriteHandler;
+
+import java.io.File;
+import java.io.FileInputStream;
+
+/**
+ * 11.12 使用 ChunkedStream 传输文件内容
+ */
+public class ChunkedWriteHandlerInitializer extends ChannelInitializer<Channel> {
+
+    private final File file;
+
+    private final SslContext sslCtx;
+
+    public ChunkedWriteHandlerInitializer(File file, SslContext sslCtx) {
+        this.file = file;
+        this.sslCtx = sslCtx;
+    }
+
+    @Override
+    protected void initChannel(Channel ch) throws Exception {
+        ChannelPipeline pipeline = ch.pipeline();
+        // 将 SslHandler 添加到ChannelPipeline
+        pipeline.addLast(new SslHandler(sslCtx.newEngine(ch.alloc())));
+        // 添加 ChunkedWriteHandler以处理作为ChunkedInput传入的数据
+        pipeline.addLast(new ChunkedWriteHandler());
+        // 一旦连接建立，WriteStreamHandler就开始写文件数据
+        pipeline.addLast(new WriteStreamHandler());
+    }
+
+    public final class WriteStreamHandler extends ChannelInboundHandlerAdapter {
+
+        @Override
+        public void channelActive(ChannelHandlerContext ctx) throws Exception {
+            // 当连接建立时，channelActive()将使用ChunkedInput写文件数据
+            super.channelActive(ctx);
+            ctx.writeAndFlush(new ChunkedStream(new FileInputStream(file)));
+        }
+    }
+}
+```
+
+#### 逐块输入
+
+要使用你自己的 ChunkedInput 实现，请在 ChannelPipeline 中安装一个ChunkedWriteHandler。
+
+本节讨论如何通过使用零拷贝特性来高效地传输文件，以及如何通过使用ChunkedWriteHandler写大型数据而又不必冒OOM风险。下一节研究几种序列化 POJO 方法。
+
+## 2 序列化数据
+
+JDK提供ObjectOutputStream/ObjectInputStream，用于通过网络对POJO的基本数据类型和图进行序列化/反序列化。可被应用于任何实现java.io.Serializable接口的对象，但性能不是非常高效。那Netty必须为此提供啥呢？
+
+### 2.1 JDK序列化
+
+若应用须要和用了ObjectOutputStream、ObjectInputStream的远程节点交互，且兼容性也最关心，则JDK序列化是正确选择，下表列出Netty提供的用于和JDK进行互操作的序列化类：
+
+| 名称                    | 描述                                                         |
+| ----------------------- | ------------------------------------------------------------ |
+| CompatibleObjectDecoder | 和使用 JDK 序列化的非基于 Netty 的远程节点进行互操作的解码器 |
+| CompatibleObjectEncoder | 和使用 JDK 序列化的非基于 Netty 的远程节点进行互操作的编码器 |
+| ObjectDecoder           | 构建于 JDK 序列化之上的使用自定义的序列化来解码的解码器；当没有其他的外部依赖时，它提供了速度上的改进。否则其他的序列化实现更加可取 |
+| ObjectEncoder           | 构建于 JDK 序列化之上的使用自定义的序列化来编码的编码器；当没有其他的外部依赖时，它提供了速度上的改进。否则其他的序列化实现更加可取 |
+
+> CompatibleObjectDecoder类已在Netty 3.1废弃，并不存在于Netty 4.x：https://issues.jboss.org/browse/NETTY-136
+
+若能自由使用外部依赖，则JBoss Marshalling是理想选择：比JDK序列化最多快3倍，更紧凑。在[JBoss Marshalling官网](https://jbossmarshalling.jboss.org/)对其定义：JBoss Marshalling 是一种序列化 API，它修复 JDK 序列化 API 所发现的许多问题，同时保留与 java.io.Serializable 及其相关类兼容性，并添加几个新的可调优参数及额外特性，所有这些都能通过工厂配置（如外部序列化器、类/实例查找表、类解析以及对象替换等）实现可插拔。
+
+### 2.2 使用 JBoss Marshalling 进行序列化
+
+Netty 通过下表所示的两组解码器/编码器对为 Boss Marshalling 提供支持：
+
+- 第一组兼容只使用 JDK 序列化的远程节点
+- 第二组提供最大性能，适用于和使用 JBoss Marshalling 的远程节点一起使用
+
+JBoss Marshalling编解码器：
+
+| 名称                                                         | 描述                                                  |
+| ------------------------------------------------------------ | ----------------------------------------------------- |
+| CompatibleMarshallingDecoder<br>CompatibleMarshallingEncoder | 与只使用JDK序列化的远程节点兼容                       |
+| MarshallingDecoder<br/>MarshallingEncoder                    | 适用于使用JBoss Marshalling的节点。这些类必须一起使用 |
+
+#### 使用 MarshallingDecoder/MarshallingEncoder
+
+几乎仅配置ChannelPipeline：
+
+```java
+package io.netty.example.cp11;
+
+import io.netty.channel.*;
+import io.netty.handler.codec.marshalling.MarshallerProvider;
+import io.netty.handler.codec.marshalling.MarshallingDecoder;
+import io.netty.handler.codec.marshalling.MarshallingEncoder;
+import io.netty.handler.codec.marshalling.UnmarshallerProvider;
+
+import java.io.Serializable;
+
+/**
+ * 使用 JBoss Marshalling
+ */
+public class MarshallingInitializer extends ChannelInitializer<Channel> {
+    private final MarshallerProvider marshallerProvider;
+    private final UnmarshallerProvider unmarshallerProvider;
+
+    public MarshallingInitializer(UnmarshallerProvider unmarshallerProvider, MarshallerProvider marshallerProvider) {
+        this.marshallerProvider = marshallerProvider;
+        this.unmarshallerProvider = unmarshallerProvider;
+    }
+
+    @Override
+    protected void initChannel(Channel channel) throws Exception {
+        ChannelPipeline pipeline = channel.pipeline();
+        // 添加 MarshallingDecoder 以 将 ByteBuf 转换为 POJO
+        pipeline.addLast(new MarshallingDecoder(unmarshallerProvider));
+        // 添加 MarshallingEncoder 以将POJO 转换为 ByteBuf
+        pipeline.addLast(new MarshallingEncoder(marshallerProvider));
+        pipeline.addLast(new ObjectHandler());
+    }
+
+    // 添加 ObjectHandler，以处理普通的实现了Serializable 接口的 POJO
+    public static final class ObjectHandler extends SimpleChannelInboundHandler<Serializable> {
+
+        @Override
+        public void channelRead0(ChannelHandlerContext channelHandlerContext, Serializable serializable) throws Exception {
+            // Do something
+        }
+    }
+}
+```
+
+### 2.3 通过 Protocol Buffers 序列化
+
+Netty序列化的最后一个解决方案是利用Protocol Buffers（https://protobuf.dev/）的编解码器，由Google开发、现已开源的数据交换格式。可在https://github.com/google/protobuf找到源代码。Protocol Buffers 以紧凑高效方式对结构化的数据进行编解码。它具有许多的编程语言绑定，使得它很适合跨语言项目。表 11-10 展示Netty为支持 protobuf 所提供ChannelHandler 实现。
+
+Protobuf编解码器：
+
+| 名称                                 | 描述                                                         |
+| ------------------------------------ | ------------------------------------------------------------ |
+| ProtobufDecoder                      | 使用 protobuf 解码消息                                       |
+| ProtobufEncoder                      | 使用 protobuf 编码消息                                       |
+| ProtobufVarint32FrameDecoder         | 根据消息中的 Google Protocol Buffers 的“Base 128 Varints”整数长度字段值动态地分割所接收到的 ByteBuf |
+| ProtobufVarint32LengthFieldPrepender | 向 ByteBuf 前追加一个 Google Protocol Buffers 的“Base 128 Varints”整型的长度字段值 |
+
+使用 protobuf 只不过是将正确的 ChannelHandler 添加到 ChannelPipeline 中：
+
+```java
+package io.netty.example.cp11;
+
+import com.google.protobuf.MessageLite;
+import io.netty.channel.*;
+import io.netty.handler.codec.protobuf.ProtobufDecoder;
+import io.netty.handler.codec.protobuf.ProtobufEncoder;
+import io.netty.handler.codec.protobuf.ProtobufVarint32FrameDecoder;
+
+public class ProtoBufInitializer extends ChannelInitializer<Channel> {
+    private final MessageLite lite;
+
+    public ProtoBufInitializer(MessageLite lite) {
+        this.lite = lite;
+    }
+
+    @Override
+    protected void initChannel(Channel ch) throws Exception {
+        ChannelPipeline pipeline = ch.pipeline();
+        // 添加 ProtobufVarint32FrameDecoder 以分隔帧
+        pipeline.addLast(new ProtobufVarint32FrameDecoder());
+        // 还需要在当前的 ProtobufEncoder 之前添加一个相应的 ProtobufVarint32LengthFieldPrepender 以编码进帧长度信息
+        // 添加 ProtobufEncoder以处理消息的编码
+        pipeline.addLast(new ProtobufEncoder());
+        // 添加 ProtobufDecoder以解码消息
+        pipeline.addLast(new ProtobufDecoder(lite));
+        // 加 ObjectHandler 以处理解码消息
+        pipeline.addLast(new ObjectHandler());
+    }
+
+    public static final class ObjectHandler extends SimpleChannelInboundHandler<Object> {
+
+        @Override
+        public void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
+            // Do something with the object
+        }
+    }
+}
+```
+
+这节探讨由 Netty 专门的解码器和编码器所支持的不同的序列化选项：标准JDK序列化、JBoss Marshalling 及 Google 的 Protocol Buffers。
+
+## 3 总结
+
+Netty 提供的编解码器以及各种 ChannelHandler 可以被组合和扩展，以实现非常广泛的处理方案。此外，它们也是被论证的、健壮的组件，已经被许多的大型系统所使用。
+
+我们只涵盖最常见示例；Netty 的 API 文档提供了更加全面的覆盖。
+
+后文学习另一种先进协议——WebSocket，被开发用以改进 Web 应用程序的性能以及响应性。Netty 提供你将会需要的工具，以便你快速、轻松地利用它强大的功能。
\ No newline at end of file
diff --git a/docs/md/opensearch/opensearch-3-0-enhances-vector-database-performance.md b/docs/md/opensearch/opensearch-3-0-enhances-vector-database-performance.md
new file mode 100644
index 000000000..0cbca4575
--- /dev/null
+++ b/docs/md/opensearch/opensearch-3-0-enhances-vector-database-performance.md
@@ -0,0 +1,47 @@
+# OpenSearch 3.0 提升向量数据库性能、搜索基础设施与可扩展性，以满足 AI 时代的需求
+
+## 0 前言
+
+OpenSearch 软件基金会，致力于搜索、分析、可观测性和向量数据库软件的发展。由 Linux 基金会托管，得到 AWS、SAP 和 Uber 等核心成员的支持，携手社区维护者、开发者及会员组织，共同推动 OpenSearch 项目的持续发展。
+
+最新版进一步加强开放、可扩展、社区驱动的搜索与分析平台，助力可持续创新。就在上个月OpenSearch 3.0 正式发布。相比 OpenSearch 1.3 性能提升高达 9.5 倍，而此前的[基准测试数据](https://hubs.la/Q03ldJkL0)显示，早期版本的 OpenSearch 比业内最接近的竞争产品快 1.6 倍。
+
+如今的 AI 应用——如生成式 AI、混合搜索、RAG和推荐引擎——都高度依赖向量数据库来在庞大复杂的数据集中寻找模式。然而，随着向量数量激增至数十亿，许多组织在速度、成本和扩展性方面面临挑战。[Forrester](https://www.forrester.com/report/the-forrester-wave-tm-vector-databases-q3-2024/RES181372) 强调，传统数据库已无法满足生成式 AI 的增长需求，因为它们在支持现代向量多维数据和执行相似度搜索方面存在局限。
+
+OpenSearch 3.0 正是为了解决这一挑战，通过新增的数据管理、AI 代理和向量搜索功能，帮助用户提升效率、实现更优性能并加快 AI 应用的开发。同时，引入如 GPU 加速等功能，还能将成本降低达 3.75 倍。
+
+“随着 AI 的快速发展，企业搜索市场正迅速增长，预计到 2030 年将达到 89 亿美元，”OpenSearch 软件基金会理事会主席、亚马逊云科技（AWS）产品管理总监 Carl Meadows 表示。“OpenSearch 3.0 是我们为社区提供一个开放、可扩展平台的重要一步，旨在推动搜索与分析的未来发展。这也体现了我们对开放协作与创新的承诺，推动实际影响。”
+
+## 向量引擎创新：提升处理速度与效率
+
+为支撑其大规模搜索平台和海量向量数据管理，OpenSearch 引入了基于 GPU 的加速，利用 [NVIDIA cuVS](https://hubs.la/Q03ldJnV0) 提高索引效率。全新[向量引擎](https://hubs.la/Q03ldxF_0)功能包括：
+
+- **GPU 加速向量引擎：** 为大规模向量工作负载提供更优性能，同时显著降低运营成本，缩短索引构建时间。该实验性功能通过部署 GPU，可将索引构建速度提升至原来的 9.3 倍，加速数据密集型任务。
+- **模型上下文协议（MCP）支持：** 原生支持 MCP 协议，使 AI 代理能更便捷地与 OpenSearch 交互，实现更全面、可定制的 AI 解决方案。
+- **派生数据源：** 通过去除冗余的向量数据源、仅利用主数据在需要时重建源文档，用于重新索引或调用原始数据，从而降低三分之一的存储消耗。
+
+## 数据管理新特性：优化资源、增强灵活性、推动可扩展性
+
+OpenSearch 3.0 在数据的摄取、传输与管理方面取得重大进展，包括：
+
+- **支持 gRPC 协议：** 实验性功能，为 OpenSearch 部署带来更快速、高效的数据传输与处理。实现客户端、服务端及节点间更高效的通信机制。
+- **基于拉取的数据摄取方式：** 实验性功能，通过将数据源与数据消费者解耦，增强数据摄取效率，让 OpenSearch 对数据流的获取拥有更多控制权。支持从 Apache Kafka、Amazon Kinesis 等流处理系统中拉取数据。
+- **读写分离：** 通过将索引和搜索工作负载分别配置，确保两者在高效状态下独立运行，避免彼此影响，提升整体系统性能。
+- **集成 Apache Calcite：** 将查询构建器集成进 OpenSearch SQL 和 PPL，简化安全、可观测性与日志分析的使用场景，支持更直观、迭代式的查询构建。
+- **索引类型检测：** 可自动识别索引是否包含日志相关数据，加快日志分析功能的应用配置，提高生产力。
+
+## 核心升级
+
+让 OpenSearch 的搜索与分析平台更具前瞻性。
+
+平台在搜索基础设施方面的优化——如移除旧代码、采用模块化架构、对齐最新 Java 标准——进一步增强了维护性、性能潜力与效率。关键更新包括：
+
+- **升级至 Lucene 10：** 现代化搜索基础设施，提升索引与搜索能力，提高并行任务执行性能，为长期创新打下基础。
+- **最低支持 Java 21 运行时：** 利用现代语言特性与性能改进。
+- **支持 Java 平台模块系统：** 改善组织结构，移除顶级包冲突，为将单体服务器模块重构为可拆分库奠定基础。
+
+------
+
+## 总结
+
+OpenSearch 3.0 现已正式发布。请查看官方[发布博客](https://hubs.la/Q03ldJsC0)获取更多信息，以及[完整发布说明](https://github.com/opensearch-project/opensearch-build/blob/main/release-notes/opensearch-release-notes-3.0.0.md)。
\ No newline at end of file
diff --git "a/docs/md/reactive/\345\223\215\345\272\224\345\274\217\347\274\226\347\250\213\347\232\204\351\200\202\347\224\250\345\234\272\346\231\257.md" b/docs/md/reactive/applicable-scenarios-for-reactive-programming.md
similarity index 54%
rename from "docs/md/reactive/\345\223\215\345\272\224\345\274\217\347\274\226\347\250\213\347\232\204\351\200\202\347\224\250\345\234\272\346\231\257.md"
rename to docs/md/reactive/applicable-scenarios-for-reactive-programming.md
index 7dbe90230..458612eb3 100644
--- "a/docs/md/reactive/\345\223\215\345\272\224\345\274\217\347\274\226\347\250\213\347\232\204\351\200\202\347\224\250\345\234\272\346\231\257.md"
+++ b/docs/md/reactive/applicable-scenarios-for-reactive-programming.md
@@ -2,30 +2,30 @@
 
 ## 0 前提
 
-已掌握响应式编程核心概念：响应式流、背压及响应式流规范。
+响应式流、背压及响应式流规范。
 
 ## 1 引言
 
-- 响应式编程能应用到哪些具体场景?
-- 目前有啥框架用到这新技术体系?
+- 响应式编程能应用到啥场景?
+- 目前有啥框架用到这技术体系?
 
-## 2 响应式编程的应用场景分析
+## 2 响应式编程应用场景
 
-可认为响应式编程不仅是一种编程技术，更是一种架构设计的系统方法，因此可应用于任何地方：
+响应式编程不仅是编程技术，更是一种架构设计的系统方法，可应用于任何地方：
 
-- 既可用于简单的 Web 应用系统
-- 也可用于大型企业解决方案
+- 简单的 Web 应用系统
+- 大型企业解决方案
 
-数据流处理是响应式编程的一大应用场景，流式系统主要特点：
+数据流处理是响应式编程一大应用场景，流式系统特点：
 
 - 低延迟
 - 高吞吐量
 
-通过使用非阻塞式通信，可确保资源得到高效利用，实现低延迟和高吞吐量。
+用非阻塞式通信，可确保资源高效利用，实现低延迟、高吞吐量。
 
-高并发流量通常涉及大量 IO 操作，相比传统同步阻塞式 IO 模型，响应式编程所具备的异步非阻塞式IO模型很适合应对处理高并发流量的业务场景。
+高并发通常涉及大量 IO 操作，相比传统同步阻塞式 IO 模型，响应式编程的异步非阻塞式IO模型适合应对。
 
-网关的作用：响应来自前端系统的流量，并将其转发到后端服务。
+网关：响应来自前端系统的流量，并将其转发到后端服务。
 
 ### 核心诉求
 
@@ -35,37 +35,60 @@
 
 ## 3 响应式流规范
 
-### 3.1 Netflix Hystrix 中的滑动窗口
+### 3.1 Hystrix滑动窗口
 
 Spring Cloud Netflix Hystrix 基于 Netflix Hystrix 实现服务熔断功能。Netflix Hystrix，Netflix 开源的一款容错库，使用HystrixCircuitBreaker类实现熔断器。
 
-#### HystrixCircuitBreaker咋动态获取系统运行时的各项数据？
+#### 咋动态获取系统运行时的各项数据？
 
-HealthCountsStream采用滑动窗口 (Rolling Window) 机制，大量采用数据流处理方面技术及 RxJava 响应式编程框架。Hystrix 以秒为单位统计系统中所有请求的处理情况，然后每次取最近 10s 数据计算，如失败率超过一定阈值，就熔断。
+HealthCountsStream采用滑动窗口，大量采用数据流处理方面技术及 RxJava 响应式编程框架。Hystrix 以s为单位统计系统中所有请求的处理情况，再每次取最近 10s 数据计算，如失败率超过阈值，熔断。
 
-#### 咋实现这滑动窗口？
+#### 实现
 
-把系统运行时所产生的所有数据都视为一个个的事件，这样滑动窗口中每个桶的数据都来自源源不断的事件，通常需要对其进行转换以便进行后续的操作。
+把系统运行时产生数据视为一个个事件，滑动窗口中每个桶的数据都来自事件，通常需对其转换以便后续操作。
 
-Hystrix 采用基于响应式编程思想的 RxJava。使用 RxJava 的一大好处，可通过 RxJava 的一系列操作符来实现滑动窗口：
+Hystrix采用RxJava，用其一系列操作符实现滑动窗口：
 
 - window 操作符，把当前流中的元素收集到另外的流序列
 - flatMap 操作符，把流中的每个元素转换成一个流，再把转换之后得到的所有流中的元素进行合并
 - reduce 操作符，对流中包含的所有元素进行累积操作，得到一个包含计算结果的流
 
-![](https://img-blog.csdnimg.cn/36dd9a8c14704de58b5d16f43769698f.png)
+```java
+this.bucketedStream = Observable.defer(new Func0<Observable<Bucket>>() {
+
+    @Override
+    public Observable<Bucket> call() {
+        return inputEventStream
+            .observe()
+            // 使用 window 操作符收集一个 Bucket 时间内的数据
+            .window(bucketSizeInMs, TimeUnit.MILLISECONDS)
+            // 将每个 window 内聚集起来的事件集合汇总成 Bucket
+            .flatMap(reduceBucketToSummary)
+            .startWith(emptyEventCountsToStart);
+    }
+});
+```
 
-![](https://img-blog.csdnimg.cn/d44f7a36d6674dd2a565a8c602d3fab8.png)
+```java
+this.sourceStream = bucketedStream
+    // 将 N 个 Bucket 进行汇总
+    .window(numBuckets, 1)
+    // 汇总成一个窗口
+    .flatMap(reduceWindowToSummary)
+    ...
+    // 添加背压控制
+    .onBackpressureDrop();
+```
 
-Hystrix 巧妙运用 RxJava 的 window、flatMap等操作符来将单位窗口时间内的事件。以及将一个窗口大小内的 Bucket 聚集到一起形成滑动窗口，并基于滑动窗口集成指标数据。
+Hystrix 用 RxJava 的 window、flatMap等操作符来将单位窗口时间内的事件。以及将一个窗口大小内的 Bucket 聚集到一起形成滑动窗口，并基于滑动窗口集成指标数据。
 
-### 3.2 Spring Cloud Gateway 中的过滤器
+### 3.2 Spring Cloud Gateway中的过滤器
 
-Spring 官方自己开发的一款 API 网关，基于最新的Spring5和Spring Boot2以及用于响应式编程的Proiect Reactor框架提供的是响应式、非阻塞式I/0 模型。
+Spring开发的API网关，基于Spring5和Spring Boot2和Proiect Reactor框架提供响应式、非阻塞式I/O模型：
 
-![](https://img-blog.csdnimg.cn/74c2aef3fa26416180377239bc39fb59.png)
+![](https://p.ipic.vip/cgphl2.png)
 
-只需实现*GlobalFilter*接口，重写 filter()即可。
+只需实现GlobalFilter接口，重写 filter()：
 
 ```java
 public class IPLimitFilter implements GlobalFilter
@@ -73,30 +96,30 @@ public class IPLimitFilter implements GlobalFilter
     @Override
     public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
 
-        // 1. 获取当前的请求路径
+        // 1 获取当前请求路径
         String url = exchange.getRequest().getURI().getPath();
 
-        // 2. 获得所有的需要进行ip限流校验的url list
+        // 2 获得所有需ip限流校验的url list
         List<String> ipLimitList = excludeUrlProperties.getIpLimitUrls();
 
-        // 3. 校验并且判断
+        // 3 校验并判断
         if (ipLimitList != null && !ipLimitList.isEmpty()) {
             for (String limitUrl : ipLimitList) {
                 if (antPathMatcher.matchStart(limitUrl, url)) {
-                    // 如果匹配到，则表明需要进行ip的拦截校验
+                    // 若匹配到，则表明需进行ip拦截校验
                     log.info("IPLimitFilter - 拦截到需要进行ip限流校验的方法：URL = " + url);
                     return doLimit(exchange, chain);
                 }
             }
         }
 
-        // 4. 默认直接放行
+        // 4 默认放行
         return chain.filter(exchange);
     }
 }
 ```
 
-filter()返回了一个 Mono 对象，它就是在响应式编程框架 Project Reactor 中代表**单个返回值的流式对象**。
+filter()返回的Mono对象，是响应式编程框架 Project Reactor 中代表**单个返回值的流式对象**。
 
 #### 案例
 
@@ -129,25 +152,33 @@ public class PreGatewayFilterFactory extends AbstractGatewayFilterFactory<PreGat
 
 ### 3.3 Spring Webflux 中的请求处理流程
 
-Spring 5 中引入的全新的响应式 Web 服务开发框架。
-
-针对涉及大量I/O 操作的服务化架构，WebFlux也是一种非常有效的解决方案。
+Spring 5 中引入的全新的响应式 Web 服务开发框架。针对涉及大量I/O 操作的服务化架构，WebFlux也是解决方案。
 
-#### 工作流程图
+#### 工作流程
 
-
-
-![](https://img-blog.csdnimg.cn/ec9b9b6147db4626be38f21fc56aa5bd.png)
+![](https://p.ipic.vip/3v94dk.png)
 
 #### 示例
 
-![](https://img-blog.csdnimg.cn/2f138646effd42d39367778265da8566.png)
-
-![](https://img-blog.csdnimg.cn/29467a6ffae544c3ada947880e9ba57d.png)
-
+```java
+public Mono<Void> handle(ServerWebExchange exchange) {
+    if (this.handlerMappings == null) {
+        return createNotFoundError();
+    }
 
+    return Flux.fromIterable(this.handlerMappings)
+            .concatMap(mapping -> mapping.getHandler(exchange))
+            .next()
+            // 如果没有找到 HandlerMapping，则抛出异常
+            .switchIfEmpty(createNotFoundError())
+            // 触发 HandlerAdapter 的 handle 方法
+            .flatMap(handler -> invokeHandler(exchange, handler))
+            // 触发HandlerResultHandler的handleResult方法
+            .flatMap(result -> handleResult(exchange, result));
+}
+```
 
-## 总结
+## 4 总结
 
 通过理论联系实际，讨论了响应式编程的具体应用场景。
 
diff --git a/docs/md/reactive/spring-5-reactive-programming-high-performance-full-stack-apps.md b/docs/md/reactive/spring-5-reactive-programming-high-performance-full-stack-apps.md
new file mode 100644
index 000000000..e75836401
--- /dev/null
+++ b/docs/md/reactive/spring-5-reactive-programming-high-performance-full-stack-apps.md
@@ -0,0 +1,113 @@
+# 03-Spring 5 响应式编程：构建高性能全栈应用的关键
+
+## 1 引言
+
+Spring支持响应式编程，梳理 Spring 框架中的响应式编程技术栈，并引出贯穿整个教程的案例系统。
+
+## 2 Spring5响应式编程技术栈
+
+17年 Spring 发布 Spring 5，引入很多核心功能，重要的就是全面拥抱了响应式编程的设计思想和实践。Spring5响应式编程模型以 Proiect Reactor 库为基础，而后者实现响应式流规范。
+
+响应式编程并非只针对系统中的某部分组件，而是需要适用于调用链路上的所有组件。只要有一个环节非响应式，这环节就会出现同步阻塞，即全栈式响应式编程。
+
+Spring 5也针对响应式编程，构建了全栈式的开发组件，提供：
+
+- 针对 Web 服务层开发的响应式 Web 框架 WebFlux
+- 支持响应式数据访问的 Spring Data Reactive 框架
+
+## 3 Spring WebFlux
+
+WebFlux 框架名称中的 Flux 源 Project Reactor 框架中的 Flux 组件。WebFlux 不仅包含：
+
+- 对创建和访问响应式HTTP 端点的支持
+- 还可用来实现SSE、WebSocket
+
+![](https://p.ipic.vip/rtccyj.png)
+
+### 3.1 架构图
+
+webflux架构图：
+
+![](https://docs.spring.io/spring-framework/docs/5.0.0.M5/spring-framework-reference/html/images/webflux-overview.png)
+
+### 3.2 实现原理
+
+传统的 Spring MVC 构建在 Java EE 的Servlet 标准之上，该标准本身就是阻塞和同步的。
+
+最新版Servlet在等待请求过程中，仍在线程池中保持着线程。Spring WebFlux则是构建在响应式流及它的实现框架 Reactor 基础上的一个开发框架，因此能基于 HTTP 协议用来构建异步非阻塞的 Web 服务。
+
+- Spring MVC 是运行在传统的 Servlet 容器之上
+- 而 Spring WebFlux 则需要支持异步的运行环境，如Netty、Undertow以及 Servlet 3.1 版本以上的 Tomcat和Jetty
+
+WebFlux 提供异步非阻塞的 I/0 特性，适合开发I/O密集型服务。
+
+不推荐 WebFlux、Spring MVC 混用，因为显然无法保证全栈式响应式流。
+
+## 4 Spring Data Reactive
+
+Spring Data 是 Spring 家族中专门针对数据访问而开发的一个框架，针对各种数据存储媒介抽象了一批 Repository 接口，以简化开发过程。
+
+Spring Boot2架构图：
+
+![](https://p.ipic.vip/2iwtt4.png)
+
+## 5 案例ReactiveSpringCSS
+
+CSS，客户服务系统 Customer Service System，构建一个精简但又完整的系统来展示 Spring 5 中响应式编程相关的设计理念和各项技术组件。
+
+案例系统的目的在于演示技术实现过程，不在于介绍具体业务逻辑所以我们对案例的业务流程做了高度的简化。
+
+ReactiveSpringCSS 中，存在一个 customer-service这是一个 Spring Boot 应用程序，也是整个案例系统中的主体服务。
+
+![](https://p.ipic.vip/dt21ok.png)
+
+### Web 层
+
+使用 Spring WebFlux 组件来分别为系统中的三个服务构建响应式 RESTful 端点，并通过支持响应式请求的 Webclient 客户端组件来消费这些端点。
+
+### Service层
+
+完成事件处理和消息通信相关的业务场景。
+
+- account-service 消息的发布者
+- customer-service 消费者
+
+Spring5也针对Spring Cloud Stream做响应式升级并提供对应的响应式编程组件。
+
+### Repository层
+
+引入 MongoDB、Redis 两款支持响应式流的 NOSQL：
+
+- MongoDB为各个服务存储业务数据
+- Redis主要用在 customer-service
+
+分别引入 Spring 5中的 Spring Data MongoDB Reactive和 Spring Data Redis Reactive 进行整合。
+
+![](https://p.ipic.vip/jne2k2.png)
+
+## 总结
+
+本教程是一款以案例驱动的响应式应用程序开发的教程。
+今天我们就针对Spring5中所提供的响应式编程组件进行了展开，并引出了贯穿整课程体系的ReactiveSpringCSS案例系统。
+
+## FAQ
+
+Spring WebFlux V.S Spring MVC
+
+两种不同 Web 框架：
+
+1. 编程模型：Spring WebFlux 基于响应式编程模型，使用 Reactor 库来处理异步和非阻塞的 I/O 操作，而 Spring MVC 则是基于传统的 Servlet API，使用阻塞式 I/O 操作。
+
+2. 线程模型：Spring WebFlux 使用少量的线程来处理大量的并发请求，通过 Reactor 库提供的事件循环机制来实现非阻塞式 I/O 操作。而 Spring MVC 则是使用线程池来处理请求，并且每个请求都会占用一个线程。
+
+3. 响应式支持：Spring WebFlux 支持响应式编程，可以使用 Mono 和 Flux 类型来处理异步操作和流式数据。而 Spring MVC 则不支持响应式编程。
+
+4. 异常处理：Spring WebFlux异常处理机制不同于Spring MVC，它用函数式编程模型处理异常。WebFlux异常处理器是函数，接收一个 ServerRequest 对象和一个 Throwable 对象，并返回一个`Mono<ServerResponse>`对象。而Spring MVC异常处理器是一个类，需实现HandlerExceptionResolver接口
+
+5. 安全性：由于 Spring WebFlux 使用少量的线程来处理大量的并发请求，因此它可以更好地保护系统免受拒绝服务攻击。而 Spring MVC 则需要使用线程池来处理请求，容易受到拒绝服务攻击的影响。
+
+总之，Spring WebFlux 和 Spring MVC 都是很好的 Web 框架，选择哪个取决于具体的应用场景和需求。如果需要处理大量的并发请求，并希望使用响应式编程模型来实现非阻塞式 I/O 操作，那么可以选择 Spring WebFlux；如果应用程序需要使用传统的 Servlet API，并且不需要响应式支持，那么可以选择 Spring MVC。
+
+参考：
+
+- https://docs.spring.io/spring-framework/docs/5.0.0.M5/spring-framework-reference/html/web-reactive.html
\ No newline at end of file
diff --git a/docs/md/redis/redis-agpl-license.md b/docs/md/redis/redis-agpl-license.md
new file mode 100644
index 000000000..7a6921b9c
--- /dev/null
+++ b/docs/md/redis/redis-agpl-license.md
@@ -0,0 +1,27 @@
+# Redis重回开源：回归AGPL，不觉得晚了吗？
+
+[Redis 8 已于近日正式发布](https://redis.io/blog/redis-8-ga/)，并采用 AGPLv3 开源许可证。一年前，为了对抗云服务商，Redis 放弃了开源路线并引发了 Valkey 项目的诞生。如今，Redis 重新聘请了其创始人，并再次转向开源。
+
+Redis 最初是以较为宽松的 BSD 许可证发布的，但在 2024 年 3 月，项目转向更具限制性的、且不被视为开源的 SSPLv1 许可证，这一变化引发了社区的不安，也促成了 Valkey 的成功分支。而仅仅一年后，Redis 的发展方向再次发生重大转变，Redis 8.0 现在又成为开源软件，这次是采用 OSI 认可的 AGPLv3 许可证。
+
+根据 Redis 官方公告，这一重大版本带来了多个性能提升，包括命令执行速度最高提升 87%、每秒操作吞吐量提升最多 2 倍，以及复制速度提升最多 18%。此外，还推出了新的测试功能 Vector Sets，InfoQ 上对此也有单独报道。Redis 的创始人 [Salvatore Sanfilippo](https://www.linkedin.com/in/salvatore-sanfilippo-b52b47249/)（网名 antirez）[解释说](https://antirez.com/news/151)：
+
+> 五个月前，我重新加入了 Redis，很快就和同事们开始讨论是否切换到 AGPL 许可证，结果发现其实早就有相关讨论了，而且是很早以前就开始的讨论。(...) 写开源软件已经深深地刻在我的职业生涯中：我几乎没写过非开源的软件。现在开始改变也太晚了。
+
+一年前，Redis 转向更严格的许可证后，出现了多个分支，其中最成功的就是得到了 CNCF 支持的 Valkey，许多云服务提供商（包括 AWS 和 Google Cloud）立即表示支持。AWS 推出了专门针对 Valkey 的 ElastiCache 和 MemoryDB 服务，价格比原本基于 Redis 的版本要低不少。
+
+虽然目前 [Valkey 在真实使用场景下的性能优于 Redis 8.0](https://www.gomomento.com/blog/valkey-turns-one-how-the-community-fork-left-redis-in-the-dust/)，但 Momento 的 CEO 兼联合创始人 [Khawaja Shams](https://www.linkedin.com/in/kshams/) 仍然欢迎 Sanfilippo 回归，并写道：
+
+> 我真的很高兴他回来了，这已经带来了实质性影响。他确实履行了承诺，为 Redis 带来了新功能和性能优化。更重要的是，Redis 8.0 再次成为开源项目。
+
+尽管许多人认为使用 Valkey 的开发者[不会轻易回到 Redis](https://www.linkedin.com/posts/peterzaitsev_activity-7324943971397378048-p2GI?utm_source=share&utm_medium=member_desktop&rcm=ACoAABaQ5R4B1z_TPIVzQKBvbJ9SpDn29zaiJcY)，他们也承认 Valkey 面临的竞争会更加激烈。Percona 创始人、开源倡导者 Peter Zaitsev [指出](https://www.linkedin.com/posts/peterzaitsev_release-800-redisredis-activity-7324199641200140288-Ab47) Redis 的一个重要优势：
+
+> 尽管大家都在讨论 Redis 回归开源、采用 AGPLv3 的消息，但很多人可能忽略了，现在的 Redis 已不再是几年前那个基于 BSD 的 Redis 了 —— 现在包括 RedisJSON 在内的多个扩展模块（自 2018 年以来并非开源）如今都已被整合进 Redis，并统一采用 AGPLv3。这可能是对 Valkey 的直接回应，毕竟 Valkey 只继承了“核心”Redis BSD 代码，缺少这些功能。
+
+在文章《[Redis 现在以 AGPLv3 开源许可证发布](https://redis.io/blog/agplv3/)》中确认，除了新数据类型 Vector Sets 外，Redis 8 还将 Redis Stack 中的多个技术集成到核心代码中，包括 JSON、时间序列、概率数据类型和查询引擎，这些都已统一采用 AGPL 许可证。
+
+此次重大版本更新和许可证变更也在 [Reddit](https://www.reddit.com/r/linux/comments/1kcdc2j/redis_is_open_source_again/) 上引发了热议，不少开发者认为这步棋下得太晚，是过去错误决策的结果。有些开发者认为 Redis 最大的资产仍然是它的创始人，而 AboutCode 的维护者 Philippe Ombredanne 则[更为悲观](https://www.linkedin.com/posts/philippeombredanne_redis-license-is-bsd-and-will-remain-bsd-activity-7323828480847081472-D_th?utm_source=share&utm_medium=member_desktop&rcm=ACoAABaQ5R4B1z_TPIVzQKBvbJ9SpDn29zaiJcY)地看待这一转变：
+
+> 用户一眼就能看穿这些操作。对 Redis 来说，它失去的用户基础恐怕已经无法挽回，而信任的破裂也是永久性的。
+
+Redis 并不是第一个因 SSPLv1 引发分支、社区流失和信任危机后又改回 AGPL 的项目。一年前，[Elastic 的创始人兼 CEO Shay Banon](https://www.linkedin.com/in/kimchy)也为 Elasticsearch 和 Kibana 做出了类似决定。
\ No newline at end of file
diff --git a/docs/md/rules-engine/drools/drools-core-guide-configuration-to-drl-and-decision-tables.md b/docs/md/rules-engine/drools/drools-core-guide-configuration-to-drl-and-decision-tables.md
new file mode 100644
index 000000000..f539e6494
--- /dev/null
+++ b/docs/md/rules-engine/drools/drools-core-guide-configuration-to-drl-and-decision-tables.md
@@ -0,0 +1,241 @@
+# Drools 核心指南：从配置到 DRL 与决策表实战
+
+## 1 概述
+
+[Drools](https://www.drools.org/)，一种商业规则管理系统 (BRMS) 解决方案。提供一个规则引擎，该引擎处理事实并产生输出，作为规则和事实处理的结果。业务逻辑集中化，使变更快且成本低。
+
+提供一种易于理解的格式，来编写规则，弥合业务和技术团队之间差距。
+
+## 2 POM依赖
+
+添加依赖：
+
+```xml
+<dependency>
+    <groupId>org.kie</groupId>
+    <artifactId>kie-ci</artifactId>
+    <version>8.32.0.Final</version>
+</dependency>
+
+<dependency>
+    <groupId>org.drools</groupId>
+    <artifactId>drools-decisiontables</artifactId>
+    <version>8.32.0.Final</version>
+</dependency>
+```
+
+最新版：
+
+- [kie-ci](https://mvnrepository.com/artifact/org.kie/kie-ci) 
+- [drools-decisiontables](https://mvnrepository.com/artifact/org.drools/drools-decisiontables)
+
+## 3 基本概念
+
+- Facts – 规则输入的数据
+- 工作内存 – 存储带有 *Facts* 的地方，在那里它们被用于模式匹配，可以被修改、插入和移除
+- Rule – 代表一个将 *Facts* 与匹配动作关联的单一规则。它可以用 Drools 规则语言编写在 *.drl* 文件中，或者作为 *决策表* 写在 Excel 电子表格中
+- 知识会话 – 它持有触发规则所需的所有资源；所有 *Facts* 都被插入会话中，然后触发匹配的规则
+- 知识库 – 代表 Drools 生态系统中的知识，它有关于 *Rules* 所在资源的信息，同时它也创建知识会话
+- 模块 – 一个模块持有多个可容纳不同会话的知识库
+
+## 4 Java配置
+
+为了在给定数据上触发规则，需用规则文件和 *Facts* 的位置信息实例化框架提供的类：
+
+### 4.1 KieServices
+
+一个线程安全的单例，作为一个中心枢纽，可访问Kie提供的其他服务。一般规则：
+
+- getX()只返回另一个单例的引用
+- newX()则创建一个新实例。 可通过其工厂获取KieServices引用：
+
+KieServices类提供对所有 Kie 构建和运行时的访问。提供几个工厂、服务和实用方法。
+
+#### 先得到一个KieServices实例
+
+```java
+KieServices kieServices = KieServices.Factory.get();
+```
+
+使用KieServices，将创建 *KieFileSystem*、*KieBuilder* 和 *KieContainer* 的新实例。
+
+### 4.2 KieFileSystem
+
+一个内存中的文件系统，负责读取和写入规则文件。
+
+编程式定义 Drools 资源（如规则文件和决策表）的容器：
+
+```java
+private KieFileSystem getKieFileSystem() {
+    KieFileSystem kieFileSystem = kieServices.newKieFileSystem();
+    List<String> rules = Arrays.asList("com/javaedge/drools/rules/order-rules.drl", "com/javaedge/drools/rules/SuggestApplicant.drl", "com/javaedge/drools/rules/Product_rules.drl.xls");
+    for (String rule : rules) {
+        kieFileSystem.write(ResourceFactory.newClassPathResource(rule));
+    }
+    return kieFileSystem;
+}
+```
+
+从classpath读取文件。
+
+### 4.3 KieBuilder
+
+将 KieFileSystem 传递给 KieBuilder 并用 *kb.buildAll()* 构建所有定义的规则来构建 KieFileSystem 的内容。
+
+编译了规则并检查它们的语法错误：
+
+```java
+KieBuilder kieBuilder = kieServices.newKieBuilder(kieFileSystem);
+kieBuilder.buildAll();
+```
+
+### 4.4 KieRepository
+
+框架自动将构建结果的 *KieModule* 添加到 *KieRepository* 中：
+
+```java
+KieRepository kieRepository = kieServices.getRepository();Copy
+```
+
+### 4.5 KieContainer
+
+包含规则的运行时环境，可以从中获取 KieSession。
+
+现在可用其 *ReleaseId* 创建一个带有此 *KieModule* 的新 *KieContainer*。在这种情况下，Kie 会分配一个默认的 *ReleaseId*：
+
+```java
+ReleaseId krDefaultReleaseId = kieRepository.getDefaultReleaseId();
+KieContainer kieContainer 
+  = kieServices.newKieContainer(krDefaultReleaseId);Copy
+```
+
+### 4.6 KieSession
+
+规则执行的上下文，用于触发规则评估和执行。
+
+现可从 *KieContainer* 获取 *KieSession*。我们的应用程序与 *KieSession* 交互，它存储并执行运行时数据：
+
+```java
+KieSession kieSession = kieContainer.newKieSession();
+```
+
+### 完整配置
+
+```java
+public KieSession getKieSession() {
+    KieBuilder kb = kieServices.newKieBuilder(getKieFileSystem());
+    kb.buildAll();
+
+    KieRepository kieRepository = kieServices.getRepository();
+    ReleaseId krDefaultReleaseId = kieRepository.getDefaultReleaseId();
+    KieContainer kieContainer = kieServices.newKieContainer(krDefaultReleaseId);
+
+    return kieContainer.newKieSession();
+}
+```
+
+## 5 实现规则
+
+已完成设置，来看创建规则的几个选项。
+
+通过分类申请人是否适合特定角色为例来探讨规则的实施，这是基于他当前的薪水和他拥有的工作经验年数。
+
+#### 5.1 Drools 规则文件 (*.drl)
+
+简而言之，Drools 规则文件包含所有的业务规则。
+
+**一个规则包括一个 \*当-则\* 结构**，这里 *当* 部分列出要检查的条件，*则* 部分列出如果条件满足要采取的动作：
+
+```java
+package com.javaedge.drools.rules;
+
+import com.javaedge.drools.model.Applicant;
+
+global com.javaedge.drools.model.SuggestedRole suggestedRole;
+
+dialect  "mvel"
+
+rule "Suggest Manager Role"
+    when
+        Applicant(experienceInYears > 10)
+        Applicant(currentSalary > 1000000 && currentSalary <= 
+         2500000)
+    then
+        suggestedRole.setRole("Manager");
+end
+```
+
+这条规则可以通过在 *KieSession* 中插入 *Applicant* 和 *SuggestedRole* 事实来触发：
+
+```java
+public SuggestedRole suggestARoleForApplicant(
+    Applicant applicant,SuggestedRole suggestedRole){
+    KieSession kieSession = kieContainer.newKieSession();
+    kieSession.insert(applicant);
+    kieSession.setGlobal("suggestedRole",suggestedRole);
+    kieSession.fireAllRules();
+    // ...
+}
+```
+
+它测试 *Applicant* 实例上的两个条件，然后基于两个条件的满足，它在 *SuggestedRole* 对象中设置 *Role* 字段。
+
+可以通过执行测试来验证这一点：
+
+```java
+@Test
+public void whenCriteriaMatching_ThenSuggestManagerRole(){
+    Applicant applicant = new Applicant("David", 37, 1600000.0,11);
+    SuggestedRole suggestedRole = new SuggestedRole();
+        
+    applicantService.suggestARoleForApplicant(applicant, suggestedRole);
+ 
+    assertEquals("Manager", suggestedRole.getRole());
+}Copy
+```
+
+在这个例子中，我们使用了一些 Drools 提供的关键字。让我们了解它们的用法：
+
+- ***package –\*** 这是我们在 *kmodule.xml* 中指定的包名，规则文件位于这个包内
+- ***import*** – 这类似于 Java 的 *import* 声明，在这里我们需要指定我们正在插入 *KnowledgeSession* 中的类
+- ***global –*** 这用于为会话定义全局级别变量；可以用来传递输入参数或获取输出参数以总结会话的信息
+- ***dialect*** – 方言指定了在条件部分或动作部分的表达式中使用的语法。默认的方言是 Java。Drools 还支持方言 *mvel*；它是一种基于 Java 应用程序的表达式语言。它支持字段和方法/获取器访问
+- ***rule*** – 这定义了一个带有规则名称的规则块
+- ***when*** – 这指定了一个规则条件，在这个例子中检查的条件是 *Applicant* 有超过十年的 *experienceInYears* 和一定范围的 *currentSalary*
+- ***then –*** 这个块在满足*when*块中的条件时执行操作。在这个例子中，*Applicant*角色被设定为经理
+
+### **5.2. 决策表**
+
+决策表提供了在预格式化的Excel电子表格中定义规则的能力。Drools提供的决策表的优势在于，即使对非技术人员来说也很容易理解。
+
+当存在类似规则但具有不同值时，这种表格非常有用，这样可以更容易地在Excel表格中添加新行，而不是在*drl*文件中编写新规则。让我们看一下一个决策表的结构，以及基于产品类型对产品应用标签的示例：
+
+![](https://p.ipic.vip/sr57dq.png)
+
+决策表分为不同的部分，顶部部分类似于头部部分，在这里我们指定*RuleSet*（规则文件所在的包），*Import*（要导入的Java类）和*Notes*（关于规则目的的注释）。
+
+**我们定义规则的中心部分称为\*RuleTable\*，它将适用于同一领域对象的规则分组在一起。**
+
+在下一行中，我们有列类型*CONDITION*和*ACTION*。在这些列内，我们可以访问一行中提到的领域对象的属性及其在后续行中的值。
+
+触发规则的机制类似于我们在*.drl*文件中看到的。
+
+我们可以通过执行以下测试来验证应用这些规则的结果：
+
+```java
+@Test
+public void whenProductTypeElectronic_ThenLabelBarcode() {
+    Product product = new Product("Microwave", "Electronic");
+    product = productService.applyLabelToProduct(product);
+    
+    assertEquals("BarCode", product.getLabel());
+}
+```
+
+## 6 结论
+
+在这篇简短的文章中，我们探讨了如何在应用程序中使用Drools作为业务规则引擎。我们还看到了在Drools规则语言中以及在易于理解的电子表格中编写规则的多种方式。
+
+参考：
+
+- https://blog.csdn.net/weixin_42176639/article/details/134959946
\ No newline at end of file
diff --git a/docs/md/sentinel/basic-api-resource-rule.md b/docs/md/sentinel/basic-api-resource-rule.md
new file mode 100644
index 000000000..c6c320bfd
--- /dev/null
+++ b/docs/md/sentinel/basic-api-resource-rule.md
@@ -0,0 +1,431 @@
+# 基本使用 - 资源与规则
+
+## 0 前言
+
+Sentinel分为：
+
+- Sentinel 核心库
+
+- Dashboard
+
+核心库不依赖 Dashboard，但结合可取得最好效果。
+
+### 资源
+
+可为任何东西：服务，方法，甚至一段代码。使用 Sentinel 来进行资源保护的步骤:
+
+1. 定义资源
+2. 定义规则
+3. 检验规则是否生效
+
+有了资源，就可随时灵活定义各种流量控制规则。编码时，只需考虑这代码是否需保护，需，就定义为一个资源。
+
+对主流框架提供适配，只需按适配中的说明配置，Sentinel 就默认定义提供的服务，方法等为资源。
+
+## 1 定义资源
+
+### 1.1 方式一：主流框架适配
+
+主流框架如Dubbo、Spring Cloud、gRPC、Spring WebFlux、Reactor都适配。
+
+### 1.2 方式二：抛异常定义资源
+
+`SphU` 包含 try-catch 风格 API。当资源发生限流后抛 `BlockException`。可捕捉，进行限流后处理:
+
+```java
+// 1.5.0 版开始可try-with-resources
+// 资源名可使用任意有业务语义的字符串，如方法名、接口名或其它可唯一标识的字符串。
+try (Entry entry = SphU.entry("resourceName")) {
+  // 被保护的业务逻辑
+} catch (BlockException ex) {
+  // 资源访问阻止，被限流或被降级
+  // 在此处进行相应处理
+}
+```
+
+若 entry 的时候传入了热点参数，则exit时也要带上对应参数（`exit(count, args)`），否则可能会有统计错误。这时不能用 try-with-resources。另外通过 `Tracer.trace(ex)` 来统计异常信息时，由于 try-with-resources 语法中 catch 调用顺序的问题，会导致无法正确统计异常数，因此统计异常信息时也不能在 try-with-resources 的 catch 块中调用 `Tracer.trace(ex)`。
+
+**注意：** `SphU.entry(xxx)` 需要与 `entry.exit()` 方法成对出现，匹配调用，否则会导致调用链记录异常，抛出 `ErrorEntryFreeException` 异常。
+
+### 1.3 方式三：返回布尔值定义资源
+
+`SphO` 提供 if-else 风格 API。当资源发生了限流之后会返回 `false`，这个时候可以根据返回值，进行限流之后的逻辑处理。示例代码如下:
+
+```java
+  // 资源名可使用任意有业务语义的字符串
+  if (SphO.entry("自定义资源名")) {
+    // 务必保证finally会被执行
+    try {
+      /**
+      * 被保护的业务逻辑
+      */
+    } finally {
+      SphO.exit();
+    }
+  } else {
+    // 资源访问阻止，被限流或被降级
+    // 进行相应的处理操作
+  }
+```
+
+### 1.4 方式四：注解定义资源
+
+通过 `@SentinelResource` 定义资源，并配置 `blockHandler` 和 `fallback` 函数来进行限流后处理：
+
+```java
+// 原业务方法.
+@SentinelResource(value = "pilot_list", 
+                 blockHandler = "blockHandler")
+@GetMapping("/getList")
+public ResultBody list() {
+    Map<String, List<Pilot>> pilotServiceList = pilotService.getList();
+    return ResultBody.success(pilotServiceList);
+}
+
+// 原方法调用被限流/降级/系统保护的时候调用
+public ResultBody blockHandler(BlockException e) {
+    log.warn("触发限流", e);
+    return ResultBody.error("服务繁忙，请稍后再试");
+}
+```
+
+注意 `blockHandler` 函数会在原方法被限流/降级/系统保护的时候调用，而 `fallback` 函数会针对所有类型的异常。
+
+### 1.5 方式五：异步调用支持
+
+Sentinel 支持异步调用链路的统计。在异步调用中，需要通过 `SphU.asyncEntry(xxx)` 方法定义资源，并通常需要在异步的回调函数中调用 `exit` 方法。
+
+示例：
+
+```java
+try {
+    AsyncEntry entry = SphU.asyncEntry(resourceName);
+
+    // 异步调用.
+    doAsync(userId, result -> {
+        try {
+            // 在此处处理异步调用的结果.
+        } finally {
+            // 在回调结束后 exit.
+            entry.exit();
+        }
+    });
+} catch (BlockException ex) {
+    // Request blocked.
+    // Handle the exception (e.g. retry or fallback).
+}
+```
+
+`SphU.asyncEntry(xxx)` 不会影响当前（调用线程）的 Context，因此以下两个 entry 在调用链上是平级关系（处于同一层），而不是嵌套关系：
+
+```java
+// 调用链类似于：
+// -parent
+// ---asyncResource
+// ---syncResource
+asyncEntry = SphU.asyncEntry(asyncResource);
+entry = SphU.entry(normalResource);
+```
+
+若在异步回调中需要嵌套其它的资源调用（无论是 `entry` 还是 `asyncEntry`），只需要借助 Sentinel 提供的上下文切换功能，在对应的地方通过 `ContextUtil.runOnContext(context, f)` 进行 Context 变换，将对应资源调用处的 Context 切换为生成的异步 Context，即可维持正确的调用链路关系。示例如下：
+
+```java
+public void handleResult(String result) {
+    Entry entry = null;
+    try {
+        entry = SphU.entry("handleResultForAsync");
+        // Handle your result here.
+    } catch (BlockException ex) {
+        // Blocked for the result handler.
+    } finally {
+        if (entry != null) {
+            entry.exit();
+        }
+    }
+}
+
+public void someAsync() {
+    try {
+        AsyncEntry entry = SphU.asyncEntry(resourceName);
+
+        // Asynchronous invocation.
+        doAsync(userId, result -> {
+            // 在异步回调中进行上下文变换，通过 AsyncEntry 的 getAsyncContext 方法获取异步 Context
+            ContextUtil.runOnContext(entry.getAsyncContext(), () -> {
+                try {
+                    // 此处嵌套正常的资源调用.
+                    handleResult(result);
+                } finally {
+                    entry.exit();
+                }
+            });
+        });
+    } catch (BlockException ex) {
+        // Request blocked.
+        // Handle the exception (e.g. retry or fallback).
+    }
+}
+```
+
+此时的调用链就类似于：
+
+```
+-parent
+---asyncInvocation
+-----handleResultForAsync
+```
+
+更详细的示例可以参考 Demo 中的 [AsyncEntryDemo](https://github.com/alibaba/Sentinel/blob/master/sentinel-demo/sentinel-demo-basic/src/main/java/com/alibaba/csp/sentinel/demo/AsyncEntryDemo.java)，里面包含了普通资源与异步资源之间的各种嵌套示例。
+
+## 2 规则的种类
+
+Sentinel 所有规则都可在内存态中动态地查询及修改，修改之后立即生效。同时 Sentinel 也提供相关 API，供您来定制自己的规则策略。
+
+### 2.1 流控规则（FlowRule）
+
+#### 重要属性
+
+|      Field      | 说明                                                         | 默认值                    |
+| :-------------: | :----------------------------------------------------------- | :------------------------ |
+|    resource     | 资源名，资源名是限流规则的作用对象                           |                           |
+|      count      | 限流阈值                                                     |                           |
+|      grade      | 限流阈值类型，QPS 或线程数模式                               | QPS 模式                  |
+|    limitApp     | 流控针对的调用来源                                           | `default`：不区分调用来源 |
+|    strategy     | 调用关系限流策略：直接、链路、关联                           | 根据资源本身（直接）      |
+| controlBehavior | 流控效果（直接拒绝 / 排队等待 / 慢启动模式），不支持按调用关系限流 | 直接拒绝                  |
+
+同一个资源可同时有多个限流规则。
+
+#### Web设置
+
+![](https://p.ipic.vip/hfw18y.png)
+
+#### 代码定义
+
+调用 `FlowRuleManager.loadRules()` 硬编码定义流量控制规则：
+
+```java
+private static void initFlowQpsRule() {
+    List<FlowRule> rules = new ArrayList<>();
+    FlowRule rule1 = new FlowRule();
+    rule1.setResource(resource);
+    // Set max qps to 20
+    rule1.setCount(20);
+    rule1.setGrade(RuleConstant.FLOW_GRADE_QPS);
+    rule1.setLimitApp("default");
+    rules.add(rule1);
+    FlowRuleManager.loadRules(rules);
+}
+```
+
+更多详细内容可以参考 [流量控制](https://sentinelguard.io/zh-cn/docs/flow-control.html)。
+
+### 2.2 熔断降级规则（DegradeRule）
+
+#### 属性
+
+|       Field        | 说明                                                         | 默认值     |
+| :----------------: | :----------------------------------------------------------- | :--------- |
+|      resource      | 资源名，即规则的作用对象                                     |            |
+|       grade        | 熔断策略，支持慢调用比例/异常比例/异常数策略                 | 慢调用比例 |
+|       count        | 慢调用比例模式下为慢调用临界 RT（超出该值计为慢调用）；异常比例/异常数模式下为对应的阈值 |            |
+|     timeWindow     | 熔断时长，单位为 s                                           |            |
+|  minRequestAmount  | 熔断触发的最小请求数，请求数小于该值时即使异常比率超出阈值也不会熔断（1.7.0 引入） | 5          |
+|   statIntervalMs   | 统计时长（单位为 ms），如 60*1000 代表分钟级（1.8.0 引入）   | 1000 ms    |
+| slowRatioThreshold | 慢调用比例阈值，仅慢调用比例模式有效（1.8.0 引入）           |            |
+
+同一个资源可同时有多个降级规则。
+
+#### Web 设置
+
+
+
+![](https://p.ipic.vip/z30ehi.png)
+
+ `DegradeRuleManager.loadRules()` 硬编码定义流量控制规则。
+
+```java
+private static void initDegradeRule() {
+    List<DegradeRule> rules = new ArrayList<>();
+    DegradeRule rule = new DegradeRule(resource);
+        .setGrade(CircuitBreakerStrategy.ERROR_RATIO.getType());
+        .setCount(0.7); // Threshold is 70% error ratio
+        .setMinRequestAmount(100)
+        .setStatIntervalMs(30000) // 30s
+        .setTimeWindow(10);
+    rules.add(rule);
+    DegradeRuleManager.loadRules(rules);
+}
+```
+
+### 2.3 系统保护规则
+
+SystemRule，Sentinel 系统自适应限流从整体维度对应用入口流量进行控制，结合应用的 Load、CPU 使用率、总体平均 RT、入口 QPS 和并发线程数等几个维度的监控指标，通过自适应的流控策略，让系统的入口流量和系统的负载达到一个平衡，让系统尽可能跑在最大吞吐量的同时保证系统整体的稳定性。
+
+#### 属性
+
+|       Field       | 说明                                   | 默认值      |
+| :---------------: | :------------------------------------- | :---------- |
+| highestSystemLoad | `load1` 触发值，用于触发自适应控制阶段 | -1 (不生效) |
+|       avgRt       | 所有入口流量的平均响应时间             | -1 (不生效) |
+|     maxThread     | 入口流量的最大并发数                   | -1 (不生效) |
+|        qps        | 所有入口资源的 QPS                     | -1 (不生效) |
+|  highestCpuUsage  | 当前系统的 CPU 使用率（0.0-1.0）       | -1 (不生效) |
+
+#### 硬编码
+
+ `SystemRuleManager.loadRules()` 定义流量控制规则：
+
+```java
+private void initSystemProtectionRule() {
+  List<SystemRule> rules = new ArrayList<>();
+  SystemRule rule = new SystemRule();
+  rule.setHighestSystemLoad(10);
+  rules.add(rule);
+  SystemRuleManager.loadRules(rules);
+}
+```
+
+### 2.4 访问控制规则
+
+AuthorityRule，当需根据调用方来限制资源是否通过，可用Sentinel访问控制（黑白名单）功能。根据资源的请求来源（origin）判断，若：
+
+- 配置白名单，仅origin在白名单才可通过
+- 若配置黑名单，仅origin在黑名单时不通过，其余请求通过
+
+授权规则，即黑白名单规则（AuthorityRule），对其
+
+#### 配置项
+
+- `resource`：资源名，即限流规则的作用对象
+- `limitApp`：对应的黑名单/白名单，不同 origin 用 `,` 分隔，如 `appA,appB`
+- `strategy`：限制模式，`AUTHORITY_WHITE` 为白名单模式，`AUTHORITY_BLACK` 为黑名单模式，默认为白名单模式
+
+更多详情可以参考 [来源访问控制](http://www.javaedge.cn/md/sentinel/origin-authority-control.html)。
+
+### 2.5 热点规则
+
+ParamFlowRule，详情参考 [热点参数限流](https://sentinelguard.io/zh-cn/docs/parameter-flow-control.html)。
+
+## 查询更改规则
+
+引入transport模块后，可以通过以下的 HTTP API 来获取所有已加载的规则：
+
+```
+http://localhost:8719/getRules?type=<XXXX>
+```
+
+type取值：
+
+- flow：JSON格式返回现有的限流规则
+- degrade：返回现有生效的降级规则列表
+- system 则返回系统保护规则
+
+获取所有热点规则：
+
+```
+http://localhost:8719/getParamRules
+```
+
+其中，type 可以输入 `flow`、`degrade` 等方式来制定更改的规则种类，`data` 则是对应的 JSON 格式的规则。
+
+## 定制持久化规则
+
+上面的规则配置，都在内存。即如果应用重启，这个规则就会失效。因此我们提供了开放的接口，您可以通过实现 [`DataSource`](https://github.com/alibaba/Sentinel/blob/master/sentinel-extension/sentinel-datasource-extension/src/main/java/com/alibaba/csp/sentinel/datasource/AbstractDataSource.java) 接口的方式，来自定义规则的存储数据源。通常我们的建议有：
+
+- 整合动态配置系统，如zk、Nacos，动态实时刷新配置规则
+- 结合 RDBMS、NoSQL、VCS 实现该规则
+- 配合 Sentinel Dashboard 使用
+
+更多详情请参考 [动态规则配置](https://sentinelguard.io/zh-cn/docs/dynamic-rule-configuration.html)。
+
+## 规则生效的效果
+
+### 判断限流降级异常
+
+通过以下方法判断是否为 Sentinel 的流控降级异常：
+
+```java
+BlockException.isBlockException(Throwable t);
+```
+
+除了在业务代码逻辑上看到规则生效，我们也可以通过下面简单的方法，来校验规则生效的效果：
+
+- **暴露的 HTTP 接口**：通过运行下面命令 `curl http://localhost:8719/cnode?id=<资源名称>`，观察返回的数据。如果规则生效，在返回的数据栏中的 `block` 以及 `block(m)` 中会有显示
+- **日志**：Sentinel 提供秒级的资源运行日志以及限流日志，详情可以参考 [日志文档](https://sentinelguard.io/zh-cn/docs/logs.html)
+
+### block 事件
+
+Sentinel 提供以下扩展接口，可以通过 `StatisticSlotCallbackRegistry` 向 `StatisticSlot` 注册回调函数：
+
+- `ProcessorSlotEntryCallback`: callback when resource entry passed (`onPass`) or blocked (`onBlocked`)
+- `ProcessorSlotExitCallback`: callback when resource entry successfully completed (`onExit`)
+
+可以利用这些回调接口来实现报警等功能，实时的监控信息可以从 `ClusterNode` 中实时获取。
+
+## 其它 API
+
+### 业务异常统计 Tracer
+
+业务异常记录类 `Tracer` 用于记录业务异常。相关方法：
+
+- `trace(Throwable e)`：记录业务异常（非 `BlockException` 异常），对应的资源为当前线程 context 下 entry 对应的资源。
+- `trace(Throwable e, int count)`：记录业务异常（非 `BlockException` 异常），异常数目为传入的 `count`。
+- `traceEntry(Throwable, int, Entry)`：向传入 entry 对应的资源记录业务异常（非 `BlockException` 异常），异常数目为传入的 `count`。
+
+如果用户通过 `SphU` 或 `SphO` 手动定义资源，则 Sentinel 不能感知上层业务的异常，需要手动调用 `Tracer.trace(ex)` 来记录业务异常，否则对应的异常不会统计到 Sentinel 异常计数中。注意不要在 try-with-resources 形式的 `SphU.entry(xxx)` 中使用，否则会统计不上。
+
+从 1.3.1 版本开始，注解方式定义资源支持自动统计业务异常，无需手动调用 `Tracer.trace(ex)` 来记录业务异常。Sentinel 1.3.1 以前的版本需要手动记录。
+
+### 上下文工具类 ContextUtil
+
+相关静态方法：
+
+**标识进入调用链入口（上下文）**：
+
+以下静态方法用于标识调用链路入口，用于区分不同的调用链路：
+
+- `public static Context enter(String contextName)`
+- `public static Context enter(String contextName, String origin)`
+
+其中：
+
+- contextName，调用链路入口名称（上下文名称）
+- origin，调用来源名称。origin默认为空
+- 返回值类型为 `Context`，即生成的调用链路上下文对象
+
+`ContextUtil.enter(xxx)` 仅在调用链路入口处生效，即仅在当前线程的初次调用生效，后面再调用不会覆盖当前线程的调用链路，直到 exit。`Context` 存于 ThreadLocal，因此切换线程时可能丢掉，若需跨线程用，可结合 `runOnContext` 方法。
+
+流控规则中若选择“流控方式”为“链路”方式，则入口资源名即为上面的 `contextName`。
+
+**退出调用链（清空上下文）**：
+
+- `public static void exit()`：该方法用于退出调用链，清理当前线程的上下文。
+
+**获取当前线程的调用链上下文**：
+
+- `public static Context getContext()`：获取当前线程的调用链路上下文对象。
+
+**在某个调用链上下文中执行代码**：
+
+- `public static void runOnContext(Context context, Runnable f)`：常用于异步调用链路中 context 的变换。
+
+### 指标统计配置
+
+Sentinel 底层采用高性能的滑动窗口数据结构来统计实时的秒级指标数据，并支持对滑动窗口进行配置。主要有以下两个配置：
+
+- `windowIntervalMs`：滑动窗口的总的时间长度，默认为 1000 ms
+- `sampleCount`：滑动窗口划分的格子数目，默认为 2；格子越多则精度越高，但是内存占用也会越多
+
+![sliding-window-leap-array](https://user-images.githubusercontent.com/9434884/51955215-0af7c500-247e-11e9-8895-9fc0e4c10c8c.png)
+
+我们可以通过 `SampleCountProperty` 来动态地变更滑动窗口的格子数目，通过 `IntervalProperty` 来动态地变更滑动窗口的总时间长度。注意这两个配置都是**全局生效**的，会影响所有资源的所有指标统计。
+
+## Dashboard
+
+详情请参考：[Sentinel Dashboard 文档](https://sentinelguard.io/zh-cn/docs/dashboard.html)。
+
+参考：
+
+- [主流框架的适配](https://sentinelguard.io/zh-cn/docs/open-source-framework-integrations.html)
+- [Sentinel 注解支持文档](https://sentinelguard.io/zh-cn/docs/annotation-support.html)
\ No newline at end of file
diff --git a/docs/md/sentinel/origin-authority-control.md b/docs/md/sentinel/origin-authority-control.md
new file mode 100644
index 000000000..0429f2e83
--- /dev/null
+++ b/docs/md/sentinel/origin-authority-control.md
@@ -0,0 +1,106 @@
+# 来源访问控制（黑白名单）
+
+## 1 意义
+
+根据调用方来限制资源是否通过，可用 Sentinel 黑白名单控制的功能。根据资源的请求来源（`origin`）限制资源是否通过：
+
+- 若配置白名单则只有请求来源位于白名单内时才可通过
+- 若配置黑名单则请求来源位于黑名单时不通过，其余的请求通过
+
+> 调用方信息通过 `ContextUtil.enter(resourceName, origin)` 方法中的 `origin` 参数传入。
+
+## 2 规则配置
+
+黑白名单规则（`AuthorityRule`）配置项：
+
+- `resource`：资源名，即限流规则的作用对象
+- `limitApp`：对应的黑名单/白名单，不同 origin 用 `,` 分隔，如 `appA,appB`
+- `strategy`：限制模式，`AUTHORITY_WHITE` 为白名单模式，`AUTHORITY_BLACK` 为黑名单模式，默认为白名单模式
+
+## 3 示例
+
+控制对资源 `test` 的访问设置白名单，只有来源 `appA` 、 `appB` 的请求才可通过，则可以配置白名单规则：
+
+```java
+AuthorityRule rule = new AuthorityRule();
+rule.setResource("test");
+rule.setStrategy(RuleConstant.AUTHORITY_WHITE);
+rule.setLimitApp("appA,appB");
+AuthorityRuleManager.loadRules(Collections.singletonList(rule));
+```
+
+详请参考：
+
+```java
+package com.alibaba.csp.sentinel.demo.authority;
+
+import java.util.Collections;
+
+import com.alibaba.csp.sentinel.Entry;
+import com.alibaba.csp.sentinel.SphU;
+import com.alibaba.csp.sentinel.context.ContextUtil;
+import com.alibaba.csp.sentinel.slots.block.BlockException;
+import com.alibaba.csp.sentinel.slots.block.RuleConstant;
+import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRule;
+import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRuleManager;
+
+/**
+ * Authority rule is designed for limiting by request origins. In blacklist mode,
+ * requests will be blocked when blacklist contains current origin, otherwise will pass.
+ * In whitelist mode, only requests from whitelist origin can pass.
+ *
+ * @author Eric Zhao
+ */
+public class AuthorityDemo {
+
+    private static final String RESOURCE_NAME = "testABC";
+
+    public static void main(String[] args) {
+        System.out.println("========Testing for black list========");
+        initBlackRules();
+        testFor(RESOURCE_NAME, "appA");
+        testFor(RESOURCE_NAME, "appB");
+        testFor(RESOURCE_NAME, "appC");
+        testFor(RESOURCE_NAME, "appE");
+
+        System.out.println("========Testing for white list========");
+        initWhiteRules();
+        testFor(RESOURCE_NAME, "appA");
+        testFor(RESOURCE_NAME, "appB");
+        testFor(RESOURCE_NAME, "appC");
+        testFor(RESOURCE_NAME, "appE");
+    }
+
+    private static void testFor(/*@NonNull*/ String resource, /*@NonNull*/ String origin) {
+        ContextUtil.enter(resource, origin);
+        Entry entry = null;
+        try {
+            entry = SphU.entry(resource);
+            System.out.println(String.format("Passed for resource %s, origin is %s", resource, origin));
+        } catch (BlockException ex) {
+            System.err.println(String.format("Blocked for resource %s, origin is %s", resource, origin));
+        } finally {
+            if (entry != null) {
+                entry.exit();
+            }
+            ContextUtil.exit();
+        }
+    }
+
+    private static void initWhiteRules() {
+        AuthorityRule rule = new AuthorityRule();
+        rule.setResource(RESOURCE_NAME);
+        rule.setStrategy(RuleConstant.AUTHORITY_WHITE);
+        rule.setLimitApp("appA,appE");
+        AuthorityRuleManager.loadRules(Collections.singletonList(rule));
+    }
+
+    private static void initBlackRules() {
+        AuthorityRule rule = new AuthorityRule();
+        rule.setResource(RESOURCE_NAME);
+        rule.setStrategy(RuleConstant.AUTHORITY_BLACK);
+        rule.setLimitApp("appA,appB");
+        AuthorityRuleManager.loadRules(Collections.singletonList(rule));
+    }
+}
+```
\ No newline at end of file
diff --git a/docs/md/sentinel/spring-boot-integration-with-sentinel-practical-tutorial-from-dependency-to-custom-flow-control-and-monitoring.md b/docs/md/sentinel/spring-boot-integration-with-sentinel-practical-tutorial-from-dependency-to-custom-flow-control-and-monitoring.md
new file mode 100644
index 000000000..3cfab0031
--- /dev/null
+++ b/docs/md/sentinel/spring-boot-integration-with-sentinel-practical-tutorial-from-dependency-to-custom-flow-control-and-monitoring.md
@@ -0,0 +1,143 @@
+# SpringBoot集成Sentinel实战：从依赖到自定义限流与监控
+
+## 1 添加依赖
+
+### 1.1 JDK8
+
+```xml
+<dependency>
+    <groupId>com.alibaba.cloud</groupId>
+    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
+    <version>2.2.10-RC1</version>
+</dependency>
+```
+
+> groupId也可为 org.springframework.cloud。
+
+涵盖依赖包：
+
+![](https://p.ipic.vip/9ldrap.png)
+
+### 1.2 JDK21
+
+我使用的 JDK23+SpringBoot3.4.1：
+
+```xml
+<!-- Sentinel 依赖-->
+<dependency>
+    <groupId>com.alibaba.cloud</groupId>
+    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
+    <version>2023.0.3.2</version>
+</dependency>
+```
+
+## 2 暴露端点
+
+整合成功后，会暴露actuator/Sentinel端点，所以再添依赖：
+
+```xml
+<dependency>
+    <groupId>org.springframework.boot</groupId>
+    <artifactId>spring-boot-starter-actuator</artifactId>
+</dependency>
+```
+
+还需配置才能暴露端点（默认不暴露）：
+
+```yml
+management:
+  endpoints:
+    web:
+      exposure:
+        include: '*'
+```
+
+## 3 配置文件
+
+连接Sentinel控制台的地址信息配置
+
+```yml
+spinrg:
+ cloud:
+  sentinel:
+    transport:
+      dashboard: localhost:8080
+```
+
+## 4 Sentinel 自定义限流响应与实时监控
+
+### Sentinel 自定义资源与限流规则
+
+如针对接口限流：
+
+```java
+@RestController
+@RequestMapping("/pilot")
+public class PilotController {
+
+    @SentinelResource(value = "pilot_list", 
+                     blockHandler = "blockHandler")
+    @GetMapping("/getList")
+    public ResultBody list() {
+        Map<String, List<Pilot>> pilotServiceList = pilotService.getList();
+        return ResultBody.success(pilotServiceList);
+    }
+
+    // 限流降级方法
+    public ResultBody blockHandler(BlockException e) {
+        log.warn("触发限流", e);
+        return ResultBody.error("服务繁忙，请稍后再试");
+    }
+}
+```
+
+value对应的资源名称：
+
+![](https://p.ipic.vip/tf6m4m.png)
+
+```java
+@Configuration
+public class SentinelConfig implements BlockExceptionHandler {
+    
+    @PostConstruct
+    private void initFlowRules() {
+        List<FlowRule> rules = new ArrayList<>();
+        
+        // 创建流控规则
+        FlowRule rule = new FlowRule();
+        // 设置受保护的资源
+        rule.setResource("pilot_list");
+        // 设置流控规则 QPS
+        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
+        // 设置受保护的资源阈值
+        rule.setCount(1);
+        rules.add(rule);
+        
+        // 加载规则
+        FlowRuleManager.loadRules(rules);
+    }
+
+    @Bean
+    public SentinelResourceAspect sentinelResourceAspect() {
+        return new SentinelResourceAspect();
+    }
+
+    @Override
+    public void handle(HttpServletRequest request, HttpServletResponse response, String resourceName, BlockException e) throws Exception {
+        response.setStatus(429);
+        response.getWriter().write("访问过于频繁，请稍后再试");
+    }
+}
+```
+
+限流效果：
+
+![](https://p.ipic.vip/o69cp4.png)
+
+## 注意
+
+升级后，注意验证规则是否失效，避免版本差异bug。
+
+参考：
+
+- https://github.com/alibaba/spring-cloud-alibaba/wiki/%E7%89%88%E6%9C%AC%E8%AF%B4%E6%98%8E
\ No newline at end of file
diff --git "a/docs/md/spring/03-SpringMVC\346\213\246\346\210\252\345\244\204\347\220\206\345\231\250.md" "b/docs/md/spring/03-SpringMVC\346\213\246\346\210\252\345\244\204\347\220\206\345\231\250.md"
deleted file mode 100644
index 5c75f2da8..000000000
--- "a/docs/md/spring/03-SpringMVC\346\213\246\346\210\252\345\244\204\347\220\206\345\231\250.md"
+++ /dev/null
@@ -1,133 +0,0 @@
-# 03-SpringMVC拦截处理器
-
-## 1 工作原理流程图
-
-
-
-![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/b2f01056d69390b83a38d2b3385d4732.png)
-
-## 2 Spring Web MVC 的处理器拦截器
-
-
-
-![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/6ca1bc0105aabaf41667dad19d267e42.png)
-
-类似Servlet的过滤器Filter，用于对处理器进行预处理和后处理。HandlerInterceptor接口定义如下方法：
-
-### 2.1 preHandle
-
-
-
-![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/a1e7971e070dc2aa8255e3f0411c9e4d.png)
-
-最终会调用HandlerInterceptor的
-
-## 1 preHandle
-
-
-
-![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/5a9e302523148147cc77fafdf2e57011.png)
-
-调用所有的HandlerInterceptor拦截器并调用其preHandle方法。
-
-执行controller处理逻辑前执行，返回值为boolean，返回值为true时接着执行postHandle和afterCompletion，若返回false则中断执行。
-
-
-
-拦截处理程序的执行。 HandlerMapping确定的适当处理器对象后调用，但在HandlerAdapter调用处理器之前。
-
-DispatcherServlet是在执行链中处理的handler，其中包括了任意数量的拦截器，处理器本身在链的末尾，即最后才处理 handler。 利用该方法，每个拦截器可以决定中止执行链，特别发送一个HTTP错误或写入客户端响应。
-
-
-
-异步请求处理参见AsyncHandlerInterceptor 。
-true如果执行链应与下一个拦截器或处理程序本身进行。 否则，DispatcherServlet认为，这种拦截器已经处理了响应本身。
-
-在**请求处理之前进行调用**，只有当该方法返回true，才会继续调用下个`Interceptor`的`preHandle()`，若已是最后一个`Interceptor`，就调用当前请求的`Controller`
-
-### 2.2  postHandle
-
-applyPostHandle，获取所有的拦截器并调用其postHandle方法：
-![](https://img-blog.csdnimg.cn/20200605105309725.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_1,color_FFFFFF,t_70)
-
-在执行controller的处理后，在ModelAndView处理前执行。
-
-拦截处理程序的执行。 调用后的HandlerAdapter实际上调用的处理，但DispatcherServlet的呈现视图之前。 可以公开额外的模型对象通过给定的ModelAndView中的视图。
-DispatcherServlet的在执行链流程处理程序，其中包括任何数量的拦截器的，与所述处理程序本身在末端。 利用这种方法，每个拦截器可以后处理的执行，在执行链的相反的顺序得到应用。
-注：特殊注意事项适用于异步请求处理。 欲了解更多详情，请参见AsyncHandlerInterceptor 。
-
-在请求处理后，`DispatcherServlet`进行视图返回**渲染之前进行调用**，可在这个方法中对`Controller`处理之后的`ModelAndView`对象进行操作(比如这里加入公用信息，以便页面显示)
-
-### 2.3 afterCompletion
-
-在DispatchServlet执行完ModelAndView之后执行。
-
-
-
-请求处理，即完成之后回调，呈现视图后。 将在处理程序执行的任何结果调用，从而允许适当的资源清理。
-注意：如果此拦截器的才会被调用preHandle方法已成功完成，返回true ！
-如同postHandle方法，该方法将在以相反的顺序链中的每个拦截器被调用，所以第一个拦截器将是最后被调用。
-注：特殊注意事项适用于异步请求处理。 欲了解更多详情，请参见AsyncHandlerInterceptor 。
-
-需当前对应的`Interceptor`的`preHandle`方法的返回值为`true`时才会执行。该方法将在整个请求结束之后，即DispatcherServlet` 渲染了对应的视图之后执行，**用于资源清理**
-
-## 3 拦截器配置
-
-### 3.1 针对某种mapping拦截器配置
-
-```xml
- <bean  
-   class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping">  
-   <property name="interceptors">  
-      <list>  
-         <ref bean="handlerInterceptor1"/>  
-         <ref bean="handlerInterceptor2"/>  
-      </list>  
-   </property>  
-</bean>  
-<bean id="handlerInterceptor1"class="springmvc.intercapter.HandlerInterceptor1"/>  
-<bean id="handlerInterceptor2"class="springmvc.intercapter.HandlerInterceptor2"/> 
-```
-
-### 3.2 针对所有mapping配置全局拦截器
-
-```xml
-<!--拦截器 -->  
-<mvc:interceptors>  
-   <!--多个拦截器,顺序执行 -->  
-   <mvc:interceptor>  
-      <mvc:mapping path="/**"/>  
-      <bean class="com.sss.filter.HandlerInterceptor1"></bean>  
-   </mvc:interceptor>  
-   <mvc:interceptor>  
-      <mvc:mapping path="/**"/>  
-      <bean class="com.sss.filter.HandlerInterceptor2"></bean>  
-   </mvc:interceptor>  
-</mvc:interceptors>  
-```
-
-## 4 实践
-
- 用户访问其他页面时,从Seesion中获取到用户，未登录则重定向到登录页面。
-
-```java
-Public class LoginInterceptor implements HandlerInterceptor{   
-    @Override  
-    Public boolean preHandle(HttpServletRequest request,  
-            HttpServletResponse response, Object handler) throws Exception {  
-  
-        //如果是登录页面则放行  
-        if(request.getRequestURI().indexOf("login.action")>=0){  
-            return true;  
-        }  
-        HttpSession session = request.getSession();  
-        //如果用户已登录也放行  
-        if(session.getAttribute("user")!=null){  
-            return true;  
-        }  
-        //用户没有登录挑战到登录页面  
-        request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);  
-          
-        return false;  
-    }  
-```
\ No newline at end of file
diff --git "a/docs/md/spring/01-SpringMVC\347\232\204AsyncHandlerInterceptor\345\274\202\346\255\245\347\232\204\345\244\204\347\220\206\345\231\250\346\213\246\346\210\252\345\231\250.md" b/docs/md/spring/SpringMVC-AsyncHandlerInterceptor.md
similarity index 100%
rename from "docs/md/spring/01-SpringMVC\347\232\204AsyncHandlerInterceptor\345\274\202\346\255\245\347\232\204\345\244\204\347\220\206\345\231\250\346\213\246\346\210\252\345\231\250.md"
rename to docs/md/spring/SpringMVC-AsyncHandlerInterceptor.md
diff --git a/docs/md/spring/SpringMVC-HandlerInterceptor.md b/docs/md/spring/SpringMVC-HandlerInterceptor.md
new file mode 100644
index 000000000..e68684698
--- /dev/null
+++ b/docs/md/spring/SpringMVC-HandlerInterceptor.md
@@ -0,0 +1,167 @@
+# SpringMVC拦截处理器
+
+## 1 工作原理流程图
+
+![](https://p.ipic.vip/vp2z0x.png)
+
+## 2 Spring Web MVC 的处理器拦截器
+
+```java
+public interface HandlerInterceptor {
+
+	default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
+			throws Exception {
+
+		return true;
+	}
+
+	default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
+			@Nullable ModelAndView modelAndView) throws Exception {
+	}
+
+	default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
+			@Nullable Exception ex) throws Exception {
+	}
+
+}
+```
+
+类似Servlet的过滤器Filter，对处理器进行预处理、后处理。HandlerInterceptor接口方法：
+
+### 2.1 preHandle
+
+```java
+@SuppressWarnings("serial")
+public class DispatcherServlet extends FrameworkServlet {
+  
+  	protected void doDispatch() {
+      ...
+      if (!mappedHandler.applyPreHandle(processedRequest, response)) {
+				return;
+			 }
+    }
+}
+```
+
+最终会调用HandlerInterceptor#preHandle：
+
+```java
+public class HandlerExecutionChain {
+
+  boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
+  HandlerInterceptor[] interceptors = getInterceptors();
+  if (!ObjectUtils.isEmpty(interceptors)) {
+    for (int i = 0; i < interceptors.length; i++) {
+      HandlerInterceptor interceptor = interceptors[i];
+      if (!interceptor.preHandle(request, response, this.handler)) {
+        ...
+}
+```
+
+调用所有的HandlerInterceptor拦截器并调用其preHandle方法。
+
+执行controller处理逻辑前执行，返回值为boolean，返回值为true时接着执行postHandle和afterCompletion，若返回false则中断执行。
+
+
+
+拦截处理程序的执行。 HandlerMapping确定的适当处理器对象后调用，但在HandlerAdapter调用处理器之前。
+
+DispatcherServlet是在执行链中处理的handler，其中包括了任意数量的拦截器，处理器本身在链的末尾，即最后才处理 handler。 利用该方法，每个拦截器可以决定中止执行链，特别发送一个HTTP错误或写入客户端响应。
+
+
+
+异步请求处理参见AsyncHandlerInterceptor 。
+true如果执行链应与下一个拦截器或处理程序本身进行。 否则，DispatcherServlet认为，这种拦截器已经处理了响应本身。
+
+在业务处理器处理请求前被调用，只有当该方法返回true，才会继续调用下个`Interceptor`的`preHandle()`，若已是最后一个`Interceptor`，就调用当前请求的`Controller`
+
+### 2.2  postHandle
+
+applyPostHandle，获取所有的拦截器并调用其postHandle方法：
+
+```java
+/**
+ * Apply postHandle methods of registered interceptors.
+ */
+void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
+    throws Exception {
+
+  HandlerInterceptor[] interceptors = getInterceptors();
+  if (!ObjectUtils.isEmpty(interceptors)) {
+    for (int i = interceptors.length - 1; i >= 0; i--) {
+      HandlerInterceptor interceptor = interceptors[i];
+      interceptor.postHandle(request, response, this.handler, mv);
+    }
+  }
+}
+```
+
+执行controller的处理后，即业务处理器处理请求执行完成后，并在ModelAndView处理生成视图之前执行。
+
+请求处理后，`DispatcherServlet`进行视图返回**渲染之前进行调用**，可在该方法中对`Controller`处理之后的`ModelAndView`对象进行操作（如加入公用信息，以便页面显示）。
+
+### 2.3 afterCompletion
+
+DispatchServlet执行完ModelAndView后执行，即完成之后回调，呈现视图后。 将在处理程序执行的任何结果调用，从而允许适当的资源清理。
+
+需当前对应的`Interceptor`的`preHandle`方法的返回值为`true`时才会执行。该方法将在整个请求结束之后，即DispatcherServlet渲染了对应的视图之后执行，**用于资源清理**。
+
+## 3 拦截器配置
+
+### 3.1 针对某种mapping拦截器配置
+
+```xml
+ <bean  
+   class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping">  
+   <property name="interceptors">  
+      <list>  
+         <ref bean="handlerInterceptor1"/>  
+         <ref bean="handlerInterceptor2"/>  
+      </list>  
+   </property>  
+</bean>  
+<bean id="handlerInterceptor1"class="springmvc.intercapter.HandlerInterceptor1"/>  
+<bean id="handlerInterceptor2"class="springmvc.intercapter.HandlerInterceptor2"/> 
+```
+
+### 3.2 针对所有mapping配置全局拦截器
+
+```xml
+<!--拦截器 -->  
+<mvc:interceptors>  
+   <!--多个拦截器,顺序执行 -->  
+   <mvc:interceptor>  
+      <mvc:mapping path="/**"/>  
+      <bean class="com.sss.filter.HandlerInterceptor1"></bean>  
+   </mvc:interceptor>  
+   <mvc:interceptor>  
+      <mvc:mapping path="/**"/>  
+      <bean class="com.sss.filter.HandlerInterceptor2"></bean>  
+   </mvc:interceptor>  
+</mvc:interceptors>  
+```
+
+## 4 实践
+
+ 用户访问其他页面时,从Seesion中获取到用户，未登录则重定向到登录页面。
+
+```java
+Public class LoginInterceptor implements HandlerInterceptor {   
+    @Override  
+    Public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {  
+  
+        // 若是登录页面则放行  
+        if(request.getRequestURI().indexOf("login.action")>=0){  
+            return true;  
+        }  
+        HttpSession session = request.getSession();  
+        //如果用户已登录也放行  
+        if(session.getAttribute("user")!=null){  
+            return true;  
+        }  
+        //用户没有登录挑战到登录页面  
+        request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);  
+          
+        return false;  
+    }
+```
\ No newline at end of file
diff --git a/docs/md/spring/farewell-bean-not-found-easily-solve-spring-boot-package-scanning-issues.md b/docs/md/spring/farewell-bean-not-found-easily-solve-spring-boot-package-scanning-issues.md
new file mode 100644
index 000000000..fad565899
--- /dev/null
+++ b/docs/md/spring/farewell-bean-not-found-easily-solve-spring-boot-package-scanning-issues.md
@@ -0,0 +1,146 @@
+# 01-告别 "Bean Not Found"！轻松搞定 Spring Boot 包扫描难题 ✅
+
+## 0 前言
+
+SpringBoot约定大于配置，但不熟悉所有约定，所以经常写bug！
+
+## 1 案例：扫描不到Bean定义
+
+Spring Boot服务包结构：
+
+![](https://p.ipic.vip/ngsrcp.png)
+
+BestPractiseApplication：
+
+```java
+package com.javaedge.spring.aop;
+
+/**
+ * @author JavaEdge
+ */
+@SpringBootApplication
+public class BestPractiseApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(BestPractiseApplication.class, args);
+    }
+}
+```
+
+MyController：
+
+```java
+package com.javaedge.spring.app;
+
+/**
+ * @author JavaEdge
+ */
+@RestController
+public class MyController {
+
+    @GetMapping("hello")
+    public String hello() {
+        return "hello Java";
+    }
+}
+```
+
+访问`http://localhost:12345/hello`：
+
+![](https://p.ipic.vip/jazxoq.png)
+
+紧急需求，需添加多个Controller，常规操作调整包结构：
+
+![](https://p.ipic.vip/rs3f8j.png)
+
+发现应用不识别MyController，找不到 MyController 这 Bean，why？
+
+![](https://p.ipic.vip/9hb0it.png)
+
+## 2 解惑
+
+### 2.1 之前为啥生效？
+
+@SpringBootApplication继承了其它注解：
+
+```java
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+@SpringBootConfiguration
+@EnableAutoConfiguration
+@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
+		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
+public @interface SpringBootApplication {
+```
+
+SpringBootApplication默认开启ComponentScan。SpringBoot应用启动时，ComponentScan扫描所有定义的 Bean，扫描位置由 ComponentScan 的 basePackages 属性指定：
+
+```java
+package org.springframework.context.annotation;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+@Documented
+@Repeatable(ComponentScans.class)
+public @interface ComponentScan {
+
+	@AliasFor("basePackages")
+	String[] value() default {};
+
+	@AliasFor("value")
+	String[] basePackages() default {};
+```
+
+但basePackages默认空，那它扫描的啥包？debug 到 ComponentScanAnnotationParser#parse：
+
+![](https://p.ipic.vip/f1ohqq.png)
+
+即declaringClass所在包，即`com.javaedge.app`。
+
+## 3 修正
+
+如下两种方案：
+
+### 3.1 放好位置
+
+![](https://p.ipic.vip/mwbno6.png)
+
+![](https://p.ipic.vip/nunv63.png)
+
+### 3.2 显式配置
+
+#### @ComponentScan
+
+```java
+package com.javaedge.spring.app;
+
+@SpringBootApplication()
+@ComponentScan("com.javaedge.spring.controller")
+public class BestPractiseApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(BestPractiseApplication.class, args);
+    }
+}
+```
+
+![](https://p.ipic.vip/xybhs1.png)
+
+#### @ComponentScans
+
+```java
+package com.javaedge.spring.app;
+
+@SpringBootApplication()
+@ComponentScans(value = {@ComponentScan(value = "com.javaedge.spring.controller")})
+public class BestPractiseApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(BestPractiseApplication.class, args);
+    }
+}
+```
+
+ComponentScans 相比 ComponentScan，可指定扫描多个包范围。
\ No newline at end of file
diff --git a/docs/md/spring/why-spring-bean-difficult-birth-overcome-constructor-injection-dependencies-and-ambiguity.md b/docs/md/spring/why-spring-bean-difficult-birth-overcome-constructor-injection-dependencies-and-ambiguity.md
new file mode 100644
index 000000000..08581f79a
--- /dev/null
+++ b/docs/md/spring/why-spring-bean-difficult-birth-overcome-constructor-injection-dependencies-and-ambiguity.md
@@ -0,0 +1,189 @@
+# Spring 原型 Bean 的“单例劫”：@Lookup 如何破局，确保每次获取新实例？
+
+## 1 案例：原型 Bean 被固定
+
+使用原型 Bean：
+
+```java
+package com.javaedge.spring.service;
+
+/**
+ * @author JavaEdge
+ */
+@Service
+@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
+public class JavaService {
+}
+```
+
+这么用：
+
+```java
+package com.javaedge.spring.controller;
+
+@RestController
+public class MyController {
+
+    @Autowired
+    private JavaService javaService;
+
+    @GetMapping("hello")
+    public String hello() {
+        return "hello: " + javaService;
+    }
+```
+
+不管访问多少次[http://localhost:12345/hello](http://localhost:12345/hello)，返回值不变：
+
+![](https://p.ipic.vip/jqzjki.png)
+
+不是定义成原型 Bean了，没生效？
+
+## 2 答疑
+
+当一个属性成员 javaService 声明为@Autowired，创建 MyController Bean 时，会先用构造器反射出实例，然后装配各标记@Autowired的属性成员。
+
+装配方法AbstractAutowireCapableBeanFactory#populateBean，会用很多BeanPostProcessor，其中AutowiredAnnotationBeanPostProcessor通过 DefaultListableBeanFactory#findAutowireCandidates 寻找到 JavaService 类型 Bean，再设置给对应属性（即 javaService成员）。
+
+### inject
+
+AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement：
+
+```java
+protected void inject(Object bean, @Nullable String beanName, PropertyValues pvs) {
+   Field field = (Field) this.member;
+   Object value;
+   // 寻找bean
+   if (this.cached) {
+      value = resolvedCachedArgument(beanName, this.cachedFieldValue);
+   }
+   else {
+     // ...
+     value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
+   }
+   if (value != null) {
+      // 将bean设置给成员字段
+      ReflectionUtils.makeAccessible(field);
+      field.set(bean, value);
+   }
+}
+```
+
+找到要自动注入的 Bean 后，即反射设置给对应field。这个field的执行只发生一次，所以后续就固定，不会因ServiceImpl标记了 **SCOPE_PROTOTYPE** 而改变。
+
+所以，当一个单例Bean用@Autowired标记其属性时，该属性值会被固定！
+
+## 3 修正
+
+不能将 JavaService 的 Bean 固定到属性，而应每次用时都重新获取一次。修正方案：
+
+### 3.1 自动注入 Context
+
+即自动注入ApplicationContext，再定义 getJavaService 方法以获取一个新 JavaService 实例：
+
+```java
+@RestController
+public class MyController {
+
+    @Autowired
+    private ApplicationContext applicationContext;
+
+    @Autowired
+    private JavaService javaService;
+
+    @GetMapping("hello")
+    public String hello() {
+        return "hello: " + getJavaService();
+    }
+
+    public JavaService getJavaService() {
+  		return applicationContext.getBean(JavaService.class);
+    }
+}
+```
+
+### 使用 Lookup 注解
+
+还是要添加一个 getServiceImpl 方法，不过这个方法是被 Lookup 标记的：
+
+```java
+@RestController
+public class MyController {
+
+    @Autowired
+    private JavaService javaService;
+
+    @GetMapping("hello")
+    public String hello() {
+        return "hello: " + getJavaService();
+    }
+ 
+  	@Lookup
+    public JavaService getJavaService() {
+  		return null;
+    }
+}
+```
+
+这样每次访问该接口，都会创建新的Bean。
+
+## 4 Lookup原理
+
+最终执行因@Lookup而走入CglibSubclassingInstantiationStrategy.LookupOverrideMethodInterceptor，其关键实现参考 LookupOverrideMethodInterceptor的
+
+### intercept
+
+```java
+private final BeanFactory owner;
+
+public Object intercept(Object obj, Method method, Object[] args, MethodProxy mp) throws Throwable {
+   LookupOverride lo = (LookupOverride) getBeanDefinition().getMethodOverrides().getOverride(method);
+   Assert.state(lo != null, "LookupOverride not found");
+   Object[] argsToUse = (args.length > 0 ? args : null);  // if no-arg, don't insist on args at all
+   if (StringUtils.hasText(lo.getBeanName())) {
+      return (argsToUse != null ? this.owner.getBean(lo.getBeanName(), argsToUse) :
+            this.owner.getBean(lo.getBeanName()));
+   }
+   else {
+      return (argsToUse != null ? this.owner.getBean(method.getReturnType(), argsToUse) :
+            this.owner.getBean(method.getReturnType()));
+   }
+}
+```
+
+方法调用最终没有走入案例代码实现的return null语句，而是通过 BeanFactory 获取 Bean。从这点看出，在getServiceImpl方法实现中，随便咋写都行，不重要。
+
+如用下面实现来测试这结论：
+
+```java
+@Lookup
+public ServiceImpl getServiceImpl() {
+    // 日志会输出么？
+    log.info("executing this method");
+    return null;
+}  
+```
+
+以上代码，添加了一行代码输出日志。测试后，发现没有日志输出。这也验证了，用@Lookup注解一个方法时，方法具体实现已不重要。
+
+Q：再回溯分析，为啥走入CGLIB搞出的类？
+
+A：因为我们有方法标记Lookup。可从下面这段验证，参考 SimpleInstantiationStrategy#instantiate：
+
+```java
+@Override
+public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
+   // Don't override the class with CGLIB if no overrides.
+   if (!bd.hasMethodOverrides()) {
+      return BeanUtils.instantiateClass(constructorToUse);
+   }
+   else {
+      // Must generate CGLIB subclass.
+      return instantiateWithMethodInjection(bd, beanName, owner);
+   }
+}
+```
+
+当 hasMethodOverrides 为 true，则用 CGLIB。而本案例该条件成立在于解析HelloWorldController这Bean时，发现有方法被@Lookup，此时就会添加相应方法到属性methodOverrides 里面去（此过程由 AutowiredAnnotationBeanPostProcessor#determineCandidateConstructors 完成）。
+
+添加后效果图如下：
\ No newline at end of file
diff --git a/docs/md/vue/goodbye-jquery-thinking-create-checklist-apps-with-vue-js-experience-the-charm-of-data-driven.md b/docs/md/vue/goodbye-jquery-thinking-create-checklist-apps-with-vue-js-experience-the-charm-of-data-driven.md
new file mode 100644
index 000000000..dcd147a1d
--- /dev/null
+++ b/docs/md/vue/goodbye-jquery-thinking-create-checklist-apps-with-vue-js-experience-the-charm-of-data-driven.md
@@ -0,0 +1,388 @@
+# 告别 jQuery 思维：用 Vue.js 轻松打造清单应用，体验数据驱动的魅力
+
+## 0 前言
+
+团队的项目是用Vue.js开发的，但并不熟悉Vue的具体技术细节，所以我决定带他先做一个清单应用，先在整体上熟悉这个框架。带你们做个清单应用，更多的是一种模拟的场景，并不需要对号入座到真实的工作场景下。
+
+## 1 任务分解
+
+有一个输入框，供我们输入数据；下方有一个列表，显示着所有我们要做的事情。
+
+在输入框输入内容后，敲下回车，下面就会新增一条数据。对于每个要做的事情，你还可以用复选框标记，标记后文字就会变灰，并带有一个删除的效果，表示这事已做完。
+
+![](https://p.ipic.vip/1akdw1.png)
+
+清单应用麻雀虽小，五脏俱全。不管入门哪个框架，都可写一个清单体验。
+
+只有简单jQuery开发经验，先要思想转变。对比
+
+## 2 jQuery V.S Vue.js
+
+做一个输入框，里面输入的任何数据都会在页面上同步显示。
+
+### 2.1 jQuery开发思路
+
+1. 先找到输入框，给输入框绑定输入事件
+2. 输入的同时，我们获取输入的值
+3. 再找到对应的html标签，更新标签的内容
+
+代码：
+
+```html
+<div>
+    <h2 id="app"></h2>
+    <input type="text" id="todo-input">
+</div>
+<script src="jquery.min.js"></script>
+<script>
+    // 1. 先找到输入框，然后持续监听输入
+    $('#todo-input').on('input',function(){
+        let val = $(this).val() // 2. 之后一直等待到输入值被获取
+        $('#app').html(val) // 3. 最后找到标签所在的前端页面位置，进行内容的修改
+    })
+</script>
+```
+
+jQuery开发逻辑就是先找到目标元素，再进行对应修改。
+
+而Vue.js不再思考页面的元素咋操作，而是思考数据咋变化。即只需操作数据，至于数据和页面的同步问题，Vue帮我们处理。Vue让前端能专注数据本身操作，而数据和页面的同步问题，由Vue负责。 
+
+### 2.2 Vue开发思路
+
+我们需要一个数据，在输入框的代码和h2标签的代码内使用。只需操作数据，再交给Vue去管理数据和页面的同步。
+
+Vue下，想页面显示一个数据:
+
+- 先在代码的data里声明数据
+- 输入框代码里用v-model标记输入框和数据的同步
+- HTML模板里，两个花括号标记，来显示数据，如{{title}}∂
+
+#### 对应代码
+
+```vue
+<div id="app">
+  <h2>{{title}}</h2>
+  <input type="text" v-model="title">
+</div>
+
+<script src="https://unpkg.com/vue@next"></script>
+<script>
+const App = {
+  data() {
+    return {
+      title: "" // 定义一个数据
+    }
+  }
+}
+// 启动应用
+Vue.createApp(App).mount('#app')
+</script>
+```
+
+## 3 清单页面的渲染
+
+- 输入框输入数据
+- 输入框下方要有个列表，显示所有输入的值
+
+按Vue思考方式，需一个数组，再用v-for循环渲染。
+
+### 代码
+
+```vue
+<div id="app">
+  <h2>{{title}}</h2>
+  <input type="text" v-model="title">
+  <ul>
+    <li v-for="todo in todos">{{todo}}</li>
+  </ul>
+</div>
+
+<script src="https://unpkg.com/vue@next"></script>
+<script>
+const App = {
+  data() {
+    return {
+      title: "", // 定义一个数据
+      todos:['吃饭','睡觉'] // 再定义一个数据todos，输入一个数组
+    }
+  }
+}
+// 启动应用
+Vue.createApp(App).mount('#app')
+</script>
+```
+
+先放两个假数据，如在标签里直接写{{todos}}，就会看到显示的是数组，但不是想要的，我们需要显示一个列表。
+
+Vue中只要渲染列表，都用v-for：
+
+```xml
+<li v-for="todo in todos">{{todo}}</li>
+```
+
+循环遍历todos这个数据， 每一条遍历的结果叫todo，再把这个数据渲染出来，页面就能显示一个列表：
+
+![](https://p.ipic.vip/di4aqn.png)
+
+## 4 处理用户交互
+
+上步主要考虑：实现前端页面的一个输入框及能显示输入值的一个列表的功能。
+
+下一步，就是回车时，让列表新增一条。按Vue思维：
+
+- 监听用户的输入。在监听中，若判断到用户的输入是回车，就执行一个函数
+- 在执行的这个函数内部，把title追加到todos最后面位置，并清空title
+
+### 代码
+
+```vue
+<div id="app">
+  <input type="text" v-model="title" @keydown.enter="addTodo">
+  <ul>
+    <li v-for="todo in todos">{{todo}}</li>
+  </ul>
+</div>
+
+<script src="https://unpkg.com/vue@next"></script>
+<script>
+const App = {
+  data() {
+    return {
+      title: "", // 定义一个数据
+      todos:['吃饭','睡觉']
+    }
+  },
+  methods:{
+    addTodo(){
+      this.todos.push(this.title)
+      this.title = ""
+    }
+  }
+}
+// 启动应用
+Vue.createApp(App).mount('#app')
+</script>
+```
+
+@标记用户的交互：
+
+- @click是点击
+- @keydown是键盘敲下
+
+监听回车键，那么我们就用@keydown.enter=“addTodo” 。
+
+监听到用户的输入后，对要执行的函数，新增一个methods配置。函数内部，this可直接读到data里数据，无需考虑咋找到标签。只需如下一行就能让列表自动新增一条， 这就是数据驱动页面。
+
+```js
+this.todos.push(this.title)
+```
+
+## 5 额外信息的显示
+
+实现标记清单中某项是否完成。
+
+目前代码设计，输入只能是字符串格式。而标记功能，却是把列表中的某项，用灰色的字体背景和中划线来标记，以此表示这一条内容是已完成内容。
+
+想实现，需改造数据结构，把内容的数据类型，从简单的字符串类型改为对象。
+
+### 代码
+
+```vue
+  <ul>
+    <li v-for="todo in todos">
+      <input type="checkbox" v-model="todo.done">
+      <span :class="{done:todo.done}"> {{todo.title}}</span>
+    </li>
+  </ul>
+
+<script>
+const App = {
+  data() {
+    return {
+      title: "",
+      todos:[
+        {title:'吃饭',done:false},
+        {title:'睡觉',done:true}
+      ]
+    }
+  },
+  methods:{
+    addTodo(){
+      this.todos.push({
+        title:this.title,
+        done:false
+      })
+      this.title = ""
+    }
+  }
+}
+</script>
+
+<style>
+  .done{
+    color:gray;
+    text-decoration: line-through;
+  }
+</style>
+```
+
+### 改造思路
+
+对todos数组，除了title，还要加个done字段，标记列表中的某项内容是否完成，并且渲染时用todo.title。
+
+前面对列表中每项用无序列表示。但若想在列表中实现对某些选项的同时多选，得用复选框。对每条信息，都要加个复选框，所以用v-model绑定这done字段，实现数据里能记录用户操作的状态。
+
+还需根据done字段显示某行样式。Vue的冒号":" 开头的属性是用来传递数据，这里的写法就是根据todo.done决定是否有done这个class。最后，当加上".done"的样式后，左图就是效果，右图是涉及到".done"的相关代码：
+
+![](https://p.ipic.vip/bas4ue.png)
+
+## 6 进一步优化
+
+还想增加两个功能：
+
+- 在前端页面显示的列表的最下面，显示一下列表项目中没完成的项目的比例
+- 新增一个清理的按钮，用来删掉已经标记为完成的列表中的一条或多条数据
+
+### 第一个功能的代码（模版里写js）
+
+```html
+<div>
+  {{todos.filter(v=>!v.done).length}}
+  /
+  {{todos.length}}
+</div>
+```
+
+这段代码增加到上步最后的完整代码中，运行代码，从下图所示的前端页面运行时状态中，可见其中显示的未完成比例的数据也没问题。
+
+![](https://p.ipic.vip/enb003.png)
+
+代码看起来丑且性能差，且需要二次计算的数据。模板里写JS，看着代码也乱。Vue对此设计了
+
+### 计算属性
+
+用计算属性实现二次计算需求：
+
+```vue
+  <div>
+    {{active}}  / {{all}}
+  </div>
+
+<script>
+  computed:{
+    active(){
+      return this.todos.filter(v=>!v.done).length
+    },
+    all(){
+      return this.todos.length
+    }
+  }
+</script>
+```
+
+新增属性computed，其配置active、all都是函数。俩函数返回的计算后的值，在模板里可直接当做数据来用，这样把js的计算逻辑依然放在js，避免臃肿模板。
+
+computed计算属性还内置缓存功能，如果依赖数据没变化，多次使用计算属性会直接返回缓存结果，相比直接写在模板，性能也提升。
+
+计算属性不仅可以用来返回数据，有些时候我们也需要修改计算属性，如新增一个全选的复选框：
+
+- 全选框在勾选与取消勾选两个状态之间的切换，会把所有清单内的数据都同步勾选
+- 清单内的项目如果全部选中或者取消，也会修改全选框的状态
+
+所以全选框这计算属性，就有了修改的需求。此时computed的配置就不能是函数，要变成一个对象，分别实现：
+
+- get函数，之前的返回值
+- set，修改计算属性要执行的函数
+
+### computed修改后的代码
+
+```vue
+<div>
+  全选<input type="checkbox" v-model="allDone">
+  <span> {{active}}  / {{all}} </span>
+</div>
+
+<script>
+computed:{
+  active(){
+    return this.todos.filter(v=>!v.done).length
+  },
+  all(){
+    return this.todos.length
+  },
+  // 和没有全选框时的computed属性的配置代码相比，新增一个allDone的计算属性，页面中直接用checbox绑定
+  allDone: {
+      // allDone会返回啥值，只需判断计算属性active是否为0
+      get: function () {
+        return this.active === 0
+      },
+      // 修改allDone，即前端页面切换全选框时，直接遍历todos，把里面done字段直接和allDone同步
+      set: function (val) {
+        this.todos.forEach(todo=>{
+          todo.done = val
+        });
+      }
+  }
+}
+</script>
+```
+
+ 实现新增一个全选的复选框后的效果：
+
+![](/Users/javaedge/Pictures/Vue3images/428106/273d37ca7e59a40ac0d5a537203f41cf【海量资源：666java.com】.gif)
+
+## 7 条件渲染
+
+新增一个“清理”的按钮，点击之后把已完成的数据删除，功能需求很简单，但是有一个额外的要求，就是列表中没有标记为完成的某一项列表数据时，这个按钮是不显示的。
+
+这种在特定条件下才显示，或者隐藏的需求也很常见，我们称之为条件渲染。在Vue中，我们使用v-if 来实现条件渲染。
+
+### 代码
+
+```vue
+<button v-if="active<all" @click="clear">清理</button>
+<script>
+  methods:{
+    clear(){
+      this.todos = this.todos.filter(v=>!v.done)
+    }
+  }
+</script>
+```
+
+active＜all时，显示清理按钮，即v-if后面值true时，显示清理按钮，false时不显示。
+
+@click的作用是绑定点击事件。
+
+还可用v-else配合v-if，当todos是空的时候，显示一条“暂无数据”的信息：
+
+```xml
+  <ul v-if="todos.length">
+    <li v-for="todo in todos">
+      <input type="checkbox" v-model="todo.done">
+      <span :class="{done:todo.done}"> {{todo.title}}</span>
+    </li>
+  </ul>
+  <div v-else>
+    暂无数据
+  </div>
+
+```
+
+当我们实现了清理按钮的功能，并且也实现了列表为空时，能够显示“暂无数据”的信息后，我们看下清单应用的最终效果。
+
+ ![](/Users/javaedge/Pictures/Vue3images/428106/3c8ddf81d6b478069d6b1dec7b605572【海量资源：666java.com】.gif)
+
+## 8 总结
+
+先扭转之前jQuery开发思路，弄明白jQuery和Vue开发思路区别。从寻找DOM到数据驱动，前端开发的一次巨大变革。
+
+Vue的入门做清单应用：先要有输入框能输入文本，并且在输入框下方循环显示清单，我们用到了v-model，v-for这些功能。这些v-开头的属性都是Vue自带写法，我们通过{{}}包裹的形式显示数据。
+
+用户输入完成后回车新增一条数据，就用到@开头的几个属性，@keyup和@click都是绑定对应的交互事件。
+
+最后，通过computed，我们能对页面数据的显示进行优化。我们所需要关心的，就是数据的变化。
+
+## FAQ
+
+现在所有的操作状态一刷新就都没了，咋解决？
\ No newline at end of file
diff --git a/docs/md/vue/vue-js-vs-axios-practical-guide-from-ajax-requests-to-api-proxy-configuration.md b/docs/md/vue/vue-js-vs-axios-practical-guide-from-ajax-requests-to-api-proxy-configuration.md
new file mode 100644
index 000000000..dc7a835e4
--- /dev/null
+++ b/docs/md/vue/vue-js-vs-axios-practical-guide-from-ajax-requests-to-api-proxy-configuration.md
@@ -0,0 +1,145 @@
+# Vue.js 与 Axios 实战：从发送 AJAX 请求到 API 代理配置全攻略
+
+## 0 前言
+
+Axios，流行的 js 库，用于发送 AJAX 请求。本文介绍Vue中咋用 Axios 发 AJAX 请求。
+
+## 1 安装
+
+先在项目中安装 Axios。进入项目目录运行：
+
+```bash
+cnpm install axios@0.17.1 --save
+```
+
+## 2 发送 AJAX 请求
+
+在 Vue 组件中用它发 AJAX 请求。
+
+### 示例
+
+```vue
+<template>
+  <div>
+    <button @click="getData">获取数据</button>
+    <div v-if="data">{{ data }}</div>
+  </div>
+</template>
+
+<script>
+// 先导 Axios 库
+import axios from 'axios';
+
+export default {
+  data() {
+    return {
+      // 在组件的data()方法定义一个data属性，存储从服务器获取的数据
+      data: null,
+    };
+  },
+  methods: {
+    //  定义该方法，用于发送 AJAX 请求并更新组件的data属性
+    getData() {
+      axios
+        .get('/api/data')
+        .then((response) => {
+          this.data = response.data;
+        })
+        .catch((error) => {
+          console.log(error);
+        });
+    },
+  },
+};
+</script>
+```
+
+在 `getData` 方法中，用 `axios.get` 方法发送 GET 请求。该方法接受一个 URL 参数，用于指定要请求的服务器端点。本例用 `/api/data` 作为 URL。
+
+再用 Promise 的 `then` 方法处理响应，如果：
+
+- 请求成功，`then` 将接收一个响应对象，并将响应数据存储到组件的 `data` 属性中
+- 请求失败，则用 Promise 的 `catch` 方法处理错误
+
+最后，在组件模板中，用一个按钮触发 `getData` 方法，并根据是否有数据来显示数据。
+
+## 3 项目实战
+
+组件很多，若每个组件都发 HTTP 请求，性能太差。咋优化？希望整个首页只发送一个 ajax 请求。显然，在 Home.vue 里发送最好不过。 
+
+组件有个生命周期函数 mounted：
+
+```js
+methods: {
+  getHomeInfo () {
+    // 本地 mock 数据
+    // axios.get('/api/index.json?city=' + this.city)
+    axios.get('/static/mock/index.json')
+      .then(this.getHomeInfoSuccess)
+  },
+  getHomeInfoSuccess (res) {
+  }
+},
+mounted () {
+  this.getHomeInfo()
+}
+```
+
+有人觉得，本地mock 执行
+
+```js
+axios.get('/static/mock/index.json')
+        .then(this.getHomeInfoSuccess)
+```
+
+上线前，再改成
+
+```js
+axios.get('/api/index.json?city=' + this.city)
+```
+
+真麻烦，万一忘了，很烦。还好 Vue 帮解决这问题。修改脚手架文件：index.js
+
+![](https://img-blog.csdnimg.cn/71c97ccf0cdb41af97c6ad7a924eb25e.png)
+
+```js
+'use strict'
+// Template version: 1.3.1
+// see http://vuejs-templates.github.io/webpack for documentation.
+
+const path = require('path')
+
+module.exports = {
+  dev: {
+
+    // Paths
+    assetsSubDirectory: 'static',
+    assetsPublicPath: '/',
+    /**
+     * webpack-dev-server 提供的功能
+     * 
+     * /api开头的请求代理到http://localhost:8080/static/mock
+     * proxyTable是一个对象，用于配置代理规则
+     * '/api'是代理规则的路径，表示所有以/api开头的请求都会被代理
+     * target是代理的目标地址，即将请求转发到的地址
+     * pathRewrite是路径重写规则，用于将请求路径中的'/api'替换成'/static/mock'
+     */
+    proxyTable: {
+      '/api': {
+        target: 'http://localhost:8080',
+        pathRewrite: {
+          '^/api': '/static/mock'
+        }
+      }
+    },
+```
+
+改变了配置项，所以需要重启服务：
+
+可见，请求成功，拿到数据了：
+
+![](https://p.ipic.vip/z9gh9v.png)
+
+## 4 总结
+
+功能强大的 js 库，可发送 AJAX 请求。在 Vue 中使用 Axios 可轻松与服务器进行通信，并从服务器获取数据。
\ No newline at end of file

From 2a5651b358465eb34f8e0c300a9e8f0dd61e4c80 Mon Sep 17 00:00:00 2001
From: JavaEdge <sss2855845850@gmail.com>
Date: Fri, 6 Jun 2025 13:33:29 +0800
Subject: [PATCH 19/20] =?UTF-8?q?fix:=E8=B0=83=E6=95=B4dify=E4=B8=93?=
 =?UTF-8?q?=E6=A0=8F=E4=BD=8D=E7=BD=AE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/.vuepress/config.js                      | 23 +++++
 ...-of-rag-result-retrieval-and-reordering.md | 29 +-----
 docs/md/AI/llm/configuring-models-in-dify.md  | 91 +++++++++++++++++++
 3 files changed, 115 insertions(+), 28 deletions(-)
 create mode 100644 docs/md/AI/llm/configuring-models-in-dify.md

diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index 28e2fefb9..f97454f80 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -2205,6 +2205,7 @@ module.exports = {
                         sidebarDepth: 0,
                         children: [
                             "what-is-llmops",
+                            "configuring-models-in-dify",
                             "Build-App-with-Dify",
                             "integrate-dify-and-aws-services-to-enable-more-flexible-translation-workflows",
                             "llm-knowledge-base-segmentation-data-cleaning",
@@ -2337,6 +2338,28 @@ module.exports = {
                         ]
                     },
                     ],
+                    
+                    "/md/AI/agent/dify/": [{
+                        title: "快速上手",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "ai-agents-dont-security-nightmare",
+                            "improve-quality-gen-ai",
+                        ]
+                    },
+                    {
+                        title: "案例",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "changelog-cursor",
+                            "goodbye-cursor-hello-windsurf",
+                            "Junie",
+                            "introducing-codex",
+                        ]
+                    },
+                    ],
 
                     "/md/AI/mcp/": [{
                         title: "MCP",
diff --git a/docs/md/AI/03-core-of-rag-result-retrieval-and-reordering.md b/docs/md/AI/03-core-of-rag-result-retrieval-and-reordering.md
index 9a5d2ece9..a6309f820 100644
--- a/docs/md/AI/03-core-of-rag-result-retrieval-and-reordering.md
+++ b/docs/md/AI/03-core-of-rag-result-retrieval-and-reordering.md
@@ -116,31 +116,4 @@ Rerank：RAG中百尺竿头更进一步
 
 排序模型目的在于，对召回内容有更合理排序结果，减少提供给模型的上下文长度，长度越长，对模型压力越大。
 
-![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/974f3c64951c640dfd26adbf92ab2da1.png)
-
-基于Learning2Rank的思路提升文本语义排序效果：
-
-![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/46a36f3a3a9dc1600d21025080c63c3d.png)
-
-### Listwise的优化
-
-![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/d11518137f7d823c5e26a31246a45c06.png)
-
-指示函数做近似：
-
-![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/bc7a9bb034683c429a791e902c8b34b4.png)
-
-最终loss function：
-
-$$
-\begin{align*}
-\hat{\pi}(x) &= 1 + \sum_{y \in X, y \neq x} \frac{\exp(-\alpha s_{x,y})}{1 + \exp(-\alpha s_{x,y})} \\
-NDCG &= N_n^{-1} \sum_{x \in X} \frac{2^{r(x)} - 1}{\log_2(1 + \hat{\pi}(x))}
-\end{align*}
-$$
- 效果对比：
-
-| model                        | FAQ ACC@5 | 文档 ACC@5 | 混合数据 ACC@5 |
-| ---------------------------- | --------- | ---------- | -------------- |
-| bge-reranker-large(开源SOTA) | 90.26     | 75.98      | 77.17          |
-| Our Model                    | 93.76     | 83.20      | 81.21          |
\ No newline at end of file
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/974f3c64951c640dfd26adbf92ab2da1.png)
\ No newline at end of file
diff --git a/docs/md/AI/llm/configuring-models-in-dify.md b/docs/md/AI/llm/configuring-models-in-dify.md
new file mode 100644
index 000000000..170b0da02
--- /dev/null
+++ b/docs/md/AI/llm/configuring-models-in-dify.md
@@ -0,0 +1,91 @@
+# 接入大模型
+
+## 0 前言
+
+Dify 是基于大语言模型的 AI 应用开发平台，初次使用时你需要先在 Dify 的 **设置 -- 模型供应商** 页面内添加并配置所需要的模型:  
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/c95919356dc219d46368fa949caebb6b.png)
+
+
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/9186c0fc944a39fb95f969b8e1975c9c.png)
+
+Dify支持主流模型供应商，如OpenAI GPT系、Anthropic Claude系。不同模型能力表现、参数类型不一，据不同情景应用需求选择喜欢的模型供应商。在 Dify 应用模型能力前，应前往不同的模型厂商官方网站获得他们的 API key 。
+
+## 1 模型类型
+
+Dify按模型使用场景将模型分类：
+
+### 1.1 系统推理
+
+在创建的应用中，用的是该类型的模型。智聊、对话名称生成、下一步问题建议用的也是推理模型。
+
+> 已支持系统推理模型的供应商：[OpenAI](https://platform.openai.com/account/api-keys)、[Azure OpenAI Service](https://azure.microsoft.com/en-us/products/ai-services/openai-service/)、[Anthropic](https://console.anthropic.com/account/keys)、Hugging Face Hub、Replicate、Xinference、OpenLLM、[讯飞星火](https://www.xfyun.cn/solutions/xinghuoAPI)、[文心一言](https://console.bce.baidu.com/qianfan/ais/console/applicationConsole/application)、[通义千问](https://dashscope.console.aliyun.com/api-key\_management?spm=a2c4g.11186623.0.0.3bbc424dxZms9k)、[Minimax](https://api.minimax.chat/user-center/basic-information/interface-key)、ZHIPU(ChatGLM)
+
+### 1.2 Embedding
+
+知识库应用中：
+
+- 将分段过的文档做 Embedding
+- 将用户的提问做 Embedding 处理
+
+> 已支持的 Embedding 模型供应商：OpenAI、ZHIPU(ChatGLM)、Jina AI([Jina Embeddings](https://jina.ai/embeddings/))
+
+### 1.3 Rerank
+
+为增强检索能力，改善 LLM 搜索结果。
+
+> 已支持的 Rerank 模型供应商：Cohere、Jina AI([Jina Reranker](https://jina.ai/reranker))
+
+### 1.4 语音转文字
+
+将对话型应用中，将语音转文字用的是该类型的模型。
+
+> 已支持的语音转文字模型供应商：OpenAI
+
+### 1.5 托管模型试用服务
+
+为 Dify 云服务的用户提供了不同模型的试用额度，请在该额度耗尽前设置你自己的模型供应商，否则将会影响应用的正常使用。
+
+* **OpenAI 托管模型试用：** 我们提供 200 次调用次数供你试用体验，可用于 GPT3.5-turbo、GPT3.5-turbo-16k、text-davinci-003 模型。
+
+### 设置默认模型
+
+Dify 在需要模型时，会根据使用场景来选择设置过的默认模型。在 `设置 > 模型供应商` 中设置默认模型。
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/c679cdb6308534018494bb76ace549ae.png)
+
+系统默认推理模型：设置创建应用使用的默认推理模型,以及对话名称生成、下一步问题建议等功能也会使用该默认推理模型。
+
+## 2 接入模型设置
+
+在 Dify 的 `设置 > 模型供应商` 中设置要接入的模型。
+
+模型供应商分为两种：
+
+### 2.1 自有模型
+
+该类型的模型供应商提供的是自己开发的模型。如 OpenAI，Anthropic 等。
+
+接入自有模型的供应商后，Dify 会自动接入该供应商下的所有模型。
+
+在 Dify 中设置对应模型供应商的 API key，即可接入该模型供应商。
+
+> Dify 使用了 [PKCS1\_OAEP](https://pycryptodome.readthedocs.io/en/latest/src/cipher/oaep.html) 来加密存储用户托管的 API 密钥，每个租户均使用了独立的密钥对进行加密，确保你的 API 密钥不被泄漏。
+
+### 2.2 托管模型
+
+该类型的模型供应商提供的是第三方模型。如 Hugging Face，Replicate 等。
+
+托管类型的供应商上面有很多第三方模型。接入模型需要一个个的添加。具体接入方式如下：
+
+* [Hugging Face](../../development/models-integration/hugging-face.md)
+* [Replicate](../../development/models-integration/replicate.md)
+* [Xinference](../../development/models-integration/xinference.md)
+* [OpenLLM](../../development/models-integration/openllm.md)
+
+## 3 使用模型
+
+配置完模型后，就可以在应用中使用这些模型了：
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2025/02/c55e9ca6059b84da51ee9d246493d977.png)
\ No newline at end of file

From 7ff45781c88c1074a97b1351c8da8afc98b3bcfb Mon Sep 17 00:00:00 2001
From: JavaEdge <sss2855845850@gmail.com>
Date: Fri, 4 Jul 2025 16:00:22 +0800
Subject: [PATCH 20/20] =?UTF-8?q?docs:=E6=96=B0=E5=A2=9E=E6=96=87=E7=AB=A0?=
 =?UTF-8?q?=E4=B8=93=E6=A0=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/.vuepress/config.js                      | 103 ++-
 ...a2a-a-new-era-of-agent-interoperability.md | 288 +++++++
 .../AI/{llm => agent}/Build-App-with-Dify.md  |   0
 ...workflow-resilience-with-error-handling.md |   0
 .../configuring-models-in-dify.md             |   0
 ...ent-and-zapier-mcp-unlock-ai-automation.md |   0
 ...mented-search-unlock-ai-driven-insights.md |   0
 ...1-0-building-a-vibrant-plugin-ecosystem.md |   0
 ...edge-retrieval-with-customized-metadata.md |   0
 docs/md/AI/agent/perplexity-labs.md           |  37 +
 docs/md/AI/{llm => agent}/what-is-llmops.md   |   0
 docs/md/AI/agent/windsurf-update.md           | 745 ++++++++++++++++++
 ...rsing-and-chunking-in-open-source-tools.md | 102 +++
 docs/md/AI/llm/cuda.md                        | 230 ++++++
 docs/md/AI/llm/gpullama3-java-gpu-llm.md      |  70 ++
 docs/md/AI/llm/inference-engine.md            | 184 +++++
 docs/md/AI/llm/memory-faq.md                  | 133 ++++
 docs/md/AI/llm/qwen3-embedding.md             |  61 ++
 ...are-parsefrom-mqtt-protobuf-consumption.md | 322 ++++++++
 ...kafka-iot-message-streaming-integration.md |   0
 .../md/MQTT/mqtt-publish-subscribe-intro.md   |   0
 ...00\346\234\257\345\216\237\347\220\206.md" | 259 ++++++
 docs/md/design/open-close-principle.md        | 349 ++++++++
 .../md/java/Java16-new-features.md            |   0
 .../md/java/Java21-new-features.md            |   0
 .../md/java/Java22-new-features.md            |   0
 .../md/java/Java23-new-features.md            |   0
 .../md/java/Java9-new-features.md             |   0
 docs/md/java/java-news-roundup-jun02-2025.md  | 126 +++
 ...g-adminclient-principles-and-practices.md} | 100 +--
 .../mysql-transaction-isolation-mechanism.md  | 497 ++++++++++++
 ...mize-slow-queries-massive-row-deletions.md | 105 +++
 ...-solve-high-cpu-usage-in-tomcat-process.md |  21 +-
 33 files changed, 3657 insertions(+), 75 deletions(-)
 create mode 100644 docs/md/AI/a2a/a2a-a-new-era-of-agent-interoperability.md
 rename docs/md/AI/{llm => agent}/Build-App-with-Dify.md (100%)
 rename docs/md/AI/{llm => agent}/boost-ai-workflow-resilience-with-error-handling.md (100%)
 rename docs/md/AI/{llm => agent}/configuring-models-in-dify.md (100%)
 rename docs/md/AI/{llm => agent}/dify-agent-and-zapier-mcp-unlock-ai-automation.md (100%)
 rename docs/md/AI/{llm => agent}/dify-deep-research-workflow-farewell-to-fragmented-search-unlock-ai-driven-insights.md (100%)
 rename docs/md/AI/{llm => agent}/dify-v1-0-building-a-vibrant-plugin-ecosystem.md (100%)
 create mode 100644 docs/md/AI/agent/dify-v1-1-0-filtering-knowledge-retrieval-with-customized-metadata.md
 create mode 100644 docs/md/AI/agent/perplexity-labs.md
 rename docs/md/AI/{llm => agent}/what-is-llmops.md (100%)
 create mode 100644 docs/md/AI/agent/windsurf-update.md
 create mode 100644 docs/md/AI/document-parsing-and-chunking-in-open-source-tools.md
 create mode 100644 docs/md/AI/llm/cuda.md
 create mode 100644 docs/md/AI/llm/gpullama3-java-gpu-llm.md
 create mode 100644 docs/md/AI/llm/inference-engine.md
 create mode 100644 docs/md/AI/llm/memory-faq.md
 create mode 100644 docs/md/AI/llm/qwen3-embedding.md
 create mode 100644 docs/md/MQTT/avoid-bare-parsefrom-mqtt-protobuf-consumption.md
 rename "docs/md/mqtt/MQTT\344\270\216Kafka\345\234\250\347\211\251\350\201\224\347\275\221\346\266\210\346\201\257\344\270\216\346\265\201\346\225\260\346\215\256\351\233\206\346\210\220\345\256\236\350\267\265.md" => docs/md/MQTT/mqtt-kafka-iot-message-streaming-integration.md (100%)
 rename "docs/md/MQTT/07-MQTT\345\217\221\345\270\203\350\256\242\351\230\205\346\250\241\345\274\217\344\273\213\347\273\215.md" => docs/md/MQTT/mqtt-publish-subscribe-intro.md (100%)
 create mode 100644 "docs/md/chain/\351\232\220\347\247\201\350\256\241\347\256\227\346\212\200\346\234\257\345\216\237\347\220\206.md"
 create mode 100644 docs/md/design/open-close-principle.md
 rename "docs/md/java/JDK16\346\226\260\347\211\271\346\200\247.md" => docs/md/java/Java16-new-features.md (100%)
 rename "docs/md/java/JDK21\346\226\260\347\211\271\346\200\247.md" => docs/md/java/Java21-new-features.md (100%)
 rename "docs/md/java/JDK22\346\226\260\347\211\271\346\200\247.md" => docs/md/java/Java22-new-features.md (100%)
 rename "docs/md/java/JDK23\346\226\260\347\211\271\346\200\247.md" => docs/md/java/Java23-new-features.md (100%)
 rename "docs/md/java/Java9\346\226\260\347\211\271\346\200\247\346\246\202\350\277\260.md" => docs/md/java/Java9-new-features.md (100%)
 create mode 100644 docs/md/java/java-news-roundup-jun02-2025.md
 rename docs/md/kafka/{13-KafkaAdminClient.md => kafka-operations-tool-exploring-adminclient-principles-and-practices.md} (50%)
 create mode 100644 docs/md/mysql/mysql-transaction-isolation-mechanism.md
 create mode 100644 docs/md/mysql/optimize-slow-queries-massive-row-deletions.md
 rename "docs/md/tomcat/Tomcat\350\277\233\347\250\213\345\215\240\347\224\250CPU\350\277\207\351\253\230\346\200\216\344\271\210\345\212\236\357\274\237.md" => docs/md/tomcat/how-to-solve-high-cpu-usage-in-tomcat-process.md (86%)

diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index f97454f80..789446806 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -751,10 +751,6 @@ module.exports = {
                         text: 'LangChain4j',
                         link: '/md/AI/langchain4j/01-intro'
                     },
-                    {
-                        text: 'MCP',
-                        link: '/md/AI/mcp/mcp-fad-or-fixture'
-                    },
                     {
                         text: '大模型发展',
                         link: '/md/AI/llm/GPTs'
@@ -767,6 +763,14 @@ module.exports = {
                         text: 'AI Agent',
                         link: '/md/AI/agent/changelog-cursor'
                     },
+                    {
+                        text: 'MCP',
+                        link: '/md/AI/mcp/mcp-fad-or-fixture'
+                    },
+                    {
+                        text: 'A2A',
+                        link: '/md/AI/a2a/a2a-a-new-era-of-agent-interoperability'
+                    },
                     ]
                 },
 
@@ -796,6 +800,11 @@ module.exports = {
                         text: '以太坊区块链',
                         link: '/md/chain/01-以太坊智能合约与高级语言.md'
                     },
+                    
+                    {
+                        text: '隐私计算',
+                        link: '/md/chain/隐私计算技术原理.md'
+                    },
 
                     ]
                 },
@@ -1179,8 +1188,9 @@ module.exports = {
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "MQTT与Kafka在物联网消息与流数据集成实践",
-                            "07-MQTT发布订阅模式介绍"
+                            "mqtt-kafka-iot-message-streaming-integration",
+                            "mqtt-publish-subscribe-intro",
+                            "avoid-bare-parsefrom-mqtt-protobuf-consumption",
                         ]
                     }],
 
@@ -1246,15 +1256,16 @@ module.exports = {
                         sidebarDepth: 0,
                         children: [
                             "java-se-support-roadmap",
-                            "Java9新特性概述",
+                            "Java9-new-features",
                             "jdk14-new-features-complete-guide",
-                            "JDK16新特性",
+                            "Java16-new-features",
                             "understanding-java17-new-features-sealed-classes",
-                            "JDK21新特性",
-                            "JDK22新特性",
-                            "JDK23新特性",
+                            "Java21-new-features",
+                            "Java22-new-features",
+                            "Java23-new-features",
                             "java24-new-features",
                             "java2024",
+                            "java-news-roundup-jun02-2025",
                         ]
                     },
 
@@ -1397,7 +1408,7 @@ module.exports = {
                             "03-Tomcat的生命周期管理",
                             "04-Tomcat实现热部署、热加载原理解析",
                             "05-Tomcat如何打破双亲委派机制实现隔离Web应用的？",
-                            "Tomcat进程占用CPU过高怎么办？",
+                            "how-to-solve-high-cpu-usage-in-tomcat-process",
                         ]
                     }],
 
@@ -1501,6 +1512,7 @@ module.exports = {
                             "为什么临时表可以重名？",
                             "为什么阿里不推荐使用MySQL分区表？",
                             "一文看懂这篇MySQL的锁机制",
+                            "mysql-transaction-isolation-mechanism",
                         ]
                     },
 
@@ -1515,6 +1527,7 @@ module.exports = {
                             "MySQL查询优化",
                             "MySQL深分页调优实战",
                             "online-sql-deadlock-incident-how-to-prevent-deadlocks",
+                            "optimize-slow-queries-massive-row-deletions",
                         ]
                     },
 
@@ -1542,7 +1555,7 @@ module.exports = {
                             "05-流式操作：如何使用 Flux 和 Mono 高效构建响应式数据流？",
                         ]
                     }],
-                    
+
                     "/md/sentinel/": [{
                         title: "Sentinel基础",
                         collapsable: false,
@@ -1682,7 +1695,7 @@ module.exports = {
                             "Kafka门派知多少",
                             "08-全网最全图解Kafka适用场景",
                             "09-消息队列的消息大量积压怎么办？",
-                            "13-KafkaAdminClient",
+                            "kafka-operations-tool-exploring-adminclient-principles-and-practices",
                             "15-基于kafka实现延迟队列",
                             "kafka-transaction-implementation",
                             "kafka-versions",
@@ -2153,10 +2166,21 @@ module.exports = {
                             "lm-studio-transform-mac-into-ai-tool",
                             "navigating-llm-deployment-tips-tricks-and-techniques",
                             "only-ai-flow-can-do",
-                            "chatgpt-canva",
                             "llm-reasoning-limitations",
                             "making-an-llm-that-sees-and-reasons",
                             "lmstudio-local-llm-call",
+                            "inference-engine",
+                            "cuda",
+                            "gpullama3-java-gpu-llm",
+                        ]
+                    },
+                    {
+                        title: "ChatGPT",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "chatgpt-canva",
+                            "memory-faq",
                         ]
                     },
                     {
@@ -2214,6 +2238,7 @@ module.exports = {
                             "boost-ai-workflow-resilience-with-error-handling",
                             "introducing-parent-child-retrieval-for-enhanced-knowledge",
                             "dify-v1-0-building-a-vibrant-plugin-ecosystem",
+                            "dify-v1-1-0-filtering-knowledge-retrieval-with-customized-metadata",
                             "dify-deep-research-workflow-farewell-to-fragmented-search-unlock-ai-driven-insights",
                             "dify-agent-and-zapier-mcp-unlock-ai-automation",
                         ]
@@ -2327,29 +2352,37 @@ module.exports = {
                         ]
                     },
                     {
-                        title: "辅助编程",
+                        title: "cursor",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
                             "changelog-cursor",
+                        ]
+                    },
+
+                    {
+                        title: "windsurf",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
                             "goodbye-cursor-hello-windsurf",
-                            "Junie",
-                            "introducing-codex",
+                            "windsurf-update",
                         ]
                     },
-                    ],
-                    
-                    "/md/AI/agent/dify/": [{
-                        title: "快速上手",
+                    {
+                        title: "Dify基础",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
-                            "ai-agents-dont-security-nightmare",
-                            "improve-quality-gen-ai",
+                            "what-is-llmops",
+                            "configuring-models-in-dify",
+                            "Build-App-with-Dify",
+                            "integrate-dify-and-aws-services-to-enable-more-flexible-translation-workflows",
+                            "llm-knowledge-base-segmentation-data-cleaning",
                         ]
                     },
                     {
-                        title: "案例",
+                        title: "Dify案例",
                         collapsable: false,
                         sidebarDepth: 0,
                         children: [
@@ -2359,6 +2392,15 @@ module.exports = {
                             "introducing-codex",
                         ]
                     },
+
+                    {
+                        title: "Perplexity",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "perplexity-labs",
+                        ]
+                    },
                     ],
 
                     "/md/AI/mcp/": [{
@@ -2381,6 +2423,16 @@ module.exports = {
                     },
                     ],
 
+                    "/md/AI/a2a/": [{
+                        title: "A2A",
+                        collapsable: false,
+                        sidebarDepth: 0,
+                        children: [
+                            "a2a-a-new-era-of-agent-interoperability",
+                        ]
+                    },
+                    ],
+
                     "/md/AI/spring-ai-alibaba/": [{
                         title: "Spring AI Alibaba",
                         collapsable: false,
@@ -2529,6 +2581,7 @@ module.exports = {
                         sidebarDepth: 0,
                         children: [
                             "01-单一职责原则",
+                            "open-close-principle",
                             "rest-api-design-resource-modeling",
                         ]
                     },
diff --git a/docs/md/AI/a2a/a2a-a-new-era-of-agent-interoperability.md b/docs/md/AI/a2a/a2a-a-new-era-of-agent-interoperability.md
new file mode 100644
index 000000000..47271d5f0
--- /dev/null
+++ b/docs/md/AI/a2a/a2a-a-new-era-of-agent-interoperability.md
@@ -0,0 +1,288 @@
+# Agent2Agent (A2A) 协议发布
+
+![](https://p.ipic.vip/95frfl.jpg)
+
+## 1 智能体互操作性的新时代
+
+通过自主处理大量日常重复性或复杂性任务，AI智能体为提高人们工作效率带来独特机遇。如今，企业正在构建和部署越来越多的自主智能体，以便扩展、自动化和改进工作场所的各种流程，如订购新笔记本电脑、协助客户服务代表和协助供应链规划。
+
+为最大限度发挥智能体 AI 优势，这些智能体须能在横跨孤立数据系统和应用程序的动态、多智能体生态系统中协作。即使智能体由不同供应商构建或在不同的框架中构建，也能实现智能体之间的互操作性，这将提高自主性并成倍提高生产力，同时降低长期成本。
+
+今天，Google发布Agent2Agent (A2A) 全新开放协议，Atlassian、Box、Cohere、Intuit、Langchain、MongoDB、PayPal、Salesforce、SAP、ServiceNow、UKG 和 Workday 等 50 多家技术合作伙伴及埃森哲、BCG、Capgemini、Cognizant、德勤、HCLTech、Infosys、毕马威、麦肯锡、普华永道、TCS 和 Wipro 等领先服务提供商均支持。
+
+凭借 A2A 协议，AI 智能体能在各种企业平台或应用程序之上相互通信、安全交换信息和协调操作。A2A 框架将为客户创造巨大的价值，他们的 AI 智能体将服务于整个企业的各类应用程序资产。
+
+这种协作努力体现人们对未来的共同愿景，即无论底层技术如何，AI 智能体都能无缝协作，以自动化复杂企业工作流程，推动效率与创新达到前所未有的高度。
+
+A2A 是一个开放协议，是对MCP的补充，MCP为智能体提供了有用的工具和上下文。借鉴 Google 在扩展智能体系统方面的内部专业知识，我们设计了 A2A 协议，以应对我们在为客户部署大规模、多智能体系统时遇到的挑战。借助 A2A 协议，开发者可以构建能够与使用该协议构建的任何其他智能体建立连接的智能体，让用户能够灵活地组合来自各种提供商的智能体。至关重要的是，企业可以受益于这种标准化方法，跨不同平台和云环境管理其智能体。我们相信，这种通用的互操作性对于充分发挥协作 AI 智能体的潜力至关重要。
+
+![](https://p.ipic.vip/dipy89.png)
+
+## 2 A2A设计原则
+
+A2A 是一种开放协议，提供了一种让智能体相互协作的标准方式，无论其底层框架或供应商是什么。与合作伙伴一起设计该协议时，坚持五大关键原则：
+
+- 拥抱智能体能力：A2A聚焦于让智能体以其自然、非结构化的方式进行协作，即使彼此没有共享内存、工具和上下文，也能高效协作。我们将实现真正的多智能体场景，不再将智能体仅仅看作是“工具”
+
+- 依托现有标准构建：该协议是基于 HTTP、SSE、JSON-RPC等当下主流标准构建而成，即其能更轻松与企业当前日常使用的 IT 堆栈进行集成
+
+- 默认安全：A2A旨在支持企业级身份验证和授权，并在发布时与 OpenAPI 的身份验证方案保持对等
+
+- 支持长时间运行的任务：A2A非常灵活，支持各种场景，可出色完成从快速任务到深入研究（在有人类参与时，可能需数小时甚至数天时间才能完成）的所有任务。在整个过程中，A2A 可以向用户提供实时反馈、通知和状态更新
+
+- 模式不受限：智能体世界不仅限于文本，这就是为什么我们将 A2A 设计为支持各种模式，包括音频和视频流
+
+## 3 A2A工作原理
+
+一个说明远程Agent和客户端Agent之间数据流的插图流程图，以产生安全协作、任务和状态管理、用户体验协商及能力发现 
+
+![](https://p.ipic.vip/ngue0z.png)
+
+A2A方便了“客户端”智能体与“远程”智能体之间的通信。客户端智能体负责制定和传达任务，而远程智能体负责执行这些任务，力图提供正确的信息或采取正确的行动。这种交互涉及几个关键功能：
+
+- 能力发现：智能体可用 JSON 格式“智能体卡”来宣传其能力，使客户端智能体能识别出能执行任务的最佳智能体，并利用 A2A 与远程智能体进行通信
+
+- 任务管理：客户端智能体与远程智能体之间的通信以完成任务为导向，智能体在其中努力完成最终用户的请求。该“任务”对象由协议定义，且具有生命周期。任务可立即完成，而长时间运行的任务，每个智能体都可进行通信，以便彼此之间保持同步，了解任务完成情况的最新状态。任务的输出被称为“工件”
+
+- 协作：智能体可相互发送信息，交流上下文、回复、工件或用户指令
+
+- 用户体验协商：每条消息都包含“部件”，“部件”是一个完整的内容片段，如生成的图像。每个部件都有指定的内容类型，允许客户端和远程智能体协商所需的正确格式，并明确包括用户界面功能的协商，如 iframe、视频、网页表单等
+
+参阅[规范草案](https://github.com/google/A2A)，了解协议工作原理的完整细节。
+
+## 3 真实案例：搜寻候选人
+
+通过 A2A 协作，可大大简化软件工程师招聘过程。在 Agentspace 这样的统一界面中，用户（如招聘经理）可以要求其智能体寻找符合职位列表、地点和技能组合的候选人。然后，智能体与其他专业智能体互动，寻找潜在的候选人。用户收到这些建议后，可指示其智能体安排进一步面试，简化候选人搜寻流程。面试流程结束后，还可让另一个智能体协助背调。这这只是 AI 智能体需要跨系统协作以寻找合格求职者的一个示例。
+
+##  4 智能体互操作性的未来
+
+A2A有望开启智能体互操作性的新时代，推动创新浪潮，构建功能更强大、用途更广泛的智能体系统。我们坚信，该协议将为未来智能体发展奠定基础，促使智能体无缝协作以攻克复杂难题，提升我们生活品质。
+
+致力于与合作伙伴和社区公开合作构建该协议。开源方式发布该协议，并建立明确贡献途径。可在 [A2A 网站](https://google.github.io/A2A)查看[完整版规范草案](https://github.com/google/A2A)、试用代码示例和查看示例场景，并了解贡献方式。
+
+正与合作伙伴合作，计划今年晚些推出可用于生产的协议版本。
+
+## 5 A2A技术合作伙伴反馈
+
+### ask-ai.com
+
+> Ask-AI 很高兴与 Google 合作开发 A2A 协议，共同塑造 AI 互操作性和无缝智能体协作的未来，从而提升其在企业 AI 客户体验领域的领导地位。
+> ——Alon Talmor 博士，首席执行官
+
+### Atlassian
+
+> 凭借 Atlassian 对 Rovo 智能体的投资，像 A2A 这样的标准化协议的开发将帮助智能体成功地发现、协调和推理彼此，从而实现更丰富的授权和大规模协作形式。
+> ——Brendan Haire，Atlassian 的 AI 平台工程副总裁
+
+### Articul8
+
+> 在 Articul8，我们认为 AI 必须协作和互操作，才能真正跨企业扩展。我们很高兴支持 A2A 互操作性协议的开发，该计划与我们提供跨复杂系统和工作流程无缝运行的特定领域 GenAI 功能的使命完美契合。我们正在使 Articul8 的 ModelMesh（“智能体中的智能体”）将 A2A 视为一等公民，从而实现智能智能体之间的安全、无缝通信。
+> —— Arun Subramaniyan，Articul8 创始人兼首席执行官
+
+### Arize AI
+
+> Arize AI很荣幸与 Google 合作，成为 A2A 互操作性协议的产品发布合作伙伴，从而推进跨 AI 智能体的无缝、安全交互，这是 Arize 对开源评估和可观测性框架立场承诺的一部分。
+> ——Jason Lopatecki，Arize AI 联合创始人兼首席执行官
+
+### BCG
+
+> BCG 帮助重新设计以智能为核心的组织。像 A2A 这样开放和可互操作的功能可以加速这一进程，从而实现可持续的、自主的竞争优势。
+> —— *Djon Kleine，BCG 合伙人兼总经理*
+
+### Box
+
+> 我们期待扩大与 Google 的合作，使 Box 智能体能够使用 A2A 与 Google Cloud 的智能体生态系统协同工作，共同创新以塑造 AI 智能体的未来，同时使组织能够更好地自动化工作流程、降低成本并生成值得信赖的 AI 输出。*
+> ——Ketan Kittur，Box 的产品管理、平台和集成副总裁*
+
+### **C3 AI**
+
+> 在 C3 AI，我们认为开放、可互操作的系统是使企业 AI 在现实世界发挥作用和创造价值的关键，A2A 有潜力帮助客户打破孤岛，并安全地使 AI 智能体在系统、团队和应用程序之间协同工作。
+> —— *Nikhil Krishnan，C3 AI 高级副总裁兼负责数据科学的首席技术官*
+
+### **Chronosphere**
+
+> A2A 将支持可靠且安全的智能体专业化和协调，为计算编排的新时代打开大门，使公司能够更快、更可靠地交付产品和服务，并使他们能够将工程工作重点放在推动创新和创造价值上。*
+> ——Rob Skillington，创始人兼首席技术官*
+
+### **Cognizant**
+
+> “作为企业多智能体系统的先驱，Cognizant 致力于实现智能体互操作性，并主动将其视作我们客户的关键要求。”
+> —— *Babak Hodjat，AI 首席技术官*
+
+### **Cohere**
+
+> 在 Cohere，我们正在构建企业放心地采用自主智能体所需的安全 AI 基础设施，而开放的 A2A 协议可确保即使在气隙环境中也能实现无缝、可信的协作，使企业能够在不影响控制或合规性的情况下进行大规模创新。*
+> ——Autumn Moulder，Cohere 工程副总裁*
+
+### **Confluent**
+
+> A2A 使智能智能体能够建立直接、实时的数据交换，简化复杂的数据管道，从根本上改变智能体的通信方式并促进决策。*
+> ——Pascal Vantrepote，Confluent 创新高级总监*
+
+### **Cotality（原 CoreLogic）**
+
+> A2A 为智能、实时通信和协作的新时代打开了大门，Cotality 将其带给房屋贷款、保险、房地产和政府领域的客户，帮助他们提高生产力，加快决策速度。*
+> ——Sachin Rajpal，Cotality 数据解决方案总经理*
+
+### **DataStax**
+
+> DataStax 很高兴能成为 A2A 的一部分，并探索如何利用它为 Langflow 提供支持，这是迈向真正可互操作的 AI 系统的重要一步，这些系统可以协作完成跨多个环境的复杂任务。*
+> ——Ed Anuff，DataStax 首席产品官*
+
+### **Datadog**
+
+> 我们很高兴看到 Google Cloud 推出 A2A 协议，以简化复杂智能体系统的开发，这将帮助 Datadog 使其用户能够构建更具创新性、更优的和更安全的智能体 AI 应用程序。*
+> ——Yrieix Garnier，Datadog 产品副总裁*
+
+### **Elastic**
+
+> Elastic 支持开放、可互操作的智能体生态系统这一愿景，期待与 Google Cloud 和其他行业领导者合作开发 A2A，并提供其数据管理和工作流程编排经验来改进该协议。*
+> ——Steve Kearns，Elastic 副总裁兼搜索业务总经理*
+
+### **GrowthLoop**
+
+> A2A 有潜力加速 GrowthLoop 为我们的客户实现复合营销的愿景——使我们的 AI 智能体能够与其他专业智能体无缝协作，更快地从企业数据中学习，并快速优化整个营销生态系统中的活动，同时尊重客户云基础设施上的数据隐私。*
+> ——Anthony Rotio，GrowthLoop 首席数据战略官*
+
+### **Harness**
+
+> Harness 很高兴支持 A2A，并致力于通过将 AI 驱动的智能集成到软件生命周期的每个阶段来简化开发者体验，从而使团队能够从运行时数据中获得更深入的见解，自动化复杂的工作流程，提高系统性能。*
+> ——Gurashish Brar，Harness 工程主管*
+
+### **Incorta**
+
+> Incorta 很高兴支持 A2A 并推进客户的智能体通信，使未来的企业自动化更智能、更快速，并真正实现数据驱动。*
+> ——Osama Elkady，Incorta 首席执行官*
+
+### **Intuit**
+
+> Intuit 坚信，像 A2A 这样的开源协议将支持复杂的智能体工作流程，加速我们的合作伙伴集成，并通过有效协作的跨平台智能体推动行业向前发展。*
+> ——Tapasvi Moturu，Intuit 的智能体框架软件工程副总裁*
+
+### **JetBrains**
+
+> 我们很高兴成为 A2A 的产品发布合作伙伴，该计划增强了智能体协作，使我们更接近真正的多智能体世界，为 JetBrains IDE、团队工具和 Google Cloud 的开发者赋能。*
+> ——Vladislav Tankov，JetBrains 的 AI 总监*
+
+### **JFrog**
+
+> JFrog 很高兴加入 A2A 协议，我们认为该计划将有助于克服当今的许多集成挑战，并将成为新一代智能体应用程序的关键驱动力。*
+> ——Yoav Landman，JFrog 首席技术官兼联合创始人*
+
+### **LabelBox**
+
+> A2A 是充分发挥 AI 智能体潜力的关键一步，它支持 AI 真正增强人类能力、实现复杂工作流程自动化和推动创新的未来。*
+> ——创始人兼首席执行官 Manu Sharma*
+
+### **LangChain**
+
+> LangChain 认为，智能体与其他智能体交互是指日可待的未来，我们很高兴与 Google Cloud 合作，提出一个满足智能体构建者和用户需求的共享协议。*
+> ——Harrison Chase，LangChain 联合创始人兼首席执行官*
+
+### **MongoDB**
+
+> 通过将 MongoDB 强大的数据库基础设施和混合搜索功能与 A2A 和 Google Cloud 的前沿 AI 模型相结合，企业可以释放零售、制造等行业的新可能性，从而重新定义 AI 应用程序的未来。*
+> ——Andrew Davidson，MongoDB 产品高级副总裁*
+
+### **Neo4j**
+
+> Neo4j 很荣幸与 Google Cloud 合作，将我们的图技术知识图谱和 GraphRAG 功能与 A2A 相结合，帮助组织释放新的自动化和智能水平，同时确保智能体交互在上下文中保持相关、可解释和值得信赖。*
+> ——Sudhir Hasbe，Neo4j 首席产品官*
+
+### **New Relic**
+
+> 我们相信，Google Cloud 的 A2A 协议与 New Relic 的智能可观测性平台之间的协作，将通过简化集成、促进跨不同系统的数据交换，并最终创建一个更统一的 AI 智能体生态系统，为我们的客户提供显著价值。*
+> ——Thomas Lloyd，New Relic 首席业务和运营官*
+
+### **Pendo**
+
+> 我们很荣幸与 Google Cloud 的 A2A 协议合作，这将是使 AI 智能体能够有效协同工作，同时保持大规模信任和可用性的关键一步。
+> —— *Rahul Jain，Pendo 联合创始人兼首席产品官*
+
+### **PayPal**
+
+> PayPal 支持 Google Cloud 的 A2A 协议，这代表着开发者和商家创建由智能体 AI 驱动的新一代商业体验的新方式。*
+> ——Prakhar Mehrotra，PayPal 高级副总裁兼人工智能主管*
+
+### **普华永道**
+
+> 在普华永道，我们相信企业 AI 的未来在于无缝协作，它不仅仅是人员和系统之间的协作，还有智能体之间的协作；因此，我们很荣幸能与普华永道的智能体操作系统协作支持 A2A，帮助制定企业级的安全、可扩展的智能体互操作性标准。
+> —— *Dallas Dolen，全球 Google Cloud 联盟负责人*
+
+### **SAP**
+
+> SAP 致力于与 Google Cloud 和更广泛的生态系统合作，通过 A2A 协议塑造智能体互操作性的未来，这是使 SAP Joule 和其他 AI 智能体能够跨企业平台无缝协作，并释放端到端业务流程的全部潜力的关键一步。*
+> ——Walter Sun，高级副总裁兼 AI 工程全球主管*
+
+### **Salesforce**
+
+> Salesforce 正在率先支持 A2A 标准，以扩展我们的开放平台，使 AI 智能体能够在 Agentforce 和其他生态系统中无缝协作，将脱节的功能转化为精心设计的解决方案，并为客户和员工提供增强的数字化劳动力。*
+> ——产品架构副总裁 Gary Lerhaupt*
+
+### **ServiceNow**
+
+> ServiceNow 和 Google Cloud 正在合作，为智能体间互操作性设定新的行业标准，我们相信 A2A 将为更高效、更互联的支持体验奠定基础。*
+> ——Pat Casey，ServiceNow 的首席技术官兼 DevOps 执行副总裁*
+
+### **Supertab**
+
+> 借助 Google Cloud 的 A2A 协议和 Supertab Connect，智能体将能够像人类企业一样支付服务费用、收取服务费用和交换服务。*
+> ——Cosmin Ene，Supertab 创始人*
+
+### **UKG**
+
+> UKG 很高兴与 Google Cloud 合作开发新的 A2A 协议，该框架将使我们能够构建更智能、更具支持性的人力资本和劳动力体验，以前所未有的方式预测和响应员工需求。*
+> ——Eli Tsinovoi，UKG 的 AI 主管*
+
+### **Weights & Biases**
+
+> Weights & Biases 很荣幸与 Google Cloud 合作开发 A2A 协议，该协议设定了一个关键的开放标准，使组织能够放心地部署、编排和扩展各种 AI 智能体，而无需考虑底层技术。*
+> ——Shawn Lewis，Weights & Biases 首席技术官兼联合创始人*
+
+## 6 服务合作伙伴
+
+### **埃森哲**
+
+> Google Cloud 的多智能体 A2A 协议是将跨不同平台的特定领域智能体连接起来以应对复杂挑战的桥梁，从而实现无缝通信和集体智能，以实现更智能和更高效的智能体解决方案。*
+> ——Scott Alfieri，埃森哲 AGBG 全球负责人*
+
+### **德勤**
+
+> 智能体间互操作性是实现智能体 AI 架构演进的基础要素，Google Cloud 发起的 A2A 计划将技术行业参与者的生态系统凝聚到一起，共同开发和支持该协议，将极大地加速智能体 AI 的采用。*
+> ——德勤的 Gopal Srinivasan*
+
+### **EPAM**
+
+> 我们已经在 A2A 领域处于领先地位，专注于能产生实际商业价值的行业解决方案，此等价值包括节省时间、减少管理费用以及帮助客户增加收入和改进流程（如药物发现过程中 FDA 文件的编制）。*
+> ——Marc Cerro，EPAM 全球 Google Cloud 合作伙伴副总裁*
+
+### **HCLTech**
+
+> HCLTech 处于智能体企业的前沿，我们很荣幸与 Google Cloud 合作，通过开放的 A2A 标准定义智能体间互操作性并推进智能体 AI 的可能性。*
+> ——Vijay Guntur，HCLTech 首席技术官兼生态系统主管*
+
+### **毕马威**
+
+> 毕马威很高兴能参与这项新兴计划，因为 A2A 提供了不同 AI 智能体真正有效和负责任地协作所需的基本标准，借助该标准，客户和企业可以无缝地利用 AI 来实现创新和效率提升。*
+> ——Sherif AbdElGawad，毕马威的合伙人兼 Google Cloud 和 AI 负责人*
+
+**Quantiphi**
+
+> 智能体动态发现功能并打造跨平台用户体验的能力对于释放企业的真正潜力至关重要。我们认为 A2A 协议是支持企业构建此类可互操作智能体的关键一步。*
+> ——Asif Hasan，Quantiphi 联合创始人*
+
+### **塔塔咨询服务公司 (TCS)**
+
+> A2A 协议为智能体自动化新时代奠定了基础，语义互操作性在新时代占据突出地位，我们很荣幸能够引领这一变革之旅。*
+> ——Anupam Singhal，TCS 主管制造业务的总裁*
+
+### **Wipro**
+
+> 因为 AI 的未来在于无缝协作，所以像 A2A 这样的开放协议将成为 AI 智能体大规模推动创新的生态系统的基础。*
+> ——Nagendra P Bandaru，Wipro 管理合伙人兼技术服务全球主管*
+
+##  7 详细了解A2A
+
+要了解有关 A2A框架更多信息，仔细研读[**完整规范草案**](https://github.com/google/A2A)，并探索[**可用的代码示例**](https://google.github.io/A2A)，以根据其代码检查该协议的结构实验。
+
+[提交想法](https://docs.google.com/forms/d/e/1FAIpQLScS23OMSKnVFmYeqS2dP7dxY3eTyT7lmtGLUa8OJZfP4RTijQ/viewform)、[贡献文档](https://github.com/google/A2A/blob/main/CONTRIBUTING.md)以及与社区互动，为协议的演进做出贡献，一起定义智能体互操作性的未来。
\ No newline at end of file
diff --git a/docs/md/AI/llm/Build-App-with-Dify.md b/docs/md/AI/agent/Build-App-with-Dify.md
similarity index 100%
rename from docs/md/AI/llm/Build-App-with-Dify.md
rename to docs/md/AI/agent/Build-App-with-Dify.md
diff --git a/docs/md/AI/llm/boost-ai-workflow-resilience-with-error-handling.md b/docs/md/AI/agent/boost-ai-workflow-resilience-with-error-handling.md
similarity index 100%
rename from docs/md/AI/llm/boost-ai-workflow-resilience-with-error-handling.md
rename to docs/md/AI/agent/boost-ai-workflow-resilience-with-error-handling.md
diff --git a/docs/md/AI/llm/configuring-models-in-dify.md b/docs/md/AI/agent/configuring-models-in-dify.md
similarity index 100%
rename from docs/md/AI/llm/configuring-models-in-dify.md
rename to docs/md/AI/agent/configuring-models-in-dify.md
diff --git a/docs/md/AI/llm/dify-agent-and-zapier-mcp-unlock-ai-automation.md b/docs/md/AI/agent/dify-agent-and-zapier-mcp-unlock-ai-automation.md
similarity index 100%
rename from docs/md/AI/llm/dify-agent-and-zapier-mcp-unlock-ai-automation.md
rename to docs/md/AI/agent/dify-agent-and-zapier-mcp-unlock-ai-automation.md
diff --git a/docs/md/AI/llm/dify-deep-research-workflow-farewell-to-fragmented-search-unlock-ai-driven-insights.md b/docs/md/AI/agent/dify-deep-research-workflow-farewell-to-fragmented-search-unlock-ai-driven-insights.md
similarity index 100%
rename from docs/md/AI/llm/dify-deep-research-workflow-farewell-to-fragmented-search-unlock-ai-driven-insights.md
rename to docs/md/AI/agent/dify-deep-research-workflow-farewell-to-fragmented-search-unlock-ai-driven-insights.md
diff --git a/docs/md/AI/llm/dify-v1-0-building-a-vibrant-plugin-ecosystem.md b/docs/md/AI/agent/dify-v1-0-building-a-vibrant-plugin-ecosystem.md
similarity index 100%
rename from docs/md/AI/llm/dify-v1-0-building-a-vibrant-plugin-ecosystem.md
rename to docs/md/AI/agent/dify-v1-0-building-a-vibrant-plugin-ecosystem.md
diff --git a/docs/md/AI/agent/dify-v1-1-0-filtering-knowledge-retrieval-with-customized-metadata.md b/docs/md/AI/agent/dify-v1-1-0-filtering-knowledge-retrieval-with-customized-metadata.md
new file mode 100644
index 000000000..e69de29bb
diff --git a/docs/md/AI/agent/perplexity-labs.md b/docs/md/AI/agent/perplexity-labs.md
new file mode 100644
index 000000000..efa524337
--- /dev/null
+++ b/docs/md/AI/agent/perplexity-labs.md
@@ -0,0 +1,37 @@
+# 不止于搜索！Perplexity Labs深度解析：以项目为核心的 AI 工作流！
+
+## 0 前言
+
+Perplexity推出全新功能 [Labs](https://www.perplexity.ai/pl/hub/blog/introducing-perplexity-labs)，专为 Pro 订阅用户设计，旨在支持更复杂的任务，功能超越了传统的问答服务。这一重大更新标志着 Perplexity 从以搜索为核心的交互模式，转向由生成式 AI 驱动的结构化、多步骤工作流。
+
+## 1 交互模式
+
+Perplexity Labs 让用户可在一个统一界面完成多种任务，包括生成报告、分析数据、编写和执行代码、构建轻量级网页应用等。用户可以通网页和移动端的新模式切换器进入 Labs，桌面端支持也即将上线。
+
+## 2 适用场景
+
+与专注于简洁回答的 Perplexity Search 和提供深入信息整合的 Research（原名 Deep Research）不同，Labs 更适合需要完整成果输出的用户。这些成果可能包括格式化的电子表格、可视化图表、交互式仪表盘和基础网页工具等。
+
+每个 Lab 项目都包含一个“Assets”标签页，用户可在此查看或下载所有生成的素材，如图表、图片、CSV 文件和代码文件。有些 Labs 还支持“App”标签页，可以直接在项目环境中渲染基本网页应用。
+
+## 3 使用反馈
+
+Perplexity 的 CEO 和联合创始人 Aravind Srinivas 表示：
+
+> 推出 Perplexity Labs，是我们在 Perplexity 上进行搜索的一种全新方式，支持更复杂的任务，如构建交易策略、仪表盘、用于房地产研究的无头浏览任务、迷你网页应用、故事板，以及生成素材的目录等。
+
+实际使用看，Labs 实现了多个软件工具功能的整合与自动化，大大减少了手动操作，尤其适用于结构化研究、数据处理或原型开发等场景。
+
+用户反馈也显示出平台在速度和语境理解方面的优势。Sundararajan Anandan 就曾[分享](https://www.linkedin.com/feed/update/urn:li:ugcPost:7333908730314399752?commentUrn=urn%3Ali%3Acomment%3A(ugcPost%3A7333908730314399752%2C7334912579871326209)&dashCommentUrn=urn%3Ali%3Afsd_comment%3A(7334912579871326209%2Curn%3Ali%3AugcPost%3A7333908730314399752))：
+
+> 我最近尝试了 Perplexity Labs，它真的改变了游戏规则。以前需要花几个小时才能完成的手动研究和格式整理，现在在 10 分钟内就能输出清晰、可执行的见解。虽然目前还处于早期阶段，平台也有待进一步完善，但初次体验已经相当令人惊艳。
+
+不过，一些早期用户也指出了可改进的地方，特别是在初次生成后进行跟进操作或修改代码方面功能有限。正如一位 Reddit 用户[评论](https://www.reddit.com/r/perplexity_ai/comments/1kza7vo/comment/mv6koy5/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button)所说：
+
+> Labs 最大的问题在于它对后续操作的支持不够，基本要求用户一击命中，非常考验技巧。
+
+## 4 总结
+
+Perplexity 还宣布将统一产品术语，将“Deep Research”简化为“Research”，以便更清晰地区分三种模式：Search、Research 和 Labs。
+
+目前，Perplexity Labs 已正式上线，向所有 Pro 用户开放。平台还提供了 [Projects Gallery](https://www.perplexity.ai/labs)，展示了各种示例和使用案例，帮助用户快速上手完成实际任务。
\ No newline at end of file
diff --git a/docs/md/AI/llm/what-is-llmops.md b/docs/md/AI/agent/what-is-llmops.md
similarity index 100%
rename from docs/md/AI/llm/what-is-llmops.md
rename to docs/md/AI/agent/what-is-llmops.md
diff --git a/docs/md/AI/agent/windsurf-update.md b/docs/md/AI/agent/windsurf-update.md
new file mode 100644
index 000000000..2ff335fbe
--- /dev/null
+++ b/docs/md/AI/agent/windsurf-update.md
@@ -0,0 +1,745 @@
+# Windsurf功能更新
+
+## v 1.10.3 Windsurf Browser
+
+June 12, 2025
+
+- 可将浏览器上下文共享给 Windsurf
+- 支持共享代码块、选中文本、网页元素、截图和控制台日志
+- 可将这些内容直接发送到 Cascade
+
+## v 1.10.1 计划模式
+
+2025年6月10日
+
+![](https://p.ipic.vip/um84ce.png)
+
+### 计划模式
+
+- 可以在“计划模式”下向 Cascade 发消息，该模式允许 Cascade 在执行编辑操作前先进行规划
+- Cascade 会创建一个名为 `plan.md` 的文件，列出其准备执行的操作
+- 用户可编辑这个计划文件，Cascade 会识别用户的修改内容
+
+### 终端优化
+
+- Cascade 面板中新增原生终端
+- 现可直接在 Cascade 面板的终端中输入指令
+
+### 移除旧版模式
+
+- 移除旧版模式，现仅保留“Write模式”和“Chat模式”
+
+### 其他改进
+
+- 在 @提及 中加入图标
+- 代码块根据主题自动适配样式，界面焕新
+- 改进 `.codeiumignore` 文件支持
+- 新增菜单，可快速打开和切换之前的对话
+
+## v 1.9.4 修复
+
+2025年6月3日
+
+- 合并了来自 VS Code 1.99.3 的最新更新
+
+## v 1.9.2 支持自带 Anthropic 密钥
+
+2025年5月22日
+
+#### 自带密钥（BYOK）
+
+- 现在你可以在 Cascade 中使用自己的 Anthropic API 密钥，支持 Claude 4 Sonnet、Claude 4 Sonnet（思考版）、Claude 4 Opus 和 Claude 4 Opus（思考版）模型
+- 使用方法：前往 [提供 API 密钥](https://windsurf.com/subscription/provider-api-keys) 页面并输入你的密钥
+- 输入后返回 Windsurf 并重新加载页面，即可使用这些新模型
+
+## v 1.9.1 SWE-1 改进
+
+2025年5月21日
+
+### 多模态支持
+
+- 为 SWE-1 增加了多模态支持，现已支持图像输入
+
+## v 1.9.0 新一代 SWE-1 模型系列
+
+2025年5月15日
+
+### SWE-1
+
+- Windsurf 推出了全新的 SWE-1 模型
+- SWE-1 具备前沿级别的模型能力
+- 专业用户限时免费使用
+
+### SWE-1-lite
+
+- 替代原有 Cascade Base 的新版本，性能大幅提升
+- 所有用户免费用
+
+### SWE-1-mini
+
+- SWE-1-mini 是为 Windsurf 中的标签补全功能特别优化的轻量模型
+
+## v 1.8.2 Cascade Customization
+
+May 6, 2025
+
+### 界面改进
+
+- 重设计型选择器
+- 增加了继续按钮以处理单个工具调用限制
+- 优化会话关联的工作区打开方式
+- 代码块接受/拒绝组件新增紧凑模式，减少占用空间。
+
+### Cascade UX Improvements
+
+- Improvements to commit message generation quality
+- Commit message generation reads from global rules as context
+- Ability to edit proposed terminal command
+
+### 自定义工作流
+
+- 用户可创建并保存“工作流”
+- 通过斜杠命令调用
+- Cascade支持创建和编辑这些工作流
+- 文件保存于工作区的.windsurf/workflows目录下
+
+### 基于文件的规则
+
+- 允许创建细粒度的规则文件，可全局生效、被@提及、由Cascade请求，或附加到文件 glob 模式中
+- 规则文件保存于.windsurf/rules目录
+
+### 多任务处理
+
+- Cascade支持在切换对话时持续运行
+- 并新增了通过下拉菜单或键盘快捷键切换对话的功能
+
+### Cascade插件
+
+- Cascade新增MCP服务器管理面板
+- 简化了一键安装和卸载流程
+- 优化搜索体验
+- MCP现支持资源管理和多模型响应
+- 未来将推出更多MCP服务选项
+
+## v 1.8.0 团队功能
+
+May 6, 2025
+
+### 代码审查
+
+- 团队管理员可安装GitHub应用进行代码审查及PR标题/描述编辑
+- 每月提供500次审查，适用于团队和企业SAAS用户
+
+### 对话分享
+
+- 团队成员可生成共享链接，仅团队内其他成员可访问
+- 适用于团队和企业SaaS方案
+
+### 知识管理
+
+- 团队管理员可连接Google账户并整理相关文档
+- 团队成员可以@提及这些文档以便Cascade检索
+- 适用于团队和企业SAAS用户
+
+### 部署功能
+
+- 团队用户可通过Windsurf设置连接Netlify账户
+- 直接将应用部署至Netlify团队
+- 支持SSO、自定义域等通过Netlify控制台的团队专用设置
+
+### 分析仪表盘
+
+- 更新了团队分析仪表盘
+- 增加Cascade相关数据，如消息数量、工具调用次数、模型使用情况等
+
+### 系统升级
+
+升级至VS Code 1.99.1版本。
+
+## v 1.7.2 全新应用图标与免费套餐升级
+
+2025年4月28日
+
+### 全新应用图标
+
+- Windsurf 现已启用全新设计的应用图标
+- Windsurf.com 网站也同步更新了新版文字标志
+- （Mac 系统）可自定义应用图标也采用新标识
+
+### 免费套餐升级
+
+- 免费用户的使用额度提升
+- 现可在写作模式用 Cascade
+- Cascade 提示额度从每月 5 条提升至 25 条
+- Fast Tab 功能无限制使用
+- Cascade Base 功能无限制使用
+- 可访问预览功能
+- 支持 1 个部署操作
+
+### 性能优化
+
+- 部署应用时的性能和稳定性提升
+- 即使已有部署配置文件（yaml），仍可创建新的部署
+- 部署 Web 应用工具中新增“检查部署状态”的调用功能
+- 对远程扩展（WSL、SSH、Dev Containers）进行了稳定性改进
+- 在大型差异区域中打字时的性能表现更好
+
+### 其他更新
+
+- Command 中新增对 GPT-4.1 的支持
+- 升级至 VSCode 基础版本 1.98
+
+## v 1.7.1
+
+2025年4月24日
+
+- 更新了 IDE 应用商店链接，现同步至 Open VSX 镜像平台
+
+## v 1.7.0
+
+April 21, 2025
+
+### 更新后的简化定价方案
+
+#### 我们将取消 Flow 操作点数（Flow Action Credits）
+
+- 为了让定价模式更简单，我们将取消 Flow 操作点数
+- 此变更将于 2025 年 4 月 21 日起生效
+- 各订阅方案现在将包含「提示点数」，也可以额外购买点数包
+
+#### 用户提示点数（User Prompt Credits）
+
+- 所有订阅方案将提供提示点数，发送每条消息时会消耗点数，而不是每次工具调用时消耗
+- 可额外购买点数包
+- 用户可在个人资料中开启自动充值功能（可设置上限）
+
+#### 现有订阅方案
+
+- 所有现有订阅方案将自动迁移至新的定价模式
+- 更多详情请访问 [定价页面](https://windsurf.com/pricing)
+
+## v 1.6.5
+
+2025年4月16日
+
+### 全新 o4-mini 模型上线，限时免费使用
+
+- Windsurf 现已支持 o4-mini medium 和 o4-mini high 两个模型，所有用户均可免费使用
+- 使用时间限于 4 月 16 日至 4 月 21 日
+
+## v 1.6.4
+
+2025年4月14日
+
+### 全新 GPT 4.1 模型上线，限时免费使用
+
+- Windsurf 现已支持全新的 GPT 4.1 模型，所有用户均可免费使用
+- 使用时间限于 4 月 14 日至 4 月 21 日
+
+2025年4月9日
+
+### Cascade 现已支持JetBrains
+
+- 查看完整的 [JetBrains 更新日志](https://windsurf.com/changelog/jetbrains)
+- 阅读 [官方公告](https://windsurf.com/blog/windsurf-wave-7)
+
+### **Codeium 正式更名为 Windsurf**
+
+- 公司名称更改为Windsurf，插件产品也将更名为 **Windsurf Plugin**。
+
+- 自从推出 [Windsurf 编辑器](https://windsurf.com/editor) 以来，我们明确了真正的
+
+- 目标：融合人类创造力与机器智能，打造强大却毫不费力的体验。
+
+## v 1.6.3
+
+2025年4月7日
+
+- 修复了 Windows 系统上提交生成解析的问题
+- 修复了规则页面的部分 UI 问题
+- 允许部署网站时包含空文件
+- 提升部署错误的可见性
+- 网站部署时支持编辑子域名
+- 提高 MCP SSE 连接的稳定性
+
+## v 1.6.2
+
+2025年4月3日
+
+- 修复了 "Remote - WSL" 扩展相关的问题
+- 一些用户体验方面的小修复
+
+## v 1.6.1
+
+### **2025年4月2日**
+
+### **部署功能（测试版）**
+
+- 使用一句提示将应用部署至 Netlify，使用 windsurf.build 域名
+- 认领你的应用 URL 后，可持续部署更新至相同项目
+- 想部署新站点或更换子域名？只需让 Cascade 部署到新子域即可
+- 所有用户都可使用，付费计划有更多权限
+
+### **提交信息生成（测试版）**
+
+- 在源码控制面板中一键生成提交信息
+- 付费用户可用，且不额外消耗积分
+
+### **Cascade 记忆功能增强**
+
+- 新增记忆标签页
+- 支持编辑记忆标题、内容和标签
+- 支持搜索 Cascade 生成的记忆
+- 设置中可启用/关闭自动生成记忆的开关
+- 开启后自动记录重要上下文；关闭后只会根据请求创建记忆
+
+### **长对话改进**
+
+- 引入用户消息目录，滚动时显示，支持快速定位历史内容
+
+### **Windsurf Tab 改进**
+
+- 支持 Jupyter Notebook
+- 新增上下文信号，包括 IDE 内部搜索内容
+
+### **新图标（Mac）**
+
+付费用户可选两款新应用图标：Retro 和 Pixel Surf
+
+### **其他更新**
+
+- 新增 Cascade 工具栏，整合 MCP、预览、部署等工具
+- Cascade 支持 JSON 配置中的 SSE MCP 服务器
+- “打开新窗口时关闭 Cascade” 的设置现已生效
+- 输入框内容在新建会话和活跃会话中保留
+- 终端界面焕新，“打开终端”按钮更加醒目
+- 链接支持点击跳转
+- 可开启“运行结束播放提示音”（测试中）
+- 修复 Remote - SSH 扩展问题，支持自定义 SSH 路径
+- 合并 VS Code 1.97.0 相关更新
+
+## **v 1.5.9**
+
+### **2025年3月25日**
+
+### **新模型：Gemini 2.5 Pro（测试版）**
+
+- Gemini 2.5 Pro 正式进入测试阶段！
+- 每条消息消耗 1 个用户提示积分，每次工具调用消耗 1 个流程操作积分
+- 所有计划（包括免费）均可使用
+- *当前需求量大，团队正在扩容中*
+
+### **修复内容**
+
+- 修复了 Remote - SSH 扩展及自定义 SSH 路径设置问题
+
+## **v 1.5.8**
+
+### **2025年3月24日**
+
+### **修复内容**
+
+- Cascade 更好地遵循用户定义的记忆
+- 浏览器预览改进
+- 修复 Cascade 图标相关布局问题
+
+## **v 1.5.6**
+
+### **2025年3月18日**
+
+### **全新 Windsurf Tab 体验**
+
+- 将 Autocomplete、Supercomplete、Tab to Jump、Tab to Import 整合为一体化体验
+- 使用更大更高质量模型，提升上下文理解、速度与质量
+
+### **上下文优化**
+
+- 补全功能可利用浏览文件、终端命令、Cascade 会话等信号
+- 剪贴板上下文（默认关闭，可在高级设置中启用）
+- 上下文长度扩展，提升补全效果
+
+### **质量提升**
+
+- 自动选择插入补全 vs 编辑补全更加精准
+- Tab to Jump 跳转范围翻倍
+- 提高缩进与排版质量
+
+### **性能提升**
+
+- 预测触发补全，连贯完成多轮建议
+- 增强服务器能力与推理速度
+- 网络优化，延迟更低
+
+### **Tab 使用体验升级**
+
+- 接受的补全高亮为绿色（可关闭）
+
+- Tab to Jump 与 Tab to Import 小部件视觉更清晰、可点击
+
+### **其他改进**
+
+- 自动修复 Lint 模式中信用扣除更准确
+- 终端命令现可作为上下文
+- Debug Console 中 Tab 键支持补全
+- Cascade 差异审查体验优化
+- 修复信用不足提示、补全速度设置等问题
+- 快捷设置下拉菜单改进
+- 提升 CPU 和内存使用效率
+- 新增 Neon 数据库作为 MCP 模板
+
+## **v 1.4.6**
+
+2025年3月10日
+
+### **修复内容**
+
+- 修复 Sonnet 3.7 网页搜索问题
+- 修复代理设置问题
+
+## v 1.4.4 修复
+
+2025年3月6日
+
+- 重新添加设置项至设置面板（代理设置、索引大小）
+
+## v 1.4.3
+
+### **2025年3月5日**
+
+### **Windsurf 预览、自动 Linter、新 MCP 服务**
+
+#### **Windsurf 预览（测试版）**
+
+- Cascade 支持在 IDE 或浏览器中预览本地网站
+- 可选中 React 或 HTML 元素作为上下文提供给 Cascade
+- 错误信息也可传递作为上下文
+- 可通过“启动 Web 应用”或工具栏图标激活预览
+- 支持在 Chrome、Arc、Chromium 浏览器中展示
+- 可在设置中关闭
+
+#### **Cascade 自动 Linter**
+
+- Cascade 现在自动修复自己生成代码中的 lint 错误
+- 每步中 lint 修复不计入积分消耗
+- 示例：若某次修改包含4个 lint 错误，将自动尝试修复，无额外消耗
+- 可在设置中关闭
+
+#### **新 MCP 服务支持**
+
+- 可将 Cascade 配置为调用可信 MCP 工具服务器
+- Windsurf 设置页提供常用 MCP 服务器列表
+- 新用户界面便于添加和配置 MCP
+- 设置页中仍支持用户自定义 JSON
+- 专业与终极专业计划可用，团队与企业计划即将支持
+
+#### **Tab-to-Import**
+
+- 自动补全缺失依赖导入
+- 使用 Tab 接受建议即可完成导入
+
+#### **建议操作**
+
+- Cascade 提供任务相关建议操作，点击即可继续操作流程
+
+#### **拖放文件作为上下文**
+
+- 支持从文件资源管理器拖放文件进 Cascade
+- 支持所有文件类型
+
+#### **模型管理控制**
+
+- 团队管理员可选择开放哪些模型供团队使用
+- 成员默认仅见管理员启用的模型
+
+#### **Claude Sonnet 3.7 支持**
+
+- Cascade 支持 Claude Sonnet 3.7
+- 工具调用与流程操作表现更优
+
+#### **其他更新**
+
+- 新版快速设置界面与高级设置视图
+
+- 支持读取 .gitignore 文件
+
+- 推出用户推荐系统
+
+- Windsurf directory：官方精选规则集，帮助 Cascade 更好理解你与代码库
+
+  - [查看规则目录](https://codeium.com/windsurf/directory)
+
+## **v 1.3.10**
+
+### **修复内容**
+
+- 优化 Claude 3.7 Sonnet 的积分使用
+- 更新后建议在新会话中运行所有后续操作
+- 新增查看/编辑 .gitignore 文件的选项
+
+## **v 1.3.9**
+
+### **新模型：Claude 3.7**
+
+- Cascade 现已支持 Claude 3.7 Sonnet（高级模型）
+
+  
+
+  - 每条消息消耗 1 积分，每次工具调用也消耗 1 积分
+  - “思维模式”下使用该模型积分乘数为 1.5x
+
+  
+
+- [渐进推出] GPT-4.5 模型测试中
+
+  
+
+  - 因成本、速率限制与质量测试，将逐步放出
+
+
+## **v 1.3.3**
+
+2025 年 2 月 13 日
+
+## **模型上下文协议、自定义应用图标，以及 Tab 跳转**
+
+### **模型上下文协议 (Model Context Protocol)**
+
+- Cascade 现在支持模型上下文协议（MCP）
+- 你可以设置 Cascade 对话使用 MCP 服务器进行工具调用
+- 可以通过点击 Cascade 输入栏的锤子图标设置 MCP
+- 对所有个人用户计划开放
+- 每次 MCP 工具调用消耗 1 个流动操作积分，无论执行结果如何
+
+### **新增可自定义应用图标**
+
+- 你现在可以更改 Windsurf 的应用图标（仅限 Beta & Mac）
+- 付费用户可以选择 Classic、Blueprint、Hand-drawn、Valentine 等风格
+- 更改图标后需重启系统以实现系统级别的图标更新
+- 对所有付费用户计划开放
+- Windows 和 Linux 平台即将上线该功能
+
+### **补全功能改进**
+
+- Tab to Jump 功能正式发布，可智能预测下一个编辑位置并通过 Tab 键跳转
+
+### **Cascade Turbo 模式**
+
+- Cascade Turbo 模式全面升级，可自动执行终端命令（除非被加入拒绝列表）
+- 对所有个人用户计划开放
+
+### **Cascade 拖拽图片支持**
+
+- Cascade支持从系统文件或截图中拖拽图片到输入框
+
+### **积分使用可视化**
+
+- Cascade 现在可以显示每个操作消耗了多少积分
+- 鼠标悬停在执行后的操作上可查看积分消耗
+
+### **其他改进**
+
+- 修复了 Cascade 终端命令的一些 Bug
+- 命令步骤现在会显示自动执行的行为信息
+- 修复了重新加载后 Cascade 面板总是自动打开的问题，即使用户已在设置中关闭
+- 你可以使用 Cmd/Ctrl+L 快捷键 @提及 终端文字，新增了选择弹窗
+- @docs 结果现在支持滚动查看，避免选项被截断
+- @docs 支持更多服务，如 Vercel、Bun、Supabase 等
+
+### **新增模型**
+
+- Cascade 新增高级模型：Gemini 2.0 Flash
+
+  
+
+  - 每条消息消耗 0.25 用户提示积分，每次工具调用消耗 0.25 流动操作积分
+
+
+## **v 1.2.4**
+
+2025 年 1 月 31 日
+
+## 新增模型：DeepSeek-R1、DeepSeek-V3 和 o3-mini
+
+### 模型
+
+- 新增高级模型：DeepSeek-R1、DeepSeek-V3 和 o3-mini÷
+- DeepSeek-V3 和 R1 适用于 Pro 和 Pro Ultimate 用户
+- DeepSeek-V3：每条消息消耗 0.25 用户提示积分，每次工具调用消耗 0.25 流动操作积分
+- DeepSeek-R1：每条消息消耗 0.5 用户提示积分，每次工具调用消耗 0.5 流动操作积分
+- o3-mini 适用于所有付费用户
+- o3-mini：每条消息和每次调用均消耗 1 个积分
+
+
+### 修复内容
+
+- 增加拖拽图片至 Cascade 功能支持
+
+## v 1.2.0 弹性积分系统上线，Cascade Base 开源！
+
+2025 年 1 月 25 日
+
+### 弹性积分系统
+
+- Windsurf 现在引入 **弹性积分（Elastic Credits）** 系统
+
+- 拆分为两类积分：
+
+  - 用户提示积分（User Prompt Credits）
+  - 流动操作积分（Fluid Action Credits）
+
+- 模型对话、文件上传、API 工具调用、终端操作都将按实际用途计费，更透明可控
+
+- 设置 > 积分详情中查看各模型和工具的积分消耗
+
+- 套餐每月包含的积分数不变，仅计费方式调整
+
+### Cascade Base 开源
+
+- 作为本地运行的轻量 AI 助理，开源地址：https://github.com/exafunction/cascade
+- 用户可以自定义工具链，连接任意本地服务或模型
+
+### **新增模型**
+
+- **Claude 3 Opus** 模型上线（适用于 Pro Ultimate 用户）
+- 消耗：每条消息需 2 用户提示积分，每次工具调用需 2 流动操作积分
+
+### **改进项**
+
+- 文件上传功能更清晰，拖拽上传 UI 优化
+- 文件上传后自动触发 @files 工具处理内容
+
+## v 1.1.1
+
+2025 年 1 月 19 日
+
+### **修复内容**
+
+- 修复了终端调用 API 返回乱码的问题
+- 修复调用工具时出错未显示详细错误的 bug
+- 修复选择文件时的路径错乱问题
+- 修复长时间运行后模型响应变慢的问题
+
+## v 1.1.0
+
+2025 年 1 月 15 日
+
+## 文件支持、自动调用工具，以及 Claude 3 模型上线！
+
+### **文件功能（Beta）**
+
+- 你现在可以上传文件至对话中，AI 可自动引用内容
+- 支持的文件类型：.txt, .md, .pdf, .docx, .csv, .json 等
+- 文件内容可以通过 @files 工具进行提问和搜索
+- 文件将默认保存在本地，不会上传至云端
+
+### 自动调用工具
+
+- Cascade 现在支持 **自动调用工具**
+- 在你与 AI 对话过程中，会自动触发相关工具（如终端、API、搜索等）
+- 可在设置中手动启用或关闭自动调用
+
+### 新增 Claude 3 模型
+
+- 新增 Anthropic 的 Claude 3 Haiku 和 Claude 3 Sonnet 模型
+
+  - Claude 3 Haiku：快速响应、低消耗
+  - Claude 3 Sonnet：更强大，适用于复杂任务
+
+- 默认对所有付费用户开放，Sonnet 限 Pro 及以上
+
+## v 1.0.6
+
+2024年12月6日
+
+### 使用透明度
+
+![1.0.6 更新日志横幅](https://exafunction.github.io/public/changelog/windsurf/1.0.6/106_hero_img.jpg)
+
+#### 使用透明度与定价
+
+- 推出 Windsurf 的全新使用和定价系统。详情请参见[定价](https://codeium.com/redirect/windsurf/learn-pricing)
+- 快速设置面板现在会显示当前计划的使用情况，包括试用期到期时间、下一个刷新周期的信息以及升级链接
+- Cascade 新增“Legacy Chat”模式，当用户的 Flow Credits 耗尽时激活。此模式功能有限，但无需使用 Flow Credits
+- 在设置面板中查看 Cascade 的使用情况。更多信息请参见[此处](https://docs.codeium.com/windsurf/usage#viewing-your-usage)。
+
+#### Cascade 图片上传
+
+- Cascade 图片上传的大小限制取消为 1MB
+
+#### 增强 Python 语言支持
+
+- 通过 Windsurf Pyright 提供功能丰富的 Python 语言支持。Windsurf Pyright 是 Pylance 的替代方案
+
+### 其他修复
+
+- 从其他基于 VS Code 的 IDE 导入，可连同设置一起导入代码片段
+- 快速设置面板中可查看并配置 AI 相关快捷键
+
+## v 1.0.5 图片上传
+
+2024年11月27日
+
+#### 上传图片到 Cascade
+
+- Cascade 现在支持在高级模型上传图片
+- 上传图片后可以让 Cascade 构建或调整 UI
+
+#### 新增快捷键
+
+- 快捷键在 Cascade 差异视图中导航（默认是 ⌥/Alt + j 和 ⌥/Alt + k）
+- 快捷键在具有 Cascade 差异的文件间导航（默认是 ⌥/Alt + h 和 ⌥/Alt + l）
+
+### 其他修复
+
+- 增加了控制 Cascade 是否自动打开创建/编辑文件的选项（默认启用）
+- 修复了影响部分用户的自动补全设置问题
+- 快速设置面板 UI 更新
+
+## v 1.0.4 解释并修复问题
+
+2024年11月21日
+
+- Cascade 将尝试修复代码库中的问题
+- 鼠标悬停在问题上时会出现选项
+
+#### 从cursor导入
+
+- 导入设置和扩展
+- 可通过命令面板或重置引导流程获取
+
+#### 新增快捷键
+
+- 接受文件中所有活动差异的快捷键（默认是 ⌘/Ctrl + ⏎）
+- 拒绝文件中所有活动差异的快捷键（默认是 ⌘/Ctrl + ⌫）
+- ⌘/Ctrl + Shift + L 打开 Cascade 中的新对话，同时复制选中的终端/编辑器文本到新对话
+
+### 改进与修复
+
+####  改进的命令
+
+- 改进了 Jupyter Notebook 中的命令体验
+
+####  改进的差异视图
+
+- 删除了 Cascade 删除文件中的差异显示
+- 更清晰的光标指示，显示已删除文本的差异内容可被选中
+
+###  其他修复
+
+- Windsurf 快速设置面板在点击面板外部时会自动关闭
+- 提高了某些主题中引导元素的可见性
+- 修复了一些轻微的布局问题
+- 增加了加入 Discord 社区的按钮
+- 提高了通过 SSH 使用时 Cascade 面板的稳定性
+- 由 Cascade 编辑/创建的文件将自动在后台打开。如果没有活动的编辑器，首个编辑/创建的文件将作为当前活动编辑器打开
+- 在标题栏下拉菜单中新增了更新日志链接，同时在用户更新版本后显示更新日志提醒
+
+## v 1.0.2 - Windsurf上线
+
+2024年11月13日
+
+![](https://exafunction.github.io/public/changelog/windsurf/1.0.2/102_hero_img.jpg)
+
+- 正式发布！
+- 使用 Cascade 与 Codeium 的完整代码库上下文聊天，支持多文件编辑
+- 新模式 Supercomplete，可预测下一步意图
\ No newline at end of file
diff --git a/docs/md/AI/document-parsing-and-chunking-in-open-source-tools.md b/docs/md/AI/document-parsing-and-chunking-in-open-source-tools.md
new file mode 100644
index 000000000..52b8b8e2f
--- /dev/null
+++ b/docs/md/AI/document-parsing-and-chunking-in-open-source-tools.md
@@ -0,0 +1,102 @@
+# 01-RAG应用框架和解析器
+
+## 1 开源解析和拆分文档
+
+第三方工具去对文件解析拆分，提取文件内容，并将文档内容拆分成一个小chunk。
+
+PDF、word、markdown、JSON、HTML等都有很好的模块执行提取。
+
+### 1.1 优势
+
+- 支持丰富的文档类型
+- 每种文档多样化选择
+- 与开源框架无缝集成
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/704e6a30d6793c931c5db2a5afe142d5.png)
+
+但有时效果很差，内容跟原文件差别大。
+
+## 2 PDF格式多样性
+
+![](https://my-img.javaedge.com.cn/javaedge-blog/2024/06/96e776191774b85d9490cd0d2b3d1d4a.png)
+
+复杂多变的文档格式，提高解析效果困难。
+
+## 3 复杂文档格式解析问题
+
+文档内容质量很大程度影响最终效果，文档处理涉及问题：
+
+### 3.1 内容不完整
+
+对文档的内容提取时，可能发现提取出的文档内容会被截断。跨页形式，提取出来它的上下页，两部分内容就会被截断，导致文档内部分内容丢失，去解析图片或双栏复杂的这种格式，它会有一部分内容丢失。
+
+### 3.2 内容错误
+
+同一页PDF文件可能存在文本、表格、图片等混合。
+
+PDF解析过程中，同一页它不同段落其实会也会有不同标准的一些格式。按通用格式去提取解析就遇到同页不同段落格式不标准情况。
+
+### 3.3 文档格式
+
+像常见PDF md文件，需要去支持把这些各类型的文档格式的文件都给提取。
+
+### 3,4 边界场景
+
+代码块还有单元格这些，都是我们去解析一个复杂文档格式中会遇到的一些问题。
+
+## 4 PDF内容提取流程
+
+![](https://p.ipic.vip/bgzr90.png)
+
+## 5 为啥解析文档后，要做知识片段拆分？
+
+### 5.1 Token限制
+
+- 绝大部分开源限制 <= 512 Tokens
+- bge_base、e5_large、m3e_base、text2vector_large_chinese、multilingnal-e5-base..
+
+### 5.2 效果影响
+
+- 召回效果：有限向量维度下表达较多的文档信息易产生失真
+- 回答效果：召回内容中包含与问题无关信息对LLM增加干扰
+
+### 5.3 成本控制
+
+- LLM费用：按Token计费
+- 网络费用：按流量计费
+
+## 6 Chunk拆分对最终效果的影响
+
+### 6.1 Chunk太长
+
+信息压缩失真。
+
+### 6.2 Chunk太短
+
+表达缺失上下文；匹配分数容易变高。
+
+### 6.3 Chunk跨主题
+
+内容关系脱节。
+
+### 原文连续内容（含表格）被截断
+
+单个Chunk信息表达不完整，或含义相反
+
+### 干扰信息
+
+如空白、HTML、XML等格式，同等长度下减少有效信息、增加干扰信息
+
+### 主题和关系丢失
+
+缺失了主题和知识点之间的关系
+
+## 7 改进知识的拆分方案
+
+![](https://p.ipic.vip/n7g8l0.png)
+
+## 8 商用向量数据库AI套件
+
+Vector DB AI套件：
+
+![](https://p.ipic.vip/69bx73.png)
\ No newline at end of file
diff --git a/docs/md/AI/llm/cuda.md b/docs/md/AI/llm/cuda.md
new file mode 100644
index 000000000..735f4355e
--- /dev/null
+++ b/docs/md/AI/llm/cuda.md
@@ -0,0 +1,230 @@
+# 空有A100却在“吃灰”？给Javaer的三种CUDA“遥控器”，榨干GPU性能
+
+## 0 前言
+
+有自己的智算中心和这么多A100“大杀器”，了解CUDA不是“要不要”，而是“必须”的问题了。不把GPU潜力榨干，那可真是太浪费了。
+
+作为Java架构师，无需像C++程序员手写底层CUDA C++代码，但须理解核心思想和工作原理。才能在架构层正确决策，判断：
+
+- 哪些业务场景适合交给GPU加速
+- 咋将Java应用与底层CUDA能力连接
+
+这就像不一定手写汇编，但懂些CPU工作原理，能写更高性能Java代码。
+
+## 1 CUDA是啥？从JVM说起
+
+先定调：对Java架构师，可把CUDA看作专属于NVIDIA GPU的“JVM + JIT编译器”。
+
+  * **JVM是什么？** 一个标准的运行时，能让Java字节码（`.class`文件）在不同的操作系统和CPU上运行
+  * **CUDA是什么？** 一个标准的运行时和API集合，能让你写的“GPU代码”（通常是C++写的`.cu`文件）在NVIDIA的GPU硬件运行
+
+再进一步：
+
+  * **JIT（Just-In-Time）编译器**：JVM精髓之一。运行时把热点的Java字节码动态编译成本地机器码，充分压榨CPU性能
+  * **NVCC（NVIDIA C Compiler）**：CUDA的“编译器”。会把`.cu`文件（一种混合C++和CUDA特殊指令的源文件）编译成能在GPU上高效执行的机器码（PTX或SASS）
+
+所以，谈论CUDA时，谈论的是一个完整生态系统：
+
+  * **一个编程模型**：告诉你咋写并行代码
+  * **一套API和库**：给你提供现成工具调用GPU
+  * **一个驱动和运行时**：负责在硬件上实际执行你的代码
+
+一句话总结：CUDA是连接上层应用软件和底层NVIDIA GPU硬件的“驱动+标准接口+运行时”，是释放GPU强大并行计算能力的钥匙。
+
+## 2 CUDA“世界观”：为啥它能那么快？
+
+CPU和GPU设计哲学完全不同：
+
+  * **CPU（中央处理器）**：全能的单兵王者。核心（Core）数不多（如16、32核），但每个核心都极其强大和复杂。巨大缓存、复杂分支预测和指令流水线，擅长处理**复杂的、带有大量逻辑判断和串行依赖的任务**。就像几个经验丰富项目经理，能处理各种疑难杂症
+
+  * **GPU（图形处理器）**：纪律严明的万人军团。核心数量庞大（一张A100有6912个CUDA核心！），但每个核心很简单，功能有限。不擅长复杂逻辑判断，但极其擅长**对海量数据执行同一个简单的计算任务**。就像上万个士兵，每人只会“前进、刺击”简单动作，但上万人一起做，形成冲击力毁灭性。
+
+CUDA编程模型的核心就是**咋组织和指挥这个“万人军团”**。它引入了几个核心概念：
+
+  * **Kernel（内核）**：你希望GPU执行的那个“简单任务”的定义。可以把它想象成你写的一个Java `Runnable` 接口的 `run()` 方法。这个方法里的代码，将会被成千上万个线程去执行
+
+  * **Thread（线程）**：GPU执行`Kernel`的最小单元。相当于一个Java的`Thread`实例
+
+  * **Block（块）**：一组GPU线程，形成一个“班”或“排”。同一个Block里的线程可以非常高效地进行通信和数据同步（通过一块共享内存`Shared Memory`）。这有点像一个`ExecutorService`线程池里的线程，它们可协同工作
+
+  * **Grid（网格）**：一组Block，形成一个“师”或“军”。这是你向GPU提交的一个完整的计算任务
+
+所以，一个典型CUDA任务流程：
+
+1.  **定义任务**：用CUDA C++写一个`Kernel`函数，比如“给这个数组的每个元素都乘以2”
+2.  **组织军团**：确定你要启动多少个线程（Grid和Block的维度），比如“启动1024个Block，每个Block包含256个线程，总共262,144个线程大军”
+3.  **数据传输**：把需要处理的数据从CPU的内存（我们Java应用的堆内存）拷贝到GPU的显存（VRAM）中。**这是关键瓶颈之一！**
+4.  **执行命令**：在GPU上启动`Kernel`，让成千上万个核心同时开始计算
+5.  **回收结果**：等GPU计算完成后，再把结果从GPU显存拷贝回CPU内存
+
+**架构师的启示**：一个任务是否适合用GPU加速，关键看：
+
+1.  **计算密集型**：任务本身需要大量的数学运算，而不是复杂的业务逻辑
+2.  **高度并行性**：任务可以被拆解成成千上万个完全独立的子任务。比如矩阵乘法、图像滤镜、大规模数据转换等。如果任务前后依赖严重，比如`for`循环里下一步的计算依赖上一步的结果，那就不适合GPU
+
+## 3 Javaer咋“遥控”CUDA？
+
+我们的主战场。
+
+知道CUDA原理，但我们是Java架构师，总不能去写C++吧？当然不用！有几种“遥控”方式，从“硬核”到“优雅”：
+
+### 3.1 JNI
+
+Java Native Interface，硬核但灵活。最原始、最底层方式：
+
+#### 原理
+
+Java通过JNI规范，可以调用C/C++写的动态链接库（`.dll`或`.so`文件）。我们可以让C++团队把所有CUDA相关的复杂操作（内存管理、核函数启动等）封装成一个简单的C函数，并编译成`.so`文件。Java应用在需要时，通过JNI加载这个库，并调用那个C函数。
+
+#### 优点
+
+性能最好，灵活性最高。你可以100%控制所有CUDA的细节。
+
+#### 缺点
+
+极其复杂！需要一个精通CUDA C++和JNI的团队。JNI的开发、调试、部署都非常痛苦，内存管理容易出错导致JVM崩溃。这就像你为了开个车，先自己从零件开始造发动机。
+
+#### 适用场景
+
+对性能要求达到极致，且有专门的C++/CUDA团队支持的超大型项目。
+
+### 3.2 JCuda / JCublas等第三方库 - “JDBC”模式
+
+这是目前比较主流和现实的方式。
+
+#### 原理
+
+像JCuda这样的库，已经帮你把CUDA Driver API和Runtime API用JNI封装好了，并提供了易于使用的Java接口。你不需要写一行C++代码，就可以在Java里直接调用CUDA的函数。
+
+#### 类比
+
+这完美对标我们JavaEE里的**JDBC**。我们写Java时，不会直接去跟Oracle或MySQL的底层通信协议打交道，而是使用标准的JDBC接口。JCuda就是CUDA的“JDBC驱动”。
+
+#### 示例（伪代码）
+
+```java
+// 1. 初始化CUDA环境
+JCuda.cudaInit();
+
+// 2. 分配GPU显存
+Pointer deviceInput = new Pointer();
+JCuda.cudaMalloc(deviceInput, dataSize);
+
+// 3. 从Java堆内存拷贝数据到GPU显存
+JCuda.cudaMemcpy(deviceInput, hostInput, dataSize, cudaMemcpyHostToDevice);
+
+// 4. 配置并启动Kernel（Kernel通常是预先编译好的.ptx文件）
+// ... 配置Grid和Block维度
+// ... 加载.ptx文件中的Kernel函数
+// ... 调用cuLaunchKernel
+
+// 5. 从GPU显存拷回结果到Java堆内存
+JCuda.cudaMemcpy(hostOutput, deviceOutput, dataSize, cudaMemcpyDeviceToHost);
+
+// 6. 释放资源
+JCuda.cudaFree(deviceInput);
+```
+
+#### 优点
+
+大大降低了使用门槛，纯Java开发，生态相对成熟。
+
+#### 缺点
+
+仍然需要手动管理GPU显存、数据拷贝，对CUDA的运行时模型要有比较清晰的理解。API比较啰嗦，更像是过程式的C API的Java映射。
+
+#### 适用场景
+
+绝大多数需要在Java应用中集成自定义CUDA加速的场景。你们有智算中心，想在现有的Java微服务或大数据处理任务中，把某个计算瓶颈 offload 到A100上，这通常是首选。
+
+### 3.3 TornadoVM / Aparapi等 - “JIT”终极模式
+
+这是最前沿、最优雅，也最具野心的方式。
+
+#### 原理
+
+TornadoVM是一个特殊的OpenJDK插件。它的目标是让你**像写普通的Java并行流（Parallel Stream）一样写代码，然后它自动帮你把代码JIT编译成CUDA/OpenCL代码，并 offload 到GPU上执行！**
+
+#### 类比
+
+这才是真正的“GPU上的JIT”。你甚至都不用关心GPU的存在，TornadoVM会自动分析你的Java字节码，判断是否可以并行化，然后动态生成GPU代码并执行。
+
+#### 示例（伪代码）
+
+```java
+// 你只需要在你的方法上加一个注解
+public static void matrixMultiplication(float[] a, float[] b, float[] c, final int N) {
+    // TornadoVM会把这个@Parallel注解的循环自动编译成CUDA Kernel
+    @Parallel for (int i = 0; i < N; i++) {
+        for (int j = 0; j < N; j++) {
+            float sum = 0.0f;
+            for (int k = 0; k < N; k++) {
+                sum += a[i * N + k] * b[k * N + j];
+            }
+            c[i * N + j] = sum;
+        }
+    }
+}
+
+// 在主程序中，用TornadoVM的TaskSchedule来运行
+TaskSchedule s0 = new TaskSchedule("s0")
+    .task("t0", YourClass::matrixMultiplication, matrixA, matrixB, matrixC, N)
+    .streamOut(matrixC);
+s0.execute();
+```
+
+#### 优点
+
+对Java程序员的透明度极高！** 几乎没有学习成本，可以用纯粹的Java思维来利用GPU。这可能是未来的终极方向。
+
+#### 缺点
+
+还比较新，生态和社区不如JCuda成熟。自动编译的性能可能不如C++专家手写的Kernel。对代码写法有一定要求（不能太复杂）。
+
+#### 适用场景
+
+希望快速将现有Java计算密集型代码（如科学计算、金融风控模型）迁移到GPU上进行验证和加速。新项目技术选型，可以重点关注。
+
+## 4 实践：A100该咋用？
+
+有自己的智算中心和A100，可从以下几个层面思考：
+
+### 4.1 识别瓶颈，建立“GPU加速候选池”
+
+#### 离线大数据处理
+
+Spark/Flink任务中，有开销巨大的`map`或`filter`操作？如对海量图片预处理、对金融交易数据特征提取，都是绝佳候选。可用JCuda或TornadoVM写一个UDF（User-Defined Function），让这个UDF内部调用GPU来计算。
+
+#### 在线微服务
+
+有没有哪个服务的RT（响应时间）因为某个复杂的计算而居高不下？如风控服务的实时风险评分、推荐系统的实时向量相似度计算、图像服务的AI审查。可以考虑将这个服务改造为“CPU+GPU”的混合服务。轻量级请求走CPU，计算密集型请求异步 offload 到GPU。
+
+#### 模型推理
+
+像TensorRT-LLM底层就是CUDA C++写的，它已将A100的Tensor Core（A100的“特种兵”，专精矩阵运算）用到极致。Java应用只需要通过REST/gRPC调用这些推理服务。
+
+### 4.2 构建GPU资源管理与调度层
+
+  * 既是智算中心，就不能让每个Java应用像“野孩子”一样直连GPU。需一个中间层
+  * 可基于k8s的Device Plugin机制，对GPU资源进行池化和调度
+  * 开发一套“GPU任务提交网关”，Java应用通过这个网关提交计算任务，网关负责排队、调度到空闲的A100卡上，并返回结果。这使得GPU对上层业务透明，成为一种可被计量的“计算资源”
+
+### 4.3 技术选型与团队赋能
+
+#### 短期见效
+
+对已有Java应用，选择**JCuda**方案，对最痛的计算瓶颈进行“手术刀”式的改造。
+
+#### 长期投资
+
+励团队研究**TornadoVM**，探索“无感”使用GPU的可能性，降低未来业务的开发成本。
+
+#### 专业分工
+
+如可能，培养或引入1-2名精通CUDA C++的工程师，作为你们的“核武器”，负责攻克最艰难的性能优化问题，并为上层Java应用提供封装好的高性能计算库。
+
+## 5 总结
+
+CUDA对Javaer，不是一门需精通的编程语言，而是须了解的异构计算平台。理解其工作原理和与Java的集成方式，就能打开新大门，将那些过去在CPU上跑得气喘吁吁的任务，扔给A100这个“万人军团”去瞬间完成。
+
+这不仅能带来几十甚至上百倍的性能提升，更是未来AI时代架构设计中不可或缺的一环。
\ No newline at end of file
diff --git a/docs/md/AI/llm/gpullama3-java-gpu-llm.md b/docs/md/AI/llm/gpullama3-java-gpu-llm.md
new file mode 100644
index 000000000..313bd3e3a
--- /dev/null
+++ b/docs/md/AI/llm/gpullama3-java-gpu-llm.md
@@ -0,0 +1,70 @@
+# 告别 CUDA！GPULlama3.java 横空出世，Java 首次实现原生 GPU 跑大模型
+
+## 0 前言
+
+曼彻斯特大学 [Beehive Lab](https://github.com/beehive-lab) 发布 [GPULlama3.java](https://github.com/beehive-lab/GPULlama3.java)，这是首个支持 GPU 自动加速的 Java 原生 [Llama3](https://www.llama.com/models/llama-3/) 实现。该项目基于  [TornadoVM](https://github.com/beehive-lab/TornadoVM)，让开发者无需编写 CUDA 或原生代码，即可在 Java 中实现LLM的 GPU 推理。这有望彻底改变 Javaer 在企业环境中构建 AI 应用的方式。
+
+## 1 GPULlama3.java 的核心
+
+TornadoVM —— 一款创新的异构编程框架，它扩展了 OpenJDK 和 GraalVM，使 Java 程序能自动在 GPU、FPGA 以及多核 CPU 加速运行。与传统 GPU 编程方式不同，TornadoVM 无需手动重写 CUDA 或 OpenCL 代码，开发者可完全用 Java 编写逻辑，TornadoVM 负责底层加速。
+
+根据 [TornadoVM 官方文档](https://tornadovm.readthedocs.io/en/latest/introduction.html) 的介绍，该系统通过扩展 Graal JIT 编译器，添加专用后端，在运行时将 Java 字节码转换为 GPU 可执行代码。只需用 `@Parallel` 注解标记方法，TornadoVM 就能将普通 Java 字节码转换为 Graal 中间表示（IR），应用 GPU 优化策略，并生成目标平台代码，如 OpenCL C（跨平台）、PTX（NVIDIA）或 SPIR-V（二进制格式，支持 Intel 显卡）。
+
+```java
+// 来自 TornadoVM 文档的 TaskGraph 示例
+TaskGraph taskGraph = new TaskGraph("computation")
+    .transferToDevice(DataTransferMode.FIRST_EXECUTION, data)
+    .task("process", MyClass::compute, input, output)
+    .transferToHost(DataTransferMode.EVERY_EXECUTION, output);
+
+TornadoExecutionPlan executor = new TornadoExecutionPlan(taskGraph.snapshot());
+executor.execute();
+```
+
+根据 [TornadoVM 编程指南](https://tornadovm.readthedocs.io/en/latest/programming.html)，开发者可用与硬件无关的 API，在不同硬件平台上运行相同的 Java 代码。TornadoVM 运行时会自动处理所有设备相关的优化、内存管理和数据传输。
+
+## 2 支持后端
+
+GPULlama3.java 支持三种主要后端，可运行在多种硬件：
+
+- **NVIDIA 显卡**：支持 OpenCL 和 PTX 两种后端
+- **Intel 显卡**：包括 Arc 独显和集成的 HD Graphics，支持 OpenCL
+- **Apple Silicon**：M1/M2/M3 可通过 OpenCL 运行（但由于 Apple 已弃用 OpenCL，未来将转向 Metal）
+
+项目运行时可通过命令行参数配置：
+
+```bash
+# 使用 GPU 加速运行（项目 README 示例）
+./llama-tornado --gpu --verbose-init --opencl --model beehive-llama-3.2-1b-instruct-fp16.gguf --prompt "Explain the benefits of GPU acceleration."
+```
+
+该项目依赖 Java 的现代功能，具体包括：
+
+- 要求 **Java 21 及以上版本**，以使用 Vector API 和 Foreign Memory API
+- 支持 **GGUF 模型格式**，方便模型打包与部署
+- 支持 **量化格式**（Q4_0 和 Q8_0），以降低内存占用
+
+GPULlama3.java 基于 [Alfonso Peterssen 的原始 LLama3.java 实现](https://github.com/mukel/llama3.java) 开发，并在此基础引入 TornadoVM GPU 加速功能。正如 [Peterssen 在 Devoxx 2024 大会](https://youtu.be/zgAMxC7lzkc?si=pPqZzeu81ESWjUdx) 展示，他的工作首次实现无需原生依赖即可运行 Llama 模型。TornadoVM 团队进一步将其适配为异构加速架构。
+
+## 3 Java LLM 项目
+
+GPULlama3.java 的发布也使其成为 Java LLM 项目的一员，其他相关项目还包括：
+
+- [JLama](https://github.com/tjake/Jlama)：一个现代 Java LLM 推理引擎，支持分布式部署
+- [Llama3.java](https://github.com/mukel/llama3.java)：专注 CPU 优化的纯 Java 实现
+
+正如 [Quarkus 官方博客关于 Java LLM 的文章](https://quarkus.io/blog/quarkus-jlama/) 所指出的，Java 生态系统正不断拓展其 AI/机器学习能力，使开发者能够无需离开 Java 平台就能构建 LLM 驱动的应用程序。
+
+[TornadoVM](https://www.infoq.com/articles/tornadovm-java-gpu-fpga/) 起源于曼彻斯特大学的研究项目，自 2013 年以来持续发展，目标是让 Java 开发者更容易使用异构计算。该框架目前仍在不断增加后端支持并进行性能优化。
+
+## 4 当前进度
+
+GPULlama3.java 目前处于测试阶段，团队正在持续优化性能并收集基准测试数据。由于 Apple 弃用 OpenCL，当前在 Apple Silicon 上的性能不佳，TornadoVM 团队正在开发 Metal 后端，以提升兼容性并优化 Transformer 操作。
+
+
+
+## 5 总结
+
+总的来说，GPULlama3.java 的发布标志着 Java 生态在 GPU 加速 LLM 推理方面迈出了重要一步。得益于 TornadoVM 的加持，Java 开发者无需跳出熟悉的开发环境，就能享受到 GPU 加速的强大计算能力。尽管目前仍在开发中，但该项目已展示出 Java 在 AI 应用中无限的可能性，特别是在对安全性、可扩展性与可维护性有高要求的企业级场景下。
+
+对想要在 Java 中尝试 GPU 加速 LLM 推理的开发者而言，该项目已经 [开源发布于 GitHub](https://github.com/beehive-lab/GPULlama3.java)，并配有文档和示例，方便快速上手。
\ No newline at end of file
diff --git a/docs/md/AI/llm/inference-engine.md b/docs/md/AI/llm/inference-engine.md
new file mode 100644
index 000000000..cdcc4b3d1
--- /dev/null
+++ b/docs/md/AI/llm/inference-engine.md
@@ -0,0 +1,184 @@
+# 大模型的“Tomcat”：一文读懂AI推理引擎（Inference Engine)
+
+## 1 推理引擎是啥？
+
+从熟悉的“服务器”说起，想象你用Java写好了一个业务应用，如订单处理服务，打成一个JAR或WAR包。这包能直接运行吗？显然不能。你需要一个“东西”来运行它：
+
+* Java应用，这就是JVM。JVM负责解释执行你的Java字节码，管理内存，处理线程等等
+* Web应用，你可能还需一个**应用服务器**，如Tomcat或WebLogic。它在JVM基础，提供HTTP服务、Servlet容器、连接池等一系列能力，让你的Web代码能对外提供服务
+
+现在我们把主角换成大模型。AI科学家们通过海量“学习资料”（数据）和复杂“学习方法”（训练算法），最终“毕业”得到一个成果——**模型文件**。这个模型文件，好比打包好的`order-service.jar`，包含庞大网络结构和数以百亿计的参数（权重），记录模型学到的所有“知识”。
+
+这个模型文件能直接响应我们的请求，如回答“今天天气怎么样”吗？同样不能。它也需要一个“运行环境”来加载它、管理它、并高效地执行它，最终把结果（答案）输出给我们。
+
+这专门用来运行LLM的“超级应用服务器”，就是——**推理引擎 (Inference Engine)**。
+
+### 小结
+
+把训练好的大模型比作“应用程序包（JAR/WAR）”，推理引擎就是运行这个包的“应用服务器（Tomcat/WebLogic）+ JVM”的组合体。其核心任务，就是让模型**高效、稳定、经济**地对外提供服务。这过程，在AI领域叫“推理（Inference）”。
+
+## 2 没有推理引擎又如何？直接Python跑不行？
+
+Q：我看到很多AI工程师直接用Python+PyTorch/TensorFlow就能加载模型跑，为啥非搞个这么复杂推理引擎？
+
+A：好问题！这就像我们也能用`main`方法，直接`new`一个`HttpServer`启动一个Web服务，但这能直接上生产？你会遇到：
+
+* **性能极差：** 一个请求就把CPU打满了，并发能力几乎为零
+* **资源浪费：** 内存占用巨大，无法精细化管理
+* **功能缺失：** 没有日志、没有监控、没有高可用、没有动态扩缩容
+
+直接用Python框架（如PyTorch）运行模型，就面临类似问题，而且在AI场景下，这些问题会被指数级放大：
+
+### 2.1 “慢”得离谱（高延迟）
+
+**业务场景：** 用户在智能客服里问个问题，等了30秒才看到第一个字蹦出来。
+
+**技术原因：** 大模型的计算量是天文数字。一个请求过来，逐层计算，不经任何优化，就像开着一辆家用小轿车去拉一整火车的货。
+
+### 2.2 “吞”得吓人（低吞吐）
+
+**业务场景：** 数据中心支撑全集团业务，现要上线一个基于大模型的报告自动生成功能。结果发现，系统同时只能服务3、5个人，再多请求就全部卡死排队。
+
+**技术原因：** 模型会独占一块或多块GPU显卡，而GPU显存非常宝贵且昂贵。一个请求就把显存用完了，其他请求只能干等着。这就像一个只有一个窗口的银行，办完一个才能叫下一个。
+
+### 2.3 “贵”得心疼（高成本）
+
+**业务场景：** 为支撑业务，不得不堆砌大量顶级GPU卡（一张A100/H100几十万）。年终汇报时，老板一看电费和硬件采购单，脸都绿了。
+
+**技术原因：** 资源利用率极低。GPU大部分时间可能在空闲等待，或者显存被大量浪费。花了大价钱买来的“法拉利”，却一直在市区里堵着车，油耗还高得惊人。
+
+所以，直接用原生框架跑模型，只适合实验室里做研究、发论文。一旦进入生产，**推理引擎就成了必选项**。
+
+## 3 推理引擎的最佳实践
+
+推理引擎之所以能解决上述问题，是因为它在“运行”模型这件事，做大量优化和工程化工作。
+
+### 3.1 模型“瘦身术” 
+
+就像做Java应用性能优化时，会对代码重构，优化数据结构，减少不必要的对象创建。
+
+#### 3.1.1 量化 (Quantization)
+
+原始的模型参数通常32位浮点数（FP32），精度高但占空间大，计算也慢。量化就是把这些参数“降级”成16位（FP16/BF16）甚至8位整数（INT8）。好比把一个需要用`double`类型存储的数字，发现用`float`甚至`int`就够，精度损失不大，但存储空间和计算速度大大提升。
+
+#### 3.1.2 剪枝 (Pruning)
+
+科学家发现，模型里很多参数（神经元连接）其实“冗余”，对最终结果影响不大。把这些“细枝末节”砍掉，进一步减小模型体积。
+
+#### 3.1.3 最佳实践
+
+场景：你们需要在一个边缘设备或者性能没那么强的服务器上部署一个模型，用于内部的文档识别或人脸识别。
+
+推理引擎咋做：像NVIDIA的**TensorRT-LLM**、开源的**llama.cpp**等推理引擎，都内置了强大的量化工具。你只需要把原始的FP32模型丢给它，配置好量化参数（比如INT8），它就能自动帮你生成一个“瘦身”后的模型。这个新模型体积可能只有原来的1/4，推理速度提升好几倍，而识别准确率可能只下降了不到1%。对于很多业务场景来说，这种性价比极高。
+
+### 3.2 请求“拼车”大法
+
+批处理 (Batching)如数据库操作，我们会把多个单条`INSERT`合并成一个`batch insert`，减少网络和数据库IO开销。
+
+#### 3.2.1 理论概念
+
+GPU是并行计算神器，它最喜欢“干大事”：一次处理一大批相似任务。若一个一个请求喂给它，就像让一个128车道高速公路，每次只跑一辆车，巨大浪费。批处理就是把在短时间内收到的多个用户请求，“攒”成一个大大的批次（Batch），再一次性丢给GPU去计算。
+
+#### 3.2.2 最佳实践
+
+##### ① 挑战
+
+简单的批处理（静态批处理）会引入延迟，须等到凑够一个批次或超时才处理。但用户请求是动态到达的，有的长有的短。
+
+##### ② 推理引擎的进化（Continuous Batching）
+
+假设有3个用户同时请求。
+
+* 用户A：请求生成一篇500字短文
+* 用户B：请求生成一句10个字的诗
+* 用户C：请求生成一份2000字的报告
+
+传统方式： 须等最长的C请求（2000字）全部生成完毕，这个批次才算结束。A和B早就生成完了，但它们的GPU资源必须被占用着，干等着，造成巨大的浪费（显存空泡）。
+
+最佳实践：vLLM引擎的PagedAttention技术。**近两年最火的优化技术了！它的思想借鉴了操作系统的**虚拟内存分页（Paging）。把GPU显存划分成一个个固定大小“块（Block）”，一个请求来了，按需分配块，而非一次性预分配一个巨大的连续空间。当用户B的请求（10个字）生成完毕后，它占用的“块”会立刻被释放，并马上可以分配给新的等待请求。
+
+效果：这种“持续批处理”或“动态批处理”技术，将吞吐量提升**2-4倍**甚至更高！目前业界顶级的开源推理引擎，如**vLLM**、**HuggingFace TGI (Text Generation Inference)**、**TensorRT-LLM**都将此作为核心能力。作为架构师，在选择推理引擎技术栈时，支持Continuous Batching是关键考量点。
+
+### 3.3 计算“流水线”
+
+和Java多线程、微服务拆分异曲同工。一个大任务，一个人干不过来，就拆成小任务，多个人/多个服务一起干。
+
+#### 张量并行
+
+TP，Tensor Parallelism。
+
+一个模型的某层（如一个巨大的矩阵乘法）计算量太大，一张GPU卡都扛不住。就把这大矩阵“切”成几块，分给多张卡，每张卡算自己那一小块，最后再把结果合并。好比用`Fork/Join`框架处理一个大集合。
+
+#### 流水线并行
+
+PP，Pipeline Parallelism。
+
+把模型不同层（Layer）放到不同GPU。如一个模型有80层，1号GPU负责1-20层，2号GPU负责21-40层... 数据像在流水线一样，流过一张张GPU，每张GPU只做自己那部分工作。这完全就是微服务架构的思想，每个GPU就是一个“微服务”。
+
+#### 最佳实践
+
+##### 场景
+
+部署一个像Llama3-70B（700亿参数）巨型模型，单张GPU卡装不下。
+
+##### 推理引擎咋做？
+
+像**DeepSpeed Inference**、**TensorRT-LLM**这类引擎，提供成熟分布式推理能力。无需手动实现复杂的卡间通信（All-Reduce、All-Gather等），只需在配置文件中声明：“我要用4张卡跑这个模型，使用2路张量并行和2路流水线并行”。推理引擎会自动帮你完成模型的切分、部署和协同工作。
+
+这就屏蔽了底层的分布式计算复杂性，让你能像管理一个逻辑上的“大GPU”一样，去管理一个GPU集群。你的关注点，从如何实现并行，变成了如何规划并行策略以达到最佳性价比。
+
+## 4 推理引擎选型
+
+选型通常考虑**稳定性、社区活跃度、技术支持和国产化替代**等。
+
+### 4.1 NVIDIA TensorRT-LLM，重量级选手，性能标杆
+
+NVIDIA官方出品，性能优化到极致。深度绑定NVIDIA硬件生态，能最大化榨干A100/H100等显卡的性能。支持前面提到的所有高级优化。
+
+适用场景：对性能有极致要求，不差钱，且技术栈以NVIDIA为主的场景。追求业界SOTA（State-of-the-Art）性能。
+
+类比：像是Oracle数据库，性能强悍，但有厂商锁定风险。
+
+### 4.2 vLLM，开源新贵，吞吐量之王
+
+凭借其创新的PagedAttention技术，在吞吐量方面表现极其出色，迅速成为开源社区的明星项目。易用性好，Python接口友好。
+
+适用场景：高并发的在线服务场景，如智能客服、AI聊天机器人。希望快速部署，获得极高吞吐量的首选。
+
+类比：像是Nginx，轻量、高效，专注于解决高并发问题。
+
+### 4.3 Hugging Face TGI（Text Generation Inference）社区宠儿，生态完善
+
+来自最大的AI开源社区Hugging Face，对Hugging Face生态中的海量模型支持最好。功能全面，工程化成熟度高，易于部署和监控。
+
+适用场景：需要快速验证和部署多种不同类型的开源大模型。企业内部的AI中台、模型即服务（MaaS）平台的理想底座。
+
+类比：像是Spring Boot，开箱即用，生态整合能力强，能快速构建应用。
+
+### 4.4 国产推理引擎
+
+如TNN, MindSpore Lite等。
+
+**特点：** 国内厂商（如腾讯、华为）主导，更侧重于国产芯片（如昇腾、寒武纪）的适配和优化，在信创和国产化替代方面有天然优势。
+
+**适用场景：** 国企中对软硬件自主可控有强要求的项目。
+
+**类比：** 像是TongWeb、Kingdee，在特定政策和生态环境下是必然选择。
+
+### 4.5 建议
+
+* 初次接触和探索的项目，强烈推荐 **vLLM** 或 **Hugging Face TGI** 入手。都提供Docker镜像，方便在现有数据中心K8s集群拉起一个服务。可以像部署一个普通的Java微服务一样，通过RESTful API或gRPC来调用它，无缝集成到现有的Java技术栈中
+* 核心业务和性能要求极高的场景，可深入研究 **TensorRT-LLM**，它能带来极致的性能回报
+* 务必关注信创和国产化要求，提前了解和测试国产推理框架与硬件结合方案
+
+## 5 总结
+
+跳出繁杂技术细节，站在架构师高度审视：
+
+* **它是一种资源虚拟化和池化技术：** 它将昂贵、稀缺的GPU计算资源，通过批处理、并行计算等技术，池化成一个可以被多个业务方高效共享的服务。这与我们用K8s管理CPU和内存资源，用数据库连接池管理数据库连接，在思想上是完全一致的。
+* **它是一个标准的“中间件”：** 它解决了大模型这个“特殊应用”在生产环境运行时的通用问题（性能、并发、稳定性），将AI研究人员和我们业务开发人员解耦。研究员专注于模型算法，我们专注于业务逻辑和系统集成，大家各司其职。
+* **它是未来AI应用的核心基础设施：** 就像JVM之于Java，K8s之于云原生，推理引擎将成为企业“AI中台”或“MaaS平台”不可或缺的基石。
+
+虽无需直接写CUDA，不直接研究Attention机制，但理解推理引擎的原理、价值和选型策略，将是我们在AI时代保持核心竞争力的关键。它能帮助我们更好地规划企业级的AI基础设施，设计出更健壮、更高效、更具扩展性的AI赋能业务系统。
+
+希望本文帮你把“推理引擎”这个概念，从一个模糊的术语，变成一个你工具箱里清晰的、可以评估和使用的架构组件！
\ No newline at end of file
diff --git a/docs/md/AI/llm/memory-faq.md b/docs/md/AI/llm/memory-faq.md
new file mode 100644
index 000000000..45168871e
--- /dev/null
+++ b/docs/md/AI/llm/memory-faq.md
@@ -0,0 +1,133 @@
+# 解锁 ChatGPT 超能力：全新「记忆」功能深度解析
+
+## 0 📌 **注意事项**
+
+由于近期法律变化，某些服务的数据保留政策可能受到影响，详见[官方博客说明](https://openai.com/index/response-to-nyt-data-demands/)。
+
+------
+
+## 1 🆕 免费用户也能享受「记忆」功能升级！
+
+**2025 年 6 月 3 日起**，开始向已登录的 **免费用户**逐步推出「记忆能力」优化升级。现在，**ChatGPT 可参考你最近的对话内容**，从而提供更贴近你的需求、更个性化的回答。
+
+- 免费用户获得的是「轻量版记忆」，能在多轮对话中保留短期上下文信息。
+- Plus 和 Pro 用户的记忆功能则更强大，具备长期记忆能力。
+
+### 1.1 ✅ 启用方式（仅适用于欧洲地区）：
+
+对于在欧盟、英国、瑞士、挪威、冰岛或列支敦士登的免费用户，会看到提示让你启用记忆功能，或可在 **设置 > 个性化 > 记忆 > 引用聊天记录** 中手动开启。
+
+其他地区的免费用户如果已启用记忆功能，将自动获得此次升级。
+
+可随时关闭 ChatGPT 的记忆功能，选择：
+
+- 不引用“保存的记忆”
+- 不引用“聊天记录”
+
+也可用「**临时聊天**」，完全不调用或更新任何记忆内容。
+
+## 2 ☎️ 语音助手体验（仅限美国和加拿大）
+
+拨打 **1-888-GPT-0090**，即可体验 ChatGPT 的语音助手，快速获取关于 ChatGPT 及 OpenAI 产品的帮助。
+
+通话可能会用于改进服务质量。[了解更多](https://help.openai.com/en/articles/11391933-1-888-gpt-0090-ai-voice-help-over-the-phone-experimental)。
+
+## 3 🧠 ChatGPT 的记忆功能说明
+
+ChatGPT 可以在多轮对话中记住有用信息，让回答更贴合你的兴趣和需求。不论是打字、语音、还是图像请求，只要你表达过清晰的偏好，它都有可能被记住。
+
+如你告诉它：“**记住我是素食主义者，推荐食谱时请考虑这一点**”，它将会在未来对话中考虑这个偏好。
+
+你可以随时问它：“你还记得我哪些事情？”来查看当前记忆。[了解更多](https://help.openai.com/en/articles/9237897-chatgpt-search)。
+
+## 4 👤 可随时管理 ChatGPT 的记忆
+
+- 删除单条记忆
+- 清除某些或所有记忆
+- 关闭记忆功能
+- 使用「临时聊天」跳过记忆记录
+
+## 5 🧩 「记忆」功能咋运作？
+
+ChatGPT 有两种记忆设置：
+
+### 5.1 **引用保存的记忆**
+
+- 是你明确告诉 ChatGPT 要记住的内容（如姓名、爱好、饮食偏好）。
+- 类似「自定义说明」，但它是自动更新的，不需你手动管理。
+- 如果你说了某些可能在未来有用的信息，ChatGPT 也可能自动保存为记忆。
+
+> 示例：你说“我住在北京”，下次提问“周末去哪玩？”时，它可能回答“北京的好去处有……”
+>  如果你删除这条记忆，它将不再在新对话中使用，但旧对话不会自动清除相应内容。
+
+### 5.2 **引用聊天记录**
+
+- ChatGPT 会引用近期聊天内容作为上下文，用于改进响应质量。
+- 不同于保存的记忆，这类信息会根据上下文自动更新或遗忘。
+- 如果关闭“引用保存的记忆”，聊天记录引用也会一并关闭。
+
+## 6💡 启/禁用记忆功能
+
+进入 **设置 > 个性化 > 记忆**，可选：
+
+- 仅开启“引用保存的记忆”
+- 仅开启“引用聊天记录”
+- 同时开启或全部关闭
+
+> ⚠️ 关闭“引用保存的记忆”会自动关闭“引用聊天记录”。
+
+## 7 🧽 如何彻底删除某项记忆？
+
+若开启了记忆功能，想**彻底删除某条信息**，请：
+
+1. 删除「保存的记忆」；
+2. 删除包含该信息的聊天记录。
+
+否则，旧聊天中仍可能出现相关内容。
+
+## 8 📁 ChatGPT 记忆容量说明
+
+- **引用聊天记录**没有存储上限。
+- **保存的记忆**有容量限制。你可以在 **设置 > 个性化 > 管理记忆** 中查看用量。
+
+存满时，ChatGPT 不会再保存新记忆，直到你清理空间。
+
+## 9 🧾 ChatGPT 会记住敏感信息吗？
+
+处理记忆时，严肃对待用户隐私和安全：
+
+- 默认不主动记住敏感信息（如健康状况），除非你明确要求。
+- 你始终掌控自己的信息，可以随时查看、删除、关闭记忆功能。
+
+如果你不希望某些内容被记录，请不要在聊天中提及。
+
+## 10 🧠 ChatGPT 会用我的记忆来训练模型吗？
+
+只有在你**启用了“帮助改进模型”**功能时，ChatGPT 才可能使用你分享的内容（包括记忆）来改进模型表现。
+
+- 你可以随时在 **数据控制** 中关闭该功能。
+- **ChatGPT Team、Enterprise 和 Edu 用户的内容默认不会用于训练。**
+
+[了解更多数据使用政策](https://help.openai.com/en/articles/7730893-data-controls-faq)
+
+## 11 🧠 所有模型都支持记忆吗？
+
+不是所有模型都支持记忆功能。截至目前，**o1-pro 模型不支持所有用户的记忆功能**。
+
+## 12 🔍 记忆功能如何影响 ChatGPT 搜索？
+
+当你启用了记忆，并使用 **o3 或 o4-mini 模型**时，ChatGPT 可使用你的记忆或最近聊天内容来优化搜索查询。
+
+如你曾说自己是“**素食主义者，住在旧金山**”，
+
+当你问：
+
+> “我附近有什么餐厅值得推荐？”
+
+ChatGPT 可能会自动转化为：
+
+> “旧金山有哪些适合素食者的餐厅？”
+
+以提供更个性化结果。
+
+[了解更多 ChatGPT 搜索功能](https://help.openai.com/en/articles/9237897-chatgpt-search)
\ No newline at end of file
diff --git a/docs/md/AI/llm/qwen3-embedding.md b/docs/md/AI/llm/qwen3-embedding.md
new file mode 100644
index 000000000..e4973f418
--- /dev/null
+++ b/docs/md/AI/llm/qwen3-embedding.md
@@ -0,0 +1,61 @@
+# Qwen3 Embedding：新一代文本表征与排序模型
+
+qwen正式发布 Qwen3 Embedding 系列模型, Qwen 模型家族的新成员。该系列模型专为文本表征、检索与排序任务设计，基于 Qwen3 基础模型进行训练，充分继承了 Qwen3 在多语言文本理解能力方面的优势。在多项基准测试中，Qwen3 Embedding 系列在文本表征和排序任务中展现了卓越的性能。 qwen使用了 Apache 2.0 协议在 Hugging Face 和 ModelScope 上开源了这一系列的文本表征及排序模型，并在 GitHub 公布了技术报告及相关代码。
+
+![img](https://mitalinlp.oss-cn-hangzhou.aliyuncs.com/dingkun/models/qwen-embedding/q3e-mteb-result-0605.png)
+
+**排序模型评测结果**
+
+|               Model                | Param |  MTEB-R   |  CMTEB-R  |  MMTEB-R  |   MLDR    | MTEB-Code | FollowIR  |
+| :--------------------------------: | :---: | :-------: | :-------: | :-------: | :-------: | :-------: | :-------: |
+|      **Qwen3-Embedding-0.6B**      | 0.6B  |   61.82   |   71.02   |   64.64   |   50.26   |   75.41   |   5.09    |
+| Jina-multilingual-reranker-v2-base | 0.3B  |   58.22   |   63.37   |   63.73   |   39.66   |   58.98   |   -0.68   |
+|   gte-multilingual-reranker-base   | 0.3B  |   59.51   |   74.08   |   59.44   |   66.33   |   54.18   |   -1.64   |
+|         BGE-reranker-v2-m3         | 0.6B  |   57.03   |   72.16   |   58.36   |   59.51   |   41.38   |   -0.01   |
+|      **Qwen3-Reranker-0.6B**       | 0.6B  |   65.80   |   71.31   |   66.36   |   67.28   |   73.42   |   5.41    |
+|       **Qwen3-Reranker-4B**        |  4B   | **69.76** |   75.94   |   72.74   |   69.97   |   81.20   | **14.84** |
+|       **Qwen3-Reranker-8B**        |  8B   |   69.02   | **77.45** | **72.94** | **70.19** | **81.22** |   8.05    |
+
+> **Note**:
+>
+> - q'wen使用MTEB(eng, v2), MTEB(cmn, v1), MTEB (Multilingual) 以及MTEB (Code)中的检索数据集进行测试, 分别记作MTEB-R, CMTEB-R, MMTEB-R, MTEB-Code.
+> - 排序结果基于[Qwen3-Embedding-0.6B](https://huggingface.co/Qwen/Qwen3-Embedding-0.6B)的top-100向量召回结果进行排序.
+
+**主要特点**:
+
+**卓越的泛化性**: Qwen3 Embedding 系列在多个下游任务评估中达到行业领先水平。其中，8B 参数规模的Embedding模型在MTEB多语言Leaderboard榜单中位列第一（截至 2025 年 6 月 5 日，得分 **70.58**），性能超越众多商业 API 服务。此外，该系列的排序模型在各类文本检索场景中表现出色，显著提升了搜索结果的相关性。
+
+**灵活的模型架构**: Qwen3 Embedding 系列提供从 0.6B 到 8B 参数规模的 3 种模型配置，以满足不同场景下的性能与效率需求。开发者可以灵活组合表征与排序模块，实现功能扩展。此外，模型支持以下定制化特性：1) 表征维度自定义：允许用户根据实际需求调整表征维度，有效降低应用成本；2) 指令适配优化：支持用户自定义指令模板，以提升特定任务、语言或场景下的性能表现。
+
+**全面的多语言支持**: Qwen3 Embedding 系列支持超过 100 种语言，涵盖主流自然语言及多种编程语言。该系列模型具备强大的多语言、跨语言及代码检索能力，能够有效应对多语言场景下的数据处理需求。
+
+## 模型总览
+
+|     Model Type     |        Models        | Size | Layers | Sequence Length | Embedding Dimension | MRL Support | Instruction Aware |
+| :----------------: | :------------------: | :--: | :----: | :-------------: | :-----------------: | :---------: | :---------------: |
+| **Text Embedding** | Qwen3-Embedding-0.6B | 0.6B |   28   |       32K       |        1024         |     Yes     |        Yes        |
+|                    |  Qwen3-Embedding-4B  |  4B  |   36   |       32K       |        2560         |     Yes     |        Yes        |
+|                    |  Qwen3-Embedding-8B  |  8B  |   36   |       32K       |        4096         |     Yes     |        Yes        |
+| **Text Reranking** | Qwen3-Reranker-0.6B  | 0.6B |   28   |       32K       |          -          |      -      |        Yes        |
+|                    |  Qwen3-Reranker-4B   |  4B  |   36   |       32K       |          -          |      -      |        Yes        |
+|                    |  Qwen3-Reranker-8B   |  8B  |   36   |       32K       |          -          |      -      |        Yes        |
+
+注：`MRL Support` 表示 Embedding 模型是否支持最终向量的自定义维度。`Instruction Aware` 表示 Embedding 或 Reranking 模型是否支持根据不同任务定制输入指令。
+
+## 模型架构
+
+基于 Qwen3 基础模型， qwen的 Embedding 模型和 Reranking 模型分别采用了双塔结构和单塔结构的设计。通过 LoRA 微调， qwen最大限度地保留并继承了基础模型的文本理解能力。具体实现如下：1) Embedding 模型接收单段文本作为输入，取模型最后一层`[EOS]`标记对应的隐藏状态向量，作为输入文本的语义表示；2) Reranking 模型则接收文本对（例如用户查询与候选文档）作为输入，利用单塔结构计算并输出两个文本的相关性得分。
+
+![img](https://mitalinlp.oss-cn-hangzhou.aliyuncs.com/dingkun/models/qwen-embedding/q3e-model-arc.png)
+
+## 模型训练
+
+Qwen3 Embedding 系列模型的训练继承了 GTE-Qwen 系列的多阶段训练范式，但针对具体应用场景进行了深度优化。在 Embedding 模型的训练过程中， qwen采用三阶段训练架构：第一阶段通过超大规模弱监督数据进行对比学习预训练；第二阶段基于高质量标注数据进行监督训练；最终通过模型融合策略融合多个候选模型，以提升整体性能。这种分阶段训练机制有效平衡了模型的泛化能力与任务适配性。
+
+在 Reranking 模型的训练中，基于实验验证结果， qwen直接采用高质量标注数据进行监督训练，以提升训练效率。特别需要说明的是，在 Embedding 模型的第一阶段弱监督训练中， qwen构建了多任务适配的 Prompt 体系，利用 Qwen3 基础模型的文本生成能力， qwen针对不同任务类型和语言特性，动态生成了一系列弱监督文本对，突破了传统方法依赖社区论坛或开源数据筛选获取弱监督文本对的局限性，实现了大规模弱监督数据的高效生成。
+
+![](https://mitalinlp.oss-cn-hangzhou.aliyuncs.com/dingkun/models/qwen-embedding/q3e-train-pipeline.png)
+
+## 未来发展
+
+Qwen3 Embedding 系列模型是一个新的起点，依托于 Qwen 基础模型的持续优化,  qwen将继续提升文本表征与排序模型的训练效率，以增强模型在实际场景中的部署性能。此外， qwen还计划拓展多模态表征体系，构建跨模态语义理解能力。 qwen期待更多开发者基于 Qwen3 Embedding 系列探索更广泛的应用场景，推动模型在不同业务场景中的深入应用。
\ No newline at end of file
diff --git a/docs/md/MQTT/avoid-bare-parsefrom-mqtt-protobuf-consumption.md b/docs/md/MQTT/avoid-bare-parsefrom-mqtt-protobuf-consumption.md
new file mode 100644
index 000000000..6329eaeae
--- /dev/null
+++ b/docs/md/MQTT/avoid-bare-parsefrom-mqtt-protobuf-consumption.md
@@ -0,0 +1,322 @@
+# 别再裸写 parseFrom() 了！这才是 MQTT + Protobuf 消费的正确姿势
+
+## 0 前言
+
+很多刚接触这个技术栈的同学，可能会觉得有点绕。MQTT 负责传输，Protobuf 负责定义数据结构，听起来是天作之合，但具体到代码层，咋写最“哇塞”？本文以车联网（V2X）场景为例，把这个事儿聊透，让你不仅知其然，更知其所以然。
+
+咱们的案例原型就是这段非常
+
+## 1 典型的 `.proto` 文件
+
+```protobuf
+syntax = "proto3";
+option java_multiple_files = true;
+option java_package = "cn.javaedge.v2x.protocol";
+package cn.javaedge.v2x.pb;
+
+enum Message_Type {
+    UKNOWN_MSG = 0;
+    OBJECT_MSG = 1;
+    EVENT_MSG = 2;
+    // ... 其他消息类型
+    CAM_MSG = 11;
+    DENM_MSG = 12;
+}
+
+// 消息体定义，如车辆消息
+message VehicleMessage {
+    string vehicle_id = 1;
+    double longitude = 2;
+    double latitude = 3;
+    float speed = 4;
+    // ... 其他车辆信息
+}
+```
+
+实际业务中，通常会有一个统一的“信封”消息，里面包含消息类型和真正的业务数据包。
+
+需求明确：Java服务作MQTT客户端，订阅某Topic，源源不断收到二进制数据。这些数据就是用上面这 `.proto` 文件定义的 `VehicleMessage` 序列化后的结果。我们的任务就是把它**高效、健壮**地解码出来。
+
+## 2 核心思路：从“能跑就行”到“最佳实践”
+
+很多同学第一反应直接在 MQTT 的 `messageArrived` 回调方法写一堆 `try-catch`，再调用 Protobuf 的 `parseFrom()` 方法：
+
+```java
+// 伪代码：一个“能跑就行”的例子
+public void messageArrived(String topic, MqttMessage message) {
+    try {
+        byte[] payload = message.getPayload();
+        VehicleMessage vehicleMsg = VehicleMessage.parseFrom(payload);
+        // ... 处理 vehicleMsg ...
+        System.out.println("收到车辆消息: " + vehicleMsg.getVehicleId());
+    } catch (InvalidProtocolBufferException e) {
+        // ... 打印个日志 ...
+        e.printStackTrace();
+    }
+}
+```
+
+这段代码能工作吗？当然能。但在高并发、要求高可用、业务逻辑复杂的生产环境中，这远远不够。它就像一辆只有发动机和轮子的裸车，能跑，但一阵风雨就可能让它趴窝。
+
+最佳实践是啥？，建立一套**分层、解耦、易于维护和扩展**的处理流程。
+
+## 3 最佳实践：构建稳如泰山的 Protobuf 解析层
+
+让我们把这个过程拆解成几个关键步骤，并逐一优化。
+
+### 3.1 Protobuf代码生成与依赖管理
+
+构建阶段，看似准备工作，却是保证后续一切顺利的基石。
+
+#### 使用 Maven插件自动生成代码
+
+别手动执行 `protoc` 命令，再把生成的 `.java` 文件拷贝到项目里。这是“上古时期”做法。现代化的构建工具能完美解决这个问题。
+
+Maven示例：
+
+```xml
+<dependencies>
+    <dependency>
+        <groupId>com.google.protobuf</groupId>
+        <artifactId>protobuf-java</artifactId>
+        <version>3.25.3</version> </dependency>
+    <dependency>
+        <groupId>org.eclipse.paho</groupId>
+        <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
+        <version>1.2.5</version>
+    </dependency>
+</dependencies>
+
+<build>
+    <plugins>
+        <plugin>
+            <groupId>org.xolstice.maven.plugins</groupId>
+            <artifactId>protobuf-maven-plugin</artifactId>
+            <version>0.6.1</version>
+            <configuration>
+                <protocArtifact>com.google.protobuf:protoc:3.25.3:exe:${os.detected.classifier}</protocArtifact>
+                <protoSourceRoot>${project.basedir}/src/main/proto</protoSourceRoot>
+                <outputDirectory>${project.build.directory}/generated-sources/protobuf/java</outputDirectory>
+                <clearOutputDirectory>false</clearOutputDirectory>
+            </configuration>
+            <executions>
+                <execution>
+                    <goals>
+                        <goal>compile</goal>
+                        <goal>test-compile</goal>
+                    </goals>
+                </execution>
+            </executions>
+        </plugin>
+    </plugins>
+</build>
+```
+
+#### 这样做的好处
+
+1.  **自动化**：每次构建项目时，都会自动检查 `.proto` 文件是否有更新，并重新生成 Java 类
+2.  **版本一致性**：确保 `protoc` 编译器版本和 `protobuf-java` 运行时库版本的一致，避免因版本不匹配导致的各种诡异错误
+3.  **IDE 友好**：IDEA能很好识别这些生成的源代码，提供代码补全和导航
+
+### 3.2 定义清晰的解析器接口
+
+设计模式的应用，直接在 MQTT 回调里写解析逻辑，违反**单一职责原则**。MQTT 客户端的核心职责是网络通信，不应关心消息体的具体格式。
+
+应将解析逻辑抽象出来：
+
+```java
+// 定义一个通用的反序列化器接口
+public interface MessageDeserializer<T> {
+    /**
+     * 将字节数组反序列化为指定类型的对象
+     * @param data 原始字节数据
+     * @return 反序列化后的对象
+     * @throws DeserializationException 如果解析失败
+     */
+    T deserialize(byte[] data) throws DeserializationException;
+}
+
+// 定义一个自定义的解析异常
+public class DeserializationException extends RuntimeException {
+    public DeserializationException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
+```
+
+然后，为我们的 `VehicleMessage` 实现该接口：
+
+```java
+import com.google.protobuf.InvalidProtocolBufferException;
+import cn.javaedge.v2x.pb.VehicleMessage; // 自动生成的类
+
+public class VehicleMessageDeserializer implements MessageDeserializer<VehicleMessage> {
+
+    @Override
+    public VehicleMessage deserialize(byte[] data) throws DeserializationException {
+        if (data == null || data.length == 0) {
+            // 对于空消息体，根据业务决定是抛异常还是返回 null/默认实例
+            throw new DeserializationException("Payload is empty.", null);
+        }
+        try {
+            // 核心解析逻辑
+            return VehicleMessage.parseFrom(data);
+        } catch (InvalidProtocolBufferException e) {
+            // 关键：将底层具体的异常，包装成我们自己的业务异常
+            // 这样上层调用者就不需要关心是 Protobuf 还是 JSON 或是其他格式的错误
+            throw new DeserializationException("Failed to parse VehicleMessage from protobuf", e);
+        }
+    }
+}
+```
+
+#### 好处
+
+1.  **解耦**：MQTT 消费者代码与 Protobuf 解析逻辑完全分离。未来如果想把数据格式从 Protobuf 换成 JSON，只需要换一个 `MessageDeserializer` 的实现类即可，消费者代码一行都不用改。
+2.  **职责单一**：`VehicleMessageDeserializer` 只干一件事：解析 `VehicleMessage`。代码清晰，易于测试。
+3.  **统一异常处理**：通过自定义的 `DeserializationException`，我们将底层的 `InvalidProtocolBufferException` 进行了封装。上层代码只需要捕获 `DeserializationException`，大大简化了错误处理逻辑。
+
+### 3.3 在 MQTT 消费者中优雅地使用解析器
+
+组合与分发。现在，MQTT消费者变得清爽：
+
+```java
+public class MqttConsumerService {
+
+    private final MessageDeserializer<VehicleMessage> vehicleMessageDeserializer;
+    private final BusinessLogicHandler businessLogicHandler; // 负责处理业务逻辑的服务
+
+    // 使用依赖注入来管理依赖关系
+    public MqttConsumerService(BusinessLogicHandler businessLogicHandler) {
+        this.vehicleMessageDeserializer = new VehicleMessageDeserializer(); // 在真实项目中会通过 IoC 容器注入
+        this.businessLogicHandler = businessLogicHandler;
+    }
+
+    // MQTT 回调方法
+    public void onMessageReceived(String topic, byte[] payload) {
+        try {
+            // 1. 调用解析器进行反序列化
+            VehicleMessage vehicleMsg = vehicleMessageDeserializer.deserialize(payload);
+
+            // 2. 将解析后的强类型对象传递给业务逻辑层
+            businessLogicHandler.processVehicleMessage(vehicleMsg);
+
+        } catch (DeserializationException e) {
+            // 集中处理解析失败的情况
+            // 比如：记录错误日志、发送到死信队列(DLQ)等待人工处理
+            log.error("Failed to deserialize message from topic [{}].", topic, e);
+            // sendToDeadLetterQueue(topic, payload, e.getMessage());
+        } catch (Exception e) {
+            // 捕获其他未知异常，防止消费者线程挂掉
+            log.error("An unexpected error occurred while processing message from topic [{}].", topic, e);
+        }
+    }
+}
+```
+
+#### 架构精髓
+
+##### ① 依赖注入 (DI)
+
+通过构造函数注入依赖（解析器和业务处理器），而不是在方法内部 `new` 对象。这使得整个服务非常容易进行单元测试。我们可以轻易地 mock `MessageDeserializer` 来测试 `MqttConsumerService` 的逻辑，而不需要真实的 Protobuf 数据。
+
+##### ② 关注点分离 (SoC)
+
+* `MqttConsumerService`：负责从 MQTT 接收字节流，协调解析和业务处理的流程，并统一处理异常。
+* `VehicleMessageDeserializer`：负责将字节流转换为 `VehicleMessage` 对象。
+* `BusinessLogicHandler`：负责拿到 `VehicleMessage` 对象后所有的业务计算和处理。
+
+##### ③ 健壮的异常处理
+
+* **区分已知和未知异常**：我们明确捕获 `DeserializationException`，这是“已知”的解析失败，通常意味着消息格式有问题。对于这种消息，最佳实践是**隔离**它，比如发送到“死信队列”，避免它反复阻塞正常消息的处理。
+* **捕获顶级 `Exception`**：这是一个保护性措施，确保任何意想不到的错误（比如空指针、业务逻辑层的运行时异常）都不会导致整个 MQTT 消费者线程崩溃。
+
+## 4 进阶：应对真实世界的复杂性
+
+上面的架构已很优秀，但更复杂场景下，还需考虑更多。
+
+### 4.1 多消息类型处理 (Message Dispatching)
+
+通常一个 MQTT Topic 不会只有一种消息类型。还记得我们 `.proto` 文件里的 `Message_Type` 枚举吗？这正是用于区分不同消息的。
+
+实际的 Protobuf 结构通常是这样的“信封模式” (Envelope Pattern)：
+
+```proto
+message UniversalMessage {
+    Message_Type type = 1;
+    google.protobuf.Any payload = 2; // 使用 Any 来包装任意类型的消息
+}
+```
+
+`google.protobuf.Any` 是 Protobuf 的一个标准类型，可以包含任意一种 Protobuf 消息。
+
+消费者的逻辑就需要升级为一个**分发器 (Dispatcher)**：
+
+```java
+public class UniversalMessageDispatcher {
+
+    // 一个注册表，存储消息类型到具体解析器的映射
+    private final Map<String, MessageDeserializer<?>> deserializerRegistry = new HashMap<>();
+
+    public UniversalMessageDispatcher() {
+        // 在构造时注册所有已知的解析器
+        deserializerRegistry.put(VehicleMessage.getDescriptor().getFullName(), new VehicleMessageDeserializer());
+        // ... 注册其他消息类型的解析器
+        // deserializerRegistry.put(EventMessage.getDescriptor().getFullName(), new EventMessageDeserializer());
+    }
+
+    public void dispatch(byte[] payload) {
+        try {
+            UniversalMessage envelope = UniversalMessage.parseFrom(payload);
+            Any messagePayload = envelope.getPayload();
+            String messageTypeUrl = messagePayload.getTypeUrl(); // e.g., "type.googleapis.com/cn.javaedge.v2x.pb.VehicleMessage"
+            String messageFullName = extractFullNameFromUrl(messageTypeUrl);
+
+            MessageDeserializer<?> deserializer = deserializerRegistry.get(messageFullName);
+            if (deserializer != null) {
+                // 使用 Any 的 unpack 方法来安全地解包
+                if (messageFullName.equals(VehicleMessage.getDescriptor().getFullName())) {
+                    VehicleMessage vehicleMsg = messagePayload.unpack(VehicleMessage.class);
+                    // ... 交给对应的业务处理器 ...
+                } else if (...) {
+                    // ... 处理其他消息类型 ...
+                }
+            } else {
+                log.warn("No deserializer found for message type: {}", messageFullName);
+            }
+        } catch (InvalidProtocolBufferException e) {
+            throw new DeserializationException("Failed to parse UniversalMessage envelope", e);
+        }
+    }
+
+    private String extractFullNameFromUrl(String url) {
+        return url.substring(url.lastIndexOf('/') + 1);
+    }
+}
+```
+
+这种基于“注册表”和 `Any` 类型的分发模式，是处理多消息类型时**扩展性最好**的方案。
+
+### 4.2 性能考量：对象池与零拷贝
+
+高吞吐量场景下（如每秒处理成千上万条消息），频繁创建和销毁 `VehicleMessage` 对象会给 GC 带来巨大压力。
+
+#### 对象池技术
+
+可以使用像 Apache Commons Pool2 这样的库，来复用 `VehicleMessage.Builder` 对象。解析时，从池中获取一个 Builder，用 `mergeFrom()` 方法填充数据，构建出 `VehicleMessage` 对象，使用完毕后再将 Builder 清理并归还到池中。
+
+#### 零拷贝
+
+Protobuf 的 `ByteString` 类型在内部做很多优化，可实现对底层 `byte[]` 的“零拷贝”引用。在传递数据时，尽量传递 `ByteString` 而非 `byte[]`，可减少不必要的内存复制。
+
+## 5 总结
+
+从一个简单的 `parseFrom()` 调用，逐步构建一套企业级 MQTT-Protobuf 消费方案。
+
+1.  **构建自动化**：Maven插件管理 Protobuf 代码生成，告别刀耕火种
+2.  **设计模式先行**：定义 `MessageDeserializer` 接口，实现**策略模式**，解耦【解析】与【消费】逻辑
+3.  **分层与解耦**：将流程清晰划分为**网络接入层** (MQTT Client)、**反序列化层** (Deserializer) 和**业务逻辑层** (Handler)，职责分明，易维护
+4.  **健壮的错误处理**：封装自定义异常，并设计了对解析失败消息的隔离机制（如死信队列），保证系统的韧性
+5.  **面向未来的扩展性**：引入“信封模式”和“分发器”，从容应对未来不断增加的新消息类型
+
+**优秀的代码不仅是让机器读懂，更是让同事（及半年后的自己）轻松读懂**。核心思想即通过**抽象、解耦和分层**，来管理软件的复杂性。
\ No newline at end of file
diff --git "a/docs/md/mqtt/MQTT\344\270\216Kafka\345\234\250\347\211\251\350\201\224\347\275\221\346\266\210\346\201\257\344\270\216\346\265\201\346\225\260\346\215\256\351\233\206\346\210\220\345\256\236\350\267\265.md" b/docs/md/MQTT/mqtt-kafka-iot-message-streaming-integration.md
similarity index 100%
rename from "docs/md/mqtt/MQTT\344\270\216Kafka\345\234\250\347\211\251\350\201\224\347\275\221\346\266\210\346\201\257\344\270\216\346\265\201\346\225\260\346\215\256\351\233\206\346\210\220\345\256\236\350\267\265.md"
rename to docs/md/MQTT/mqtt-kafka-iot-message-streaming-integration.md
diff --git "a/docs/md/MQTT/07-MQTT\345\217\221\345\270\203\350\256\242\351\230\205\346\250\241\345\274\217\344\273\213\347\273\215.md" b/docs/md/MQTT/mqtt-publish-subscribe-intro.md
similarity index 100%
rename from "docs/md/MQTT/07-MQTT\345\217\221\345\270\203\350\256\242\351\230\205\346\250\241\345\274\217\344\273\213\347\273\215.md"
rename to docs/md/MQTT/mqtt-publish-subscribe-intro.md
diff --git "a/docs/md/chain/\351\232\220\347\247\201\350\256\241\347\256\227\346\212\200\346\234\257\345\216\237\347\220\206.md" "b/docs/md/chain/\351\232\220\347\247\201\350\256\241\347\256\227\346\212\200\346\234\257\345\216\237\347\220\206.md"
new file mode 100644
index 000000000..356507e66
--- /dev/null
+++ "b/docs/md/chain/\351\232\220\347\247\201\350\256\241\347\256\227\346\212\200\346\234\257\345\216\237\347\220\206.md"
@@ -0,0 +1,259 @@
+# 隐私计算技术原理
+
+## 0 隐私计算核心原理概述
+
+隐私计算目标是让各方在**数据“可用不可见”**的前提下进行联合计算。常见技术包括：
+
+## 1 联合建模
+
+Joint Modeling。
+
+### 1.1 定义
+
+多个参与方共同训练一个机器学习模型，但各自的数据不离开本地。在满足各参与方的合规政策和数据价值保护的需求下，实现模型迭代和更新的服务。
+
+### 1.2 类比理解
+
+就像几个医生一起研究某种疾病的治疗方案，但每位医生只分享“经验总结”（如模型参数），而不透露具体的病人信息。
+
+### 1.3 实际应用
+
+- 多家保险公司想共同训练一个新能源汽车保险风险评估模型，但每家都只能用自己的客户数据
+- 让大家共享模型能力，而不把原始数据给别人
+
+### 1.4 技术实现
+
+联邦学习或多方安全计算。
+
+## 2 可信执行环境
+
+Trusted Execution Environment，TEE。
+
+### 2.1 定义
+
+利用硬件级隔离技术（如Intel SGX、ARM TrustZone），在一个“沙盒”中执行敏感代码，外界无法窥探其中的数据。
+
+### 1.2 类比理解
+
+就像在金库处理现金，只有特定人员能进去操作，外面的人看不见也摸不到。
+
+### 1.3 实际应用
+
+- 在 TEE 中运行保险公司的评分算法，即使平台管理员也无法看到内部逻辑和数据
+- 适合对性能要求高、但又必须保证安全的场景
+
+### 1.4 技术实现
+
+依赖 CPU 的安全扩展指令集，如Intel SGX。
+
+利用硬件隔离确保计算过程安全可证明。在TEE中，数据和算法在硬件隔离区内处理，即使操作系统被攻破，数据仍受保护。
+
+## 3 同态加密（HE）
+
+Homomorphic Encryption。
+
+### 3.1 定义
+
+允许在加密数据上直接进行运算，结果解密后与明文运算一致。
+
+### 3.2 类比理解
+
+你把一封信锁进密码箱里，送到朋友那里，他可以在不解锁的情况下帮你算里面的内容总和，再寄回来你打开看结果。
+
+### 3.3 实际应用
+
+- 对新能源车的电池评分进行加密传输，接收方可以直接在这个加密数据上做评分计算，无需先解密
+- 适合需要完全隐藏数据内容的场景
+
+### 3.4 技术实现方式
+
+使用复杂的数学结构（如 Ring-LWE、CKKS 方案），Java 中可调用 C++ 库封装接口（如 Microsoft SEAL）。
+
+对数据进行加密后，在密文上直接运算，最后解密得到结果。HE 允许对敏感数据进行复杂计算，但性能开销大。
+
+## 4 差分隐私（DP）
+
+Differential Privacy。通过加入噪声保护单个记录隐私，常用于数据发布和统计分析。DP 与上述技术常结合使用，进一步降低泄露风险。
+
+以上技术可单独或混合使用。例如如锘崴所述，隐私计算通过 MPC、HE、FL（软件层）和 TEE（硬件层）等多种路径协同工作。车联网场景中，即可在**汽车本地或边缘节点**进行模型训练和推理，而无需上传车主敏感数据，并在跨机构聚合时使用 MPC/HE 等加密技术，兼顾数据隐私与高效建模。
+
+### 定义
+
+在统计数据时加入随机噪声，使得输出结果对任意个体的存在与否不敏感，从而保护隐私。
+
+### 类比理解
+
+你问一群人平均工资，每个人回答前偷偷给自己工资加上一个随机数，这样最终的平均值还是大致准确，但没人知道谁说了实话。
+
+### 实际应用
+
+- 统计新能源车用户的驾驶习惯（如急刹车频率），但不希望任何人被识别出来。
+- 常用于数据发布、统计分析。
+
+### 技术实现
+
+- 使用拉普拉斯噪声、指数机制等
+- 可以集成到 SQL 查询引擎或机器学习框架中
+
+## 5 隐匿查询（PIR）
+
+Private Information Retrieval。
+
+### 5.1 定义
+
+用户可从DB查询某数据，但DB不知用户查了哪条。
+
+### 5.2 类比理解
+
+你在图书馆借书，但图书管理员不知道你借的哪本。
+
+### 5.3 实际应用
+
+- 用户想查某辆车的历史维修记录，但不想让数据中心知道是哪辆车。
+- 适用于保护用户行为隐私的场景。
+
+### 5.4 技术实现
+
+使用加密查询协议，部分基于同态加密。
+
+## 6 隐私求交（PSI）
+
+Private Set Intersection。
+
+### 定义
+
+两个集合找出交集，但彼此不知对方的非交集元素。
+
+### 类比理解
+
+两个人想知道有没有共同的朋友，但不想告诉对方自己所有的朋友名单。
+
+### 实际应用
+
+- 两家公司想找出共同客户，但不能交换全部客户名单
+- 保险公司和车企想找出哪些用户既是投保人又是车主
+
+### 技术实现
+
+使用Oblivious Transfer（OT）、哈希+加密等方法。
+
+## 7 多方安全分析（MSA）
+
+Secure Multi-Party Analysis。
+
+### 定义
+
+多个参与方在不共享原始数据的前提下，完成数据分析任务（如统计、回归、聚类等）。
+
+### 类比理解
+
+就像几个公司想统计他们员工的平均薪资，但每个公司只想贡献“汇总后的统计量”。
+
+### 💡 实际应用：
+
+- 多个城市想比较新能源汽车的充电频率，但不希望暴露各自城市的详细数据。
+- 医疗机构之间想共享疾病分布情况，但不能泄露患者身份。
+
+### 技术实现方式
+
+结合 MPC、HE、DP 等多种技术。
+
+## 8 多方安全计算（MPC）必备
+
+Secure Multi-Party Computation，MPC，在参与方不共享各自数据且没有可信第三方的情况下安全地计算约定函数的技术和系统。
+
+![](https://p.ipic.vip/h2aerh.png)
+
+各方将数据加密或秘密共享，在加密状态下共同计算函数，最终只输出结果。
+
+参与方不泄露原始数据，通过加密状态协同得到计算结果。
+
+多方将数据加密分片，分别计算，最终合成结果，任何单方看不到完整数据。
+
+### 类比理解
+
+就像几个人在黑暗中同时写下一个数字，通过某种机制知道这些数加起来多少，但不知道别人写了啥。
+
+### 应用
+
+- 几个公司想知道他们的用户有多少是重叠的，但不想暴露各自的用户列表（隐私求交 PSI 就是它的一个子集）。
+- 银行之间想统计总贷款额，但不想告诉对方自己的具体数据。
+
+### 技术实现
+
+设计特殊加密算法（如 Yao’s Garbled Circuits、秘密共享等）和协议，基于密码学原理实现在无可信第三方情况下，多个参与方将明文形式的数据加密后或转化后再提供给其他方，任一参与方都无法接触到其他方的明文形式的数据，从而保证各方数据的安全。
+
+安全多方计算的基本安全算子包括同态加密、秘密分享、混淆电路、不经意传输、零知识证明、同态承诺等。
+
+![img](https://www.primihub.com/img/anquanjisuan.4586f50f.png)
+
+## 9 联邦学习（FL）必备
+
+Federated Learning。
+
+### 定义
+
+一种分布式机器学习方法，允许多个参与方协同训练模型，但不共享原始数据。
+
+各方本地训练模型，将加密参数汇聚更新，实现模型共享。“数据不出门，算法满地跑”。可结合安全聚合、MPC 等增强隐私。像是分布式机器学习的参数交换，避免数据直接暴露。
+
+可让一组组织或同一组织内的群组以协作和迭代的方式，训练和改进共享的全局机器学习模型。参与方通过安全的算法协议进行联合机器学习，可以在各方数据不出本地的情况下联合多方数据源建模和提供模型推理与预测服务。
+
+在FL框架下，各参与方只交换密文形式的中间计算结果或转化结果，不交换数据，达到数据可用不可见。
+
+#### 联邦模型一
+
+![](https://p.ipic.vip/4n86te.png)
+
+#### 联邦模型二
+
+![](https://p.ipic.vip/v3wrf4.png)
+
+### 类比理解
+
+像一群学生一起做题，每个人都在自己的练习本上算，最后只告诉老师答案的“趋势”，老师再统一调整教学内容。
+
+### 实际应用
+
+新能源车企与保险公司合作：车企提供车辆运行数据（如电池状态、行驶轨迹），保险公司提供理赔数据，双方都不交出原始数据，但可以共同训练一个更准确的风险预测模型。
+
+### 技术实现
+
+- 使用加密梯度聚合（如同态加密或差分隐私）
+- 支持横向/纵向联邦学习
+
+##### 横/纵向联邦学习
+
+| 类型                          | 特点                             | 示例                                           |
+| ----------------------------- | -------------------------------- | ---------------------------------------------- |
+| 横向联邦学习（Horizontal FL） | 参与方拥有相同的特征，不同的样本 | 多家银行都有贷款记录，但各自有不同的客户       |
+| 纵向联邦学习（Vertical FL）   | 参与方拥有相同的样本，不同的特征 | 同一家客户，银行有收入数据，保险公司有健康数据 |
+
+## 选型建议
+
+### 开源 V.S 商业
+
+开源项目隐语免费且可深度定制，适合研发团队评估或基础研究。但需要投入部署运维成本。
+
+商业平台（蚂蚁、锘崴、腾讯等）提供了更完善的产品支持和界面，适合快速落地或生产环境，但往往费用较高，且对算法改动有限制。
+
+### 部署环境
+
+若需要在**本地或私有云**部署，应关注系统对 Docker/Kubernetes 的支持、平台稳定性和可扩展性。隐语支持容器化部署。若更倾向**云服务**，可直接使用蚂蚁或腾讯提供的 PaaS，不必自行搭建环境。
+
+### 自定义算法和数据控制
+
+对于需要上传自研算法的需求，应选择支持“算法沙箱”或脚本扩展的平台。
+
+- PrimiHub、FATE、Huakong 清交等支持用户自定义模型和协议扩展
+- 商业云产品通常只提供固定算子，也可通过SDK接口进行二次开发
+
+### 性能与安全要求
+
+- 数据量巨大或安全级别要求极高，可考虑软硬结合方案（锘崴、清交）或专用加速卡
+- 普通业务场景，纯软件方案（开源或云服务）即可满足需求
+
+综上，根据团队技术栈和业务场景平衡可控性与易用性：
+
+- **测试评估阶段**可选择开源平台快速搭建原型；
+- **生产应用阶段**则可视实际情况选用商业平台或混合方案
\ No newline at end of file
diff --git a/docs/md/design/open-close-principle.md b/docs/md/design/open-close-principle.md
new file mode 100644
index 000000000..2b5c52a02
--- /dev/null
+++ b/docs/md/design/open-close-principle.md
@@ -0,0 +1,349 @@
+# 开闭原则（Open Close Principle，OCP）
+
+## 1 定义
+
+来个需求就改一次代码，理所当然？反正修改也易，再CV一份，也不费脑。但每人每次改点，日积月累，再来新需求，后人改动量就大了。每人都无辜，都只是简单修改一点。但最终导致接盘侠无法维护，直接推翻老系统，写新系统（也算是创造就业机会了）。
+
+既然“修改”这么多问题，不修改行吗？就得精通OCP。
+
+`Software entities like classes,modules and functions should be open for extension but closed for modifications`
+一个软件实体如类、模块和方法应对扩展开放，对修改关闭。这是Bertrand Meyer在《面向对象软件构造》（Object-Oriented Software Construction）提出，它给软件设计提出极高要求：不修改代码，对扩展开放。可问题：
+
+- 开放啥？
+- 对修改关闭，咋关闭？
+
+### 1.1 不修改代码，还能写需求？
+
+扩展，即新需求用新代码实现。OCP向我们描述的是结果：可不修改代码，仅靠扩展就完成新功能。
+
+#### 前提
+
+在软件内部留好扩展点，这就需要设计（高级工程师的素质了）。每个扩展点都是个需要设计的模型。
+
+### 1.2 用抽象构建框架，用实现扩展细节
+
+一个软件实体应通过扩展实现变化，而不是通过修改已有代码实现变化。它是为软件实体的未来事件而制定的对现行开发设计进行约束的一个原则。
+
+## 2 案例 - 书店
+
+###  2.1 源码
+
+```java
+package com.javaedge.design.principle.openclose;
+
+/**
+ * 书籍接口
+ * 
+ * @author JavaEdge
+ */
+public interface BaseBook {
+
+    /**
+     * 获取书籍 ID
+     *
+     * @return 书籍 ID
+     */
+    Integer getId();
+
+    /**
+     * 获取书籍名
+     *
+     * @return 书籍名
+     */
+    String getName();
+
+    /**
+     * 获取书籍价
+     *
+     * @return 书籍价
+     */
+    Double getPrice();
+}
+```
+
+```java
+/**
+ * Java书籍实现类
+ * 
+ * @author JavaEdge
+ */
+@AllArgsConstructor
+@Getter
+@Setter
+public class JavaBook implements BaseBook {
+
+    private Integer id;
+
+    private String name;
+
+    private Double price;
+}
+```
+
+```java
+/**
+ * 测试类
+ *
+ * @author JavaEdge
+ */
+@Slf4j
+public class Test {
+    public static void main(String[] args) {
+        JavaBook baseCourse = new JavaBook(66, "Java编程思想", 98d);
+
+        JavaDiscountBook discountBook = (JavaDiscountBook) baseCourse;
+        log.info("书籍ID:" + discountBook.getId() +
+                " 书籍名称:" + discountBook.getName() +
+                " 书籍原价:" + discountBook.getPrice() +
+                "书籍优惠价:" + discountBook.getDiscountPrice());
+    }
+}
+```
+
+### 2.2 需求
+
+新增一个折扣优惠方法：若直接修改原接口，则每个实现类都得重新添加方法实现。但接口应稳定，不应频繁修改！
+
+```java
+package com.javaedge.design.principle.openclose;
+
+/**
+ * Java 书籍折扣类
+ *
+ * @author JavaEdge
+ */
+public class JavaDiscountBook extends JavaBook {
+
+    public JavaDiscountBook(Integer id, String name, Double price) {
+        super(id, name, price);
+    }
+
+    public Double getDiscountPrice() {
+        return super.getPrice() * 0.8;
+    }
+}
+```
+
+现UML：
+
+![](https://p.ipic.vip/ix904j.png)
+
+`接口应稳定且可靠，不应经常变化`，否则接口作为契约的作用就失去效能。
+
+### 2.3 修改实现类
+
+在getPrice()实现打折处理，低级程序员都习惯这样通过class文件替换，极速完成部分业务变化（或bugfix）。
+
+该方法在项目有明确章程（团队内约束）或优良架构设计时，很优秀，但若采购书籍人员也要看价格，由于该方法已实现打折处理价格，因此采购人员看到也是折后价，会`因信息不对称而出现决策失误`。因此，这不是最优解。
+
+### 2.4 通过扩展实现变化
+
+`增加子类`OffNovelBook，重写getPrice，高层次模块（static静态模块区）通过OffNovelBook类产生新对象，完成业务变化对系统的最小化开发。
+
+好办法！修改少，风险也小。
+
+OCP对扩展开放，对修改关闭，但并不是说不做任何修改，低层模块的变更，必然要与高层模块耦合，否则就是孤立无意义的代码段。
+
+## 3 变化的类型
+
+### 3.1 逻辑变化
+
+只变化一个逻辑，不涉及其它模块。如原算法`a*b+c`，要修改为`a*b*c`，那就直接修改原有类中的方法，但前提条件：所有依赖或关联类都按相同逻辑处理。
+
+### 3.2 子模块变化
+
+一个模块变化，会对其他的模块产生影响，特别是一个低层次的模块变化必然引起高层模块的变化，因此在通过扩展完成变化时，高层次的模块修改是必然的。
+
+### 3.3 可见视图变化
+
+如Swing。若仅是按钮、文字重排还简单，最司空见惯的是业务耦合变化一个展示数据的列表，按原有需求是6列，突然要增加1列，而且这一列要跨N张表，处理M个逻辑才能展现，这样的变化是恐怖的，但还是能通过扩展完成变化。
+
+### 3.4 小结
+
+放弃修改历史的想法吧！一个项目的基本路径：项目开发、重构、测试、投产、运维。
+
+- 重构，可对原有设计和代码进行修改
+- 运维，尽量减少对原有代码的修改，保持历史代码的纯洁性，提高系统稳定性
+
+## 4 案例 - 酒店会员
+
+开发酒店CRS系统，针对不同用户，计算不同房价：
+
+- 普通用户全价
+- 金卡8折
+- 银卡9折
+
+代码可能：
+![](https://img-blog.csdnimg.cn/d74b8a7ac93f45a0b259be02bffe8c75.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+
+### 4.1 新需求
+
+增加白金会员75折，CV大法好：
+![](https://img-blog.csdnimg.cn/e35d591b809f47bdbc8788bd6766e102.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+
+这就是【修改代码】，每增加一个新类型，就修改一次代码。
+但一个有各种级别用户的酒店系统肯定不只房价不同，提供服务也可能有区别，如是否有早餐？预付现付？优惠券力度、连住优惠规则？。可预见，每增加一个用户级别，要改的代码散布各地。
+
+### 4.2 何解？
+
+应考虑设计成可扩展模型。既然每次要增加的是用户级，且各种服务差异都体现在用户级，就需要一个用户级模型。
+
+#### ① 用户级别重构
+
+
+
+![](https://p.ipic.vip/8gg2cy.png)
+
+原代码即可重构成：
+
+![](https://img-blog.csdnimg.cn/7e59471ba0924cccbd4fac2503eb4f7e.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+
+此时再增加白金用户，只需新写一个类：
+
+![](https://img-blog.csdnimg.cn/34ec979369794553827bfe978fb70bc2.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_SmF2YUVkZ2U=,size_18,color_FFFFFF,t_70,g_se,x_16)
+可以这么做，是因为代码里留好了扩展点：UserLevel把原来只支持枚举值的UserLevel，升级成【有行为】的UserLevel。
+
+改造后，HotelService的getRoomPrice就稳定了，无需根据用户级别不断调整。
+一旦有稳定的构造块，就能在后续将其当做一个稳定模块复用。
+
+## 5 构建扩展点
+
+其实我们修改代码效果不佳，但真到自己写代码，就晕了。你开发的系统有问题吗？相信大部人都承认有。但又问：你经常主动优化吗？大部人却又沉默。
+它虽然垃圾，但在线上运行好好，万一我优化坏了咋办，绩效可就 3.25！现实就是这样 ，系统宏观层面人人都懂，而代码落地层，却各种原因本能的忽视。
+
+所以，写软件系统，就该提供一个个稳定小模块，然后，将它们组合。一个经常变动的模块不稳定，用它去构造更大模块，必后患无穷。
+
+### 5.1 为什么懂很多道理，却依旧写不好代码？
+
+阻碍我们构造稳定模块的，是构建模型的能力。回想产生变化的UserLevel是如何升级成有行为的UserLevel。
+
+封装的要点是行为，数据只是实现细节，而很多人习惯性面向数据写法，导致设计缺乏扩展性。
+
+### 5.2构建模型的难点
+
+1. 分离关注点
+2. 找到共性
+
+**要构建起抽象就要找到事物的共同点**，业务处理过程发现共性对大部分人就已经开始有难度。
+
+## 6 案例 - 报表服务
+
+![](https://img-blog.csdnimg.cn/f2d1fb410ecb49ed8b2d30cf24a89d7c.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+很多人日常写代码就这风格，代码流程僵化。只要有新需求，基本都要修改这段。
+
+### 6.1 需求
+
+把统计信息发给另外一个内部系统，该内部系统可将统计信息展示出来，供外部合作伙伴查阅。
+
+### 6.2 分析
+
+发给另一个系统的内容是**统计信息**。原代码里：
+
+- 前2步获取源数据，生成**统计信息**
+- 后2步生成报表，将**统计信息**通过邮件发出
+
+后2步和即将添加的步骤有个共同点，都使用统计信息。所以，可用共同模型，如OrderStatisticsConsumer：
+![](https://img-blog.csdnimg.cn/927eade9b0d74d9392b5bb987100577a.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+
+这样，新需求也只需添加一个新类，而非 if/else：
+![](https://img-blog.csdnimg.cn/07d88e8615564fb2974ea0631b48b087.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+
+该案例中，第一步要做的还是分解：
+
+- 把一个个步骤分开
+- 然后找出步骤间相似点
+- 并构建一个新模型
+
+实际项目代码更复杂，但并非一定业务逻辑复杂，而是代码写得就垃圾且复杂。
+所以，要先根据SRP，将不同需求来源引起的变动拆到不同方法，形成一个个小单元，再做这里的分析。
+
+实际项目达到OCP并非一朝一夕。这里只是因为有需求变动，才提取出一个OrderStatisticsConsumer。
+
+未来可能还有其它变动，如生成报表的逻辑。那时，也许再提取一个新OrderStatisticsGenerator的接口。但不管怎样，每做一次这种模型构建，最核心的类就会朝稳定发展。
+
+**好的设计都会提供足够扩展点给新功能去扩展（想起 Spring 生命周期）。**
+《Unix 编程艺术》提倡“提供机制，而非策略”，这就体现OCP。
+
+很多系统的插件机制，如IDEA和VS Code都体现OCP。去了解它们的接口，即可看到这个软件给我们提供的各种能力。
+
+### 6.3 抓手
+
+OCP还可帮助我们优化系统，查看Git，找出那些最经常变动的文件，它们通常都没满足OCP，这就能成为你系统优化的起航点。
+
+## 7 为何选择OCP？
+
+### 7.1 OCP对测试的影响
+
+有变化提出时，就要考虑：原有的健壮代码是否能不修改，而仅通过扩展实现变化？否则，就需要把原有测试过程全部回笼一遍，需要进行UT、功能测试、集成测试甚至验收测试。
+
+回看书店案例，*BaseBook*接口写完，实现类JavaBook也写好了，写个测试类：
+
+```java
+public class JavaBookTest extends TestCase {
+     private String name = "Java666";
+     private int price = 6000;
+     private String author = "JavaEdge";      
+     private BaseBook javaBook = new JavaBook(name,price,author);
+     
+     // 测试getPrice方法
+     public void testGetPrice() {
+             //原价销售，根据输入和输出的值是否相等进行断言
+             super.assertEquals(this.price, this.novelBook.getPrice());
+     }
+}
+```
+
+若加个打折销售需求，直接修改getPrice，就要修改UT类。而实际项目，一个类一般只有一个测试类，其中可以有很多测试方法，在一堆本就复杂的断言中进行大量修改，难免测试遗漏。
+
+**所以，要通过扩展实现业务逻辑变化，而非修改**。可通过增加一个子类OffJavaBook完成业务需求变化，这对测试有啥好处？重新生成一个测试文件OffJavaBookTest，然后对getPrice测试，UT是孤立测试，只要保证我提供的方法正确就成，其他不管：
+
+```java
+public class OffNovelBookTest extends TestCase {   
+     private BaseBook below40NovelBook = new OffJavaBook("Java666",3000,"JavaEdge");
+     private BaseBook above40NovelBook = new OffJavaBook("Go999",6000,"JavaEdge");
+      
+     // 测试低于40元的数据是否是打8折
+     public void testGetPriceBelow40() {
+             super.assertEquals(2400, this.below40NovelBook.getPrice());
+     }
+     
+     // 测试大于40的书籍是否是打9折
+     public void testGetPriceAbove40(){
+             super.assertEquals(5400, this.above40NovelBook.getPrice());
+     }
+}
+```
+
+新增加的类，新增加的测试方法，只要保证新增加类是正确的就可以了。
+
+### 7.2 提高复用性
+
+OOP中，所有逻辑都从原子逻辑组合而来，而非在一个类中独立实现一个业务逻辑。只有这样代码才可复用，粒度越小，被复用可能性越大。
+
+#### ①  为何要复用？
+
+减少代码量，避免相同逻辑分散，避免后来的维护人员为修改一个小bug或加个新功能，而在整个项目到处查找相关代码，然后发出对开发人员吼出“极度失望”的感慨。
+
+#### ②  如何提高复用率？
+
+缩小逻辑粒度，直到一个逻辑不可再拆分。
+
+### 7.3 提高可维护性
+
+一款软件投产后，接盘侠不仅要对数据进行维护，还可能要对程序进行扩展，接盘侠最爱干的就是扩展一个类，而非修改一个类，甭管原有代码好坏，让接盘侠先看懂原有代码，再修改，就是炼狱！不要让他在原有代码海洋里瞎游完毕后再修改，那是对接盘侠的摧残，会缺水溺死。
+
+### 7.4 OOP
+
+万物皆对象，我们要把所有事物抽象成对象，再针对对象操作，但运动是一定的，有运动就有变化，有变化就要有策略应对，如何快速应对？就需要在设计之初考虑到所有可能变化的因素，然后留下接口，等待“可能”转为“现实”。
+
+## 8 总结
+
+若说SRP主要看封装，而OCP须有多态。要想提供扩展点，就要面向接口编程。
+
+Java SPI提供扩展机制，Spring Boot和Dubbo继续改进，各自提供扩展点：
+
+- Spring Boot允许用户自定义starter
+- Dubbo可自定义协议
+
+1、识别修改点，构建模型，将原来静态逻辑转为动态逻辑
+2、构建模型的难点在于分离关注点，其次找到共性
\ No newline at end of file
diff --git "a/docs/md/java/JDK16\346\226\260\347\211\271\346\200\247.md" b/docs/md/java/Java16-new-features.md
similarity index 100%
rename from "docs/md/java/JDK16\346\226\260\347\211\271\346\200\247.md"
rename to docs/md/java/Java16-new-features.md
diff --git "a/docs/md/java/JDK21\346\226\260\347\211\271\346\200\247.md" b/docs/md/java/Java21-new-features.md
similarity index 100%
rename from "docs/md/java/JDK21\346\226\260\347\211\271\346\200\247.md"
rename to docs/md/java/Java21-new-features.md
diff --git "a/docs/md/java/JDK22\346\226\260\347\211\271\346\200\247.md" b/docs/md/java/Java22-new-features.md
similarity index 100%
rename from "docs/md/java/JDK22\346\226\260\347\211\271\346\200\247.md"
rename to docs/md/java/Java22-new-features.md
diff --git "a/docs/md/java/JDK23\346\226\260\347\211\271\346\200\247.md" b/docs/md/java/Java23-new-features.md
similarity index 100%
rename from "docs/md/java/JDK23\346\226\260\347\211\271\346\200\247.md"
rename to docs/md/java/Java23-new-features.md
diff --git "a/docs/md/java/Java9\346\226\260\347\211\271\346\200\247\346\246\202\350\277\260.md" b/docs/md/java/Java9-new-features.md
similarity index 100%
rename from "docs/md/java/Java9\346\226\260\347\211\271\346\200\247\346\246\202\350\277\260.md"
rename to docs/md/java/Java9-new-features.md
diff --git a/docs/md/java/java-news-roundup-jun02-2025.md b/docs/md/java/java-news-roundup-jun02-2025.md
new file mode 100644
index 000000000..4f3022a03
--- /dev/null
+++ b/docs/md/java/java-news-roundup-jun02-2025.md
@@ -0,0 +1,126 @@
+# Java 新闻速递：JDK 25 进入收尾阶段，JDK 26 专家组成立，Hibernate Search 发布，Oracle 推出 Project Crema
+
+## 0 前言
+
+上周Java 新闻回顾重点：JDK 25进入Rampdown第一阶段、JDK 26专家组成立、Hibernate Search 8.0.0.Final发布、Grails 7.0.0第四个里程碑版本发布、Open Liberty 25.0.0.6测试版发布、Eclipse JNoSQL、Helidon 和 JBang 的小版本更新，以及 Oracle Labs 推出的新项目 Project Crema 预览。
+
+## 1 OpenJDK
+
+JEP 509：[JFR CPU时间分析（实验性）](https://openjdk.org/jeps/509) 已从“拟定为目标”升级为“已确定目标”，将会包含在 JDK 25。该JEP提议增强 JDK Flight Recorder（JFR），使其可在 Linux 系统记录 CPU 时间的分析信息。
+
+## 2 JDK 25
+
+JDK 25 的[早期访问版本 Build 26](https://github.com/openjdk/jdk/releases/tag/jdk-25%2B26)上周上线，包含自 Build 25 以来的多项[更新](https://github.com/openjdk/jdk/compare/jdk-25%2B25...jdk-25%2B26)，修复了多个[问题](https://bugs.openjdk.org/browse/JDK-8357287?jql=project %3D JDK AND fixversion %3D 25 and "resolved in build" %3D b26 order by component%2C subcomponent)。完整详情可见[发行说明](https://jdk.java.net/25/release-notes)。
+
+根据 JDK 25 的[发布计划](https://openjdk.org/projects/jdk/25/#Schedule)，Oracle Java平台首席架构师 [Mark Reinhold](https://www.linkedin.com/in/markreinhold) [宣布](https://mail.openjdk.org/pipermail/jdk-dev/2025-June/010191.html)，JDK 25已进入 Rampdown Phase One，即主线源码仓库已分支为[JDK稳定版本仓库](https://github.com/openjdk/jdk/tree/jdk25)，不会再添加新JEP特性。JDK 25 正式发布（GA）将于 2025 年 9 月进行，最终包含18项功能：
+
+- JEP 470：[加密对象的PEM编码（预览）](https://openjdk.org/jeps/470)
+- JEP 502：[稳定值（预览）](https://openjdk.org/jeps/502)
+- JEP 503：[移除32位x86平台支持](https://openjdk.org/jeps/503)
+- JEP 505：[结构化并发（第五次预览）](https://openjdk.org/jeps/505)
+- JEP 506：[作用域值](https://openjdk.org/jeps/506)
+- JEP 507：[在模式匹配、instanceof 和 switch 中使用原始类型（第三次预览）](https://openjdk.org/jeps/507)
+- JEP 508：[向量API（第十次孵化）](https://openjdk.org/jeps/508)
+- JEP 509：[JFR CPU时间分析（实验性）](https://openjdk.org/jeps/509)
+- JEP 510：[密钥派生函数API](https://openjdk.org/jeps/510)
+- JEP 511：[模块导入声明](https://openjdk.org/jeps/511)
+- JEP 512：[简洁的源文件和实例 main 方法](https://openjdk.org/jeps/512)
+- JEP 513：[灵活的构造方法体](https://openjdk.org/jeps/513)
+- JEP 514：[AOT 命令行参数优化](https://openjdk.org/jeps/514)
+- JEP 515：[AOT 方法分析](https://openjdk.org/jeps/515)
+- JEP 518：[JFR 协作采样](https://openjdk.org/jeps/518)
+- JEP 519：[紧凑对象头](https://openjdk.org/jeps/519)
+- JEP 520：[JFR 方法计时与追踪](https://openjdk.org/jeps/520)
+- JEP 521：[新一代 Shenandoah 垃圾回收器](https://openjdk.org/jeps/521)
+
+JDK 25 将是继 JDK 21、17、11 和 8 之后的下一代长期支持（LTS）版本。
+
+## 3 JDK 26
+
+JSR 401：[Java SE 26](https://jcp.org/en/jsr/detail?id=401) 已于上周正式批准，宣布成立四人专家组，成员包括 [Simon Ritter](https://www.linkedin.com/in/siritter/)（Azul Systems）、[Iris Clark](https://www.linkedin.com/in/iris-clark-49159b13b/)（Oracle）、[Stephan Herrmann](https://github.com/stephan-herrmann)（Eclipse Foundation）和 [Christoph Langer](https://www.linkedin.com/in/christoph-langer-764280208/)（SAP SE）。Clark 将担任规范负责人。JDK 26 的[计划时间表](https://openjdk.org/projects/jdk/26/spec/)包括：2025年11月到2026年2月的公开评审期，GA版本预计在2026年3月发布。
+
+此外，JDK 26 的[Build 0](https://github.com/openjdk/jdk/releases/tag/jdk-26%2B0) 和 [Build 1](https://github.com/openjdk/jdk/releases/tag/jdk-26%2B1) 也在本周发布，修复了部分[初期问题](https://bugs.openjdk.org/browse/JDK-8355746?jql=project %3D JDK AND fixVersion %3D "26" AND "Resolved In Build" %3D b01 order by component%2C subcomponent)。
+
+开发者可通过 [Java Bug Database](https://bugreport.java.com/bugreport/) 提交 JDK 25 的问题反馈。
+
+## 4 Jakarta EE
+
+Eclipse 基金会 Jakarta EE 开发者倡导者 [Ivar Grimstad](https://se.linkedin.com/in/ivargrimstad) 在他每周的 [Hashtag Jakarta EE 博客](https://www.agilejava.eu/)中更新了 Jakarta EE 11 和 EE 12 的进展：
+
+> 该庆祝了！Jakarta EE 11 平台的所有发布审查材料都已提交，作为规范委员会的导师，我将于6月9日（周一）启动发布审查投票。这意味着最迟将在6月24日正式发布。希望那天有蛋糕……
+>
+> 随着 EE 11 推出，接下来的重点将转向 [Jakarta EE 12](https://jakarta.ee/specifications/platform/12/)。目前计划评审已完成，平台项目已启动并开始定义里程碑，[详细计划](https://jakartaee.github.io/platform/jakartaee12/JakartaEE12ReleasePlan)包括制定 *Milestone 0*，确保各个子规范项目准备就绪。
+
+Jakarta EE 11 的发布经历了五个里程碑版本，包括2024年12月发布的 [Core Profile](https://jakarta.ee/specifications/coreprofile/)、2025年4月发布的 [Web Profile](https://jakarta.ee/specifications/webprofile/)，以及平台版的候选发布版本，预计正式发布将在2025年6月。
+
+## 5 Eclipse JNoSQL
+
+[Eclipse JNoSQL](https://www.jnosql.org/) 1.1.8 发布，作为 [Jakarta NoSQL](https://jakarta.ee/specifications/nosql/) 规范的兼容实现，此版本带来以下更新：
+
+- 支持图数据库类型，新增 Java 的 Graph API，采用 Neo4j 的 [Cypher 查询语言](https://neo4j.com/product/cypher-graph-query-language/)
+- 新增 Quarkus 扩展：[quarkus-jnosql-core](https://quarkus.io/extensions/io.quarkiverse.jnosql/quarkus-jnosql-core/)，支持 MongoDB、ArangoDB、Cassandra 和 Hazelcast
+
+图形 API 的实现细节可参考这篇 [LinkedIn 博客](https://quarkus.io/extensions/io.quarkiverse.jnosql/quarkus-jnosql-core/)。
+
+## 6 Spring Framework
+
+[Spring Cloud](https://spring.io/projects/spring-cloud) 2022.0.11（代号 Kilburn）作为第11个维护版本，[已发布](https://spring.io/blog/2025/06/02/spring-cloud-2022-0-11-aka-kilburn-has-been-released)，包含多项Bug修复和依赖升级，尤其是：
+
+- [Spring Cloud Config](https://spring.io/projects/spring-cloud-config) 4.0.11 修复了 [CVE-2025-22232](https://spring.io/security/cve-2025-22232)
+- [Spring Cloud Gateway](https://spring.io/projects/spring-cloud-gateway) 4.0.12 修复了 [CVE-2025-41235](https://spring.io/security/cve-2025-41235)
+
+## 7 Hibernate
+
+[Hibernate Search](https://hibernate.org/search/) 8.0.0.Final [正式发布](https://in.relation.to/2025/06/06/hibernate-search-8-0-0-Final/)，包括：
+
+- 兼容 Hibernate ORM 7.0.0.Final
+- 与 [Hibernate Models](https://github.com/hibernate/hibernate-models/blob/main/README.adoc) 集成增强
+- 在 [Hibernate Search DSL](https://docs.jboss.org/hibernate/stable/search/reference/en-US/html_single/#search-dsl) 中支持请求指标聚合
+- 各类Bug修复
+
+更多详情请参阅[发行说明](https://hibernate.atlassian.net/issues/?jql=project%3D10061 AND fixVersion%3D33769)。
+
+## 8 Helidon
+
+Helidon 4.2.3 发布，主要改进包括：
+
+- 在 [Metrics](https://helidon.io/docs/v4/se/metrics/metrics)、[Health Checks](https://helidon.io/docs/v4/se/health)、[OpenAPI](https://helidon.io/docs/v4/se/openapi/openapi) 和 [Config](https://helidon.io/docs/v4/se/config/introduction) API 输出中添加 **`nosniff`** 的 **`X-Content-Type-Options`** 头部，防止浏览器自动推断内容类型
+- 修复了 **`SecurityEnvironment`** 类中 **`queryParams()`** 方法无法获取查询参数的问题
+
+详细变更见 [更新日志](https://github.com/helidon-io/helidon/blob/4.2.3/CHANGELOG.md)。
+
+## 9 Open Liberty
+
+[Open Liberty](https://openliberty.io/) 25.0.0.6-beta [发布](https://openliberty.io/blog/2025/06/03/25.0.0.6-beta.html)，新特性包括：
+
+- 为 Java EE 7 和 8 应用回移支持 [Microprofile Health 4.0](https://github.com/microprofile/microprofile-health/blob/main/README.adoc) 规范（`mpHealth-4.0`）
+- 更新了[基于文件的健康检查机制](https://blogs-draft-openlibertyio.mqj6zf7jocq.us-south.codeengine.appdomain.cloud/blog/2025/04/08/25.0.0.4-beta.html#backport)，新增了 **`server.xml`** 中的 **`startupCheckInterval`** 属性及其环境变量 **`MP_HEALTH_STARTUP_CHECK_INTERVAL`**，默认值为100毫秒
+
+## 10 Grails
+
+[Grails](https://grails.org/) 7.0.0 的第四个里程碑版本发布，更新内容包括：
+
+- 由于迁移至 Apache 软件基金会，进行了[构件命名重构](https://github.com/apache/grails-core/blob/7.0.x/RENAME.md)
+- 将多个仓库（如 **`grails-views`**、**`gsp`** 等）的源码整合至 **`grails-core`** 仓库中
+
+详细信息见 [发布说明](https://github.com/apache/grails-core/releases/tag/v7.0.0-M4)。
+
+## 11 JBang
+
+[JBang](https://www.jbang.dev/) 0.126.0 发布，带来文档改进、Bug 修复和新特性，包括：
+
+- 将 **`ResourceRef`** 从类更改为接口
+- 引入 **`LazyResourceRef`** 和 **`LazyResourceResolver`**，支持开发者按需加载远程资源
+
+更多信息请查阅 [发布说明](https://github.com/jbangdev/jbang/releases/tag/v0.126.2)。
+
+## 12 Project Crema
+
+Oracle Labs 的 GraalVM 开发者倡导者 [Alina Yurenko](https://www.linkedin.com/in/alinayurenko/) 在 [X 平台](https://x.com/alina_yurenko/status/1930241191418708072)上分享了新项目 [Project Crema](https://github.com/oracle/graal/issues/11327) 的预览。
+
+该项目旨在“打破 Native Image 的默认封闭世界假设，允许在运行时动态加载和执行类”，主要包括：
+
+- Java 解释器，构建在 **Native Image Layers** 之上（一个支持依赖基础镜像链的新项目，[详情](https://github.com/oracle/graal/issues/7626)）
+- 支持 [Java 调试线协议（JDWP）](https://docs.oracle.com/en/java/javase/24/docs/specs/jdwp/jdwp-spec.html)
+
+Yurenko 表示，开发者应“持续关注更多更新！”
\ No newline at end of file
diff --git a/docs/md/kafka/13-KafkaAdminClient.md b/docs/md/kafka/kafka-operations-tool-exploring-adminclient-principles-and-practices.md
similarity index 50%
rename from docs/md/kafka/13-KafkaAdminClient.md
rename to docs/md/kafka/kafka-operations-tool-exploring-adminclient-principles-and-practices.md
index 8a128812e..e7e90298e 100644
--- a/docs/md/kafka/13-KafkaAdminClient.md
+++ b/docs/md/kafka/kafka-operations-tool-exploring-adminclient-principles-and-practices.md
@@ -1,20 +1,20 @@
-# 13-KafkaAdminClient
+# Kafka运维利器：深入解析AdminClient原理与实战
 
-## 引入原因
+## 1 Kafka脚本弊端
 
-Kafka自带的各种命令行脚本，这些脚本使用起来虽然方便，却有弊端：
+Kafka自带各种命令行脚本，用起来虽方便，但是：
 
-- 命令行的脚本都只能运行在控制台。若想在应用程序、运维框架或是监控平台中集成它们很难
-- 这些命令行脚本很多都是通过连接zk来提供服务。目前，社区越来越不推荐任何工具直连zk，因这会带来一些问题：可能绕过Kafka安全设置。kafka-topics脚本连接zk时，不会考虑Kafka设置的用户认证机制。即任何使用该脚本的用户，不论是否具有创建主题的权限，都能成功“跳过”权限检查，强行创建主题！
-- 运行这些脚本，要用Kafka内部的类实现，即Kafka**服务器端**代码。社区还是希望用户只使用Kafka**客户端**代码，通过现有请求机制运维管理集群。这样所有运维操作都能纳入统一处理机制下，方便功能演进。
+- 只能运行在控制台。若想在应用程序、运维框架或是监控平台中集成难
+- 很多通过连接zk来提供服务。而社区越来越不推荐任何工具直连zk，因为这可能绕过Kafka安全设置。kafka-topics脚本连接zk时，不会考虑Kafka设置的用户认证机制。即任何使用该脚本的用户，不论是否具有创建主题的权限，都成功“跳过”权限检查，强行创建主题
+- 运行它们要用Kafka内部类实现，即Kafka**服务器端**代码。社区希望用户只用Kafka**客户端**代码，通过现有请求机制运维管理集群。这样所有运维操作都能统一处理，方便功能演进
 
-因此，社区于0.11版本正式推出Java客户端版AdminClient，**服务器端也有一个AdminClient**，包路径是kafka.admin，是之前的老运维工具类，提供的功能也比较有限，社区已经不再推荐使用它了。
+因此，社区0.11版推出Java客户端版AdminClient，**服务器端也有一个AdminClient**，包路径是kafka.admin，是之前的老运维工具类，提供的功能也比较有限，社区已经不再推荐使用它了。
 
 ![](https://img-blog.csdnimg.cn/39a17bf7e6f647568e234db27608af0a.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
 
 所以，现在统一使用客户端的AdminClient。
 
-## 如何使用？
+## 2 咋用？
 
 Java客户端提供的工具，要在你工程中显式增加依赖，以2.3版本为例。
 
@@ -30,54 +30,68 @@ Java客户端提供的工具，要在你工程中显式增加依赖，以2.3版
 compile group: 'org.apache.kafka', name: 'kafka-clients', version: '2.3.0'
 ```
 
-## 功能
+## 3 功能
 
-2.3版本中，AdminClient提供功能有9大类：
+2.3版的AdminClient支持：
 
-1. 主题管理：包括主题的创建、删除和查询。
-2. 权限管理：包括具体权限的配置与删除。
-3. 配置参数管理：包括Kafka各种资源的参数设置、详情查询。所谓的Kafka资源，主要有Broker、主题、用户、Client-id等。
+1. 主题管理：包括主题创建、删除和查询
+2. 权限管理：包括具体权限的配置与删除
+3. 配置参数管理：包括Kafka各种资源的参数设置、详情查询。所谓的Kafka资源，主要有Broker、主题、用户、Client-id等
 4. 副本日志管理：包括副本底层日志路径的变更和详情查询。
-5. 分区管理：即创建额外的主题分区。
-6. 消息删除：即删除指定位移之前的分区消息。
-7. Delegation Token管理：包括Delegation Token的创建、更新、过期和详情查询。
-8. 消费者组管理：包括消费者组的查询、位移查询和删除。
-9. Preferred领导者选举：推选指定主题分区的Preferred Broker为领导者。
+5. 分区管理：即创建额外的主题分区
+6. 消息删除：即删除指定位移之前的分区消息
+7. Delegation Token管理：包括Delegation Token的创建、更新、过期和详情查询
+8. 消费者组管理：包括消费者组的查询、位移查询和删除
+9. Preferred领导者选举：推选指定主题分区的Preferred Broker为领导者
 
-## 工作原理
+## 4 工作原理
 
-AdminClient是个双线程设计：
+AdminClient是双线程设计：
 
-- 前端主线程
+- 前端主线程：将用户要执行的操作转换成对应请求，发到后端I/O线程的队列
 
-  将用户要执行的操作转换成对应的请求，然后再将请求发送到后端I/O线程的队列
+- 后端I/O线程：从队列中读取相应请求，发到对应Broker节点，再把执行结果保存，待前端线程来获取
 
-- 后端I/O线程
-
-  从队列中读取相应请求，然后发到对应Broker节点，再把执行结果保存，等待前端线程来获取
 
 使用生产者-消费者模式将请求生成与处理解耦：
 
-![](/Users/javaedge/Downloads/IDEAProjects/java-edge-master/assets//4b520345918d0429801589217270d1eb.png)
+![](https://p.ipic.vip/81250j.png)
+
+### 前端主线程
+
+会创建名为Call的请求对象实例。该实例有两个主要的任务。
+
+#### 构建对应的请求对象
+
+如若要创建主题，那么就创建CreateTopicsRequest；如果是查询消费者组位移，就创建OffsetFetchRequest。
+
+#### 指定响应的回调逻辑
+
+如从Broker端接收到CreateTopicsResponse之后要执行的动作。一旦创建好Call实例，前端主线程会将其放入到新请求队列（New Call Queue）中，此时，前端主线程的任务就算完成了。它只需要等待结果返回即可。
 
-前端主线程会创建名为Call的请求对象实例。该实例有两个主要的任务。
+剩下工作都是
 
-1. **构建对应的请求对象**。比如，如果要创建主题，那么就创建CreateTopicsRequest；如果是查询消费者组位移，就创建OffsetFetchRequest。
-2. **指定响应的回调逻辑**。比如从Broker端接收到CreateTopicsResponse之后要执行的动作。一旦创建好Call实例，前端主线程会将其放入到新请求队列（New Call Queue）中，此时，前端主线程的任务就算完成了。它只需要等待结果返回即可。
+### 后端I/O线程
 
-剩下的所有事情就都是后端I/O线程的工作了。就像图中所展示的那样，该线程使用了3个队列来承载不同时期的请求对象，它们分别是新请求队列、待发送请求队列和处理中请求队列。为什么要使用3个呢？原因是目前新请求队列的线程安全是由Java的monitor锁来保证的。**为了确保前端主线程不会因为monitor锁被阻塞，后端I/O线程会定期地将新请求队列中的所有Call实例全部搬移到待发送请求队列中进行处理**。图中的待发送请求队列和处理中请求队列只由后端I/O线程处理，因此无需任何锁机制来保证线程安全。
+该线程用3个队列来承载不同时期的请求对象：
 
-当I/O线程在处理某个请求时，它会显式地将该请求保存在处理中请求队列。一旦处理完成，I/O线程会自动地调用Call对象中的回调逻辑完成最后的处理。把这些都做完之后，I/O线程会通知前端主线程说结果已经准备完毕，这样前端主线程能够及时获取到执行操作的结果。AdminClient是使用Java Object对象的wait和notify实现的这种通知机制。
+- 新请求队列
+- 待发送请求队列
+- 处理中请求队列
 
-严格来说，AdminClient并没有使用Java已有的队列去实现上面的请求队列，它是使用ArrayList和HashMap这样的简单容器类，再配以monitor锁来保证线程安全的。不过，鉴于它们充当的角色就是请求队列这样的主体，我还是坚持使用队列来指代它们了。
+为啥要用3个？目前新请求队列的线程安全是由Java monitor锁保证。为确保前端主线程不会因monitor锁被阻塞，后端I/O线程定期将新请求队列中的所有Call实例全部搬移到待发送请求队列中进行处理。图中的待发送请求队列和处理中请求队列只由后端I/O线程处理，因此无需任何锁机制保证线程安全。
 
-了解AdminClient工作原理的一个好处在于，**它能够帮助我们有针对性地对调用AdminClient的程序进行调试**。
+当I/O线程在处理某请求时，它会显式将该请求保存在处理中请求队列。一旦处理完成，I/O线程会自动地调用Call对象中的回调逻辑完成最后的处理。把这些都做完之后，I/O线程会通知前端主线程说结果已经准备完毕，这样前端主线程能够及时获取到执行操作的结果。AdminClient是使用Java Object对象的wait和notify实现的这种通知机制。
 
-提到的后端I/O线程有名字，前缀kafka-admin-client-thread。有时发现，AdminClient程序貌似正常工作，但执行操作没返回结果或hang住，现在你该知道这可能因为I/O线程出现问题导致。碰到类似问题，不妨jstack查看AdminClient程序，确认I/O线程是否在正常工作。
+ AdminClient没有用Java已有的队列去实现上面的请求队列，它用ArrayList、HashMap这样的简单容器类，再配monitor锁来保证线程安全的。但鉴于它们充当的角色就是请求队列，我还是坚持用队列来指代它们。
+
+### AdminClient工作原理
+
+好在它能帮助针对性地对调用AdminClient的程序调试。后端I/O线程名有前缀kafka-admin-client-thread。有时AdminClient貌似正常工作，但执行操作没返回结果或hang住，现在你该知道这可能因为I/O线程异常。碰到类似问题，不妨jstack看AdminClient程序，确认I/O线程是否正常。
 
 这是社区bug。这问题根本原因，就是I/O线程未捕获某些异常导致意外“挂”掉。由于AdminClient是双线程设计，前端主线程不受任何影响，依然可正常接收用户发送的命令请求，但此时程序已不能正常工作。
 
-## 构造和销毁AdminClient实例
+## 5 构造和销毁AdminClient实例
 
 如果你正确地引入了kafka-clients依赖，那么你应该可以在编写Java程序时看到AdminClient对象。**切记它的完整类路径是org.apache.kafka.clients.admin.AdminClient，而不是kafka.admin.AdminClient**。后者就是我们刚才说的服务器端的AdminClient，它已经不被推荐使用了。
 
@@ -85,9 +99,7 @@ AdminClient是个双线程设计：
 
 完整参数列表看[官网](https://kafka.apache.org/documentation/#adminclientconfigs)。如要销毁AdminClient实例，需显式调用AdminClient#close。
 
-## AdminClient实例的创建与销毁
-
-
+## 6 AdminClient实例的创建与销毁
 
 ```java
 Properties props = new Properties();
@@ -99,7 +111,7 @@ try (AdminClient client = AdminClient.create(props)) {
 }
 ```
 
-## 常见的AdminClient应用实例
+## 7 AdminClient应用
 
 讲完了AdminClient的工作原理和构造方法，接下来，我举几个实际的代码程序来说明一下如何应用它。这几个例子，都是我们最常见的。
 
@@ -142,15 +154,17 @@ try (AdminClient client = AdminClient.create(props)) {
 
 ### 获取Broker磁盘占用
 
-现在，我们来使用AdminClient实现一个稍微高级一点的功能：获取某台Broker上Kafka主题占用的磁盘空间量。有些遗憾的是，目前Kafka的JMX监控指标没有提供这样的功能，而磁盘占用这件事，是很多Kafka运维人员要实时监控并且极为重视的。
+获取某Broker上Kafka主题占用磁盘量。目前Kafka的JMX监控指标未提供该功能，而磁盘占用是很多Kafka运维需实时监控且重视。
 
-幸运的是，我们可以使用AdminClient来实现这一功能。代码如下：
+好在可用AdminClient实现：
 
 ```scala
 try (AdminClient client = AdminClient.create(props)) {
+  				// 使用AdminClient#describeLogDirs获取指定Broker上所有分区主题的日志路径信息
          DescribeLogDirsResult ret = client.describeLogDirs(Collections.singletonList(targetBrokerId)); // 指定Broker id
          long size = 0L;
          for (Map<String, DescribeLogDirsResponse.LogDirInfo> logDirInfoMap : ret.all().get().values()) {
+           				 // 然后把它们累积在一起，得出总磁盘占用量
                   size += logDirInfoMap.values().stream().map(logDirInfo -> logDirInfo.replicaInfos).flatMap(
                            topicPartitionReplicaInfoMap ->
                            topicPartitionReplicaInfoMap.values().stream().map(replicaInfo -> replicaInfo.size))
@@ -158,6 +172,4 @@ try (AdminClient client = AdminClient.create(props)) {
          }
          System.out.println(size);
 }
-```
-
-使用AdminClient的**describeLogDirs方法**获取指定Broker上所有分区主题的日志路径信息，然后把它们累积在一起，得出总磁盘占用量。
\ No newline at end of file
+```
\ No newline at end of file
diff --git a/docs/md/mysql/mysql-transaction-isolation-mechanism.md b/docs/md/mysql/mysql-transaction-isolation-mechanism.md
new file mode 100644
index 000000000..4667d1489
--- /dev/null
+++ b/docs/md/mysql/mysql-transaction-isolation-mechanism.md
@@ -0,0 +1,497 @@
+# MySQL是怎么实现事务隔离的？
+
+## 0 前言
+
+一个事务要更新一行，若恰有另一事务持有该行的行锁，它会被锁住。既然进入等待状态，那等该事务自己获取到行锁要更新数据时，它读到的值又是啥？
+
+## 1 案例
+
+### 1.1 数据初始化
+
+```sql
+mysql> CREATE TABLE `t`
+    -> (
+    -> `id` int(11) NOT NULL,
+    -> `k` int(11) DEFAULT NULL,
+    -> PRIMARY KEY (`id`)
+    -> ) ENGINE = InnoDB;
+Query OK, 0 rows affected, 2 warnings (0.01 sec)
+
+mysql>
+mysql> insert into t(id, k)
+    -> values (1, 1),
+    ->        (2, 2);
+```
+
+### 1.2 事务执行流程
+
+| 事务A                                       | 事务B                                                        | 事务C                          |
+| ------------------------------------------- | ------------------------------------------------------------ | ------------------------------ |
+| start transaction with consistent snapshot; |                                                              |                                |
+|                                             | start transaction with consistent snapshot;                  |                                |
+|                                             |                                                              | update t set k=k+1 where id=1; |
+|                                             | update t set k=k+1 where id=1;  <br/>select k from t where id=1; |                                |
+| select k from t where id=1; <br>commit;     |                                                              |                                |
+|                                             | commit;                                                      |                                |
+
+### 1.3 事务启动时机
+
+- begin/start transaction：在执行到它们之后的第一个操作InnoDB表的语句，事务才真正启动。一致性视图是在执行【第一个快照读语句】时创建
+- **start transaction with consistent snapshot**：想立马启动一个事务时用。一致性视图是在执行【start transaction with consistent snapshot】时创建
+
+默认`autocommit=1`。该案例中：
+
+- 事务C未显式用begin/commit，即该update语句本身就是个事务，语句完成时自动提交
+- 事务B更新行后，就查询
+- 事务A在一个只读事务中查询，时间上在事务B的查询后
+
+## 2 undo log链
+
+每条undo log有两个隐藏字段：
+
+- trx_id：最近一次更新这条数据的事务id
+
+- roll_pointer：指向更新这个事务之前生成的undo log
+
+
+若有一事务A（id=50）插入一条数据，则该数据隐藏字段及指向的undo log如下：roll_pointer指向一个空undo log，因为之前没这条数据
+
+![](https://img-blog.csdnimg.cn/887ff223849e46398e2dd152d2d1bb8b.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+
+﻿再有一事务B修改该数据，改成值B，事务B的id是53，此时更新之前会生成一个undo log记录之前的值，然后roll_pointer指向这个实际的undo log回滚日志：
+
+![](https://img-blog.csdnimg.cn/af32cf5eaecd4610917d181d7e9a69f3.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+
+﻿roll_pointer指向undo log，这undo log就记录你更新之前的那条数据的值。
+
+再事务C来修改这值为C，其事务id=60，此时会把数据行里的txr_id改成60，然后生成一条undo log，记录之前事务B修改的那个值：
+
+![](https://img-blog.csdnimg.cn/bbc7ffed187c4ea59fbecc81f2f0c573.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+
+﻿多个事务串行执行时，每个人修改了一行数据，都会更新隐藏字段txr_id和roll_pointer，同时之前多个数据快照对应的undo log，会通过roll_pinter指针串联起来，形成版本链！
+
+## 3 视图（ReadView）
+
+执行一个事务时，就给你生成一个ReadView，其关键组成：
+
+- m_ids：此时有哪些事务在MySQL里执行还没提交
+
+- min_trx_id：m_ids里最小的值
+
+- max_trx_id：MySQL下一个要生成的事务id，就是最大事务id
+
+- creator_trx_id：你这个事务的id
+
+若原有一行数据，很早就有事务插入过了，事务id是32，他的值就是初始值：
+
+![](https://img-blog.csdnimg.cn/7522f99e1bca4407843806d070744c2a.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+
+此时两个事务并发来执行了：
+
+- 事务A（id=45）：读取这行数据的值
+
+- 事务B（id=59）：更新这行数据的
+
+
+﻿现在A直接开启一个ReadView：
+
+- m_ids包含事务A、B的id：45和59
+- min_trx_id=45
+- max_trx_id=60
+- creator_trx_id=45，事务A自己
+
+事务A第一次查询该行数据，判断：
+
+```
+当前这行数据的txr_id ＜ReadView中的min_trx_id？
+```
+
+txr_id=32小于ReadView里的min_trx_id 45，说明事务开启前，修改这行数据的事务早就提交，所以此时可以查到这行数据。
+
+接着B把这行数据的值修改为了值b，然后这行数据txr_id设为自己的id=59，roll_pointer指向修改之前生成的一个undo log，接着这个事务B就提交了：
+
+![](https://img-blog.csdnimg.cn/97b7e42a361643c8a28ea54e39d33eec.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+
+A再次查询，发现此时数据行里的txr_id=59：
+
+ReadView里的max_trx_id（60) ＞ txr_id ＞ ReadView里的min_txr_id(45)
+
+说明更新这条数据的事务，很可能就跟自己差不多同时开启，于是会看txr_id=59是否在ReadView的m_ids列表。果然就有45和59两个事务id，证实这修改数据的事务是和自己同一时段并发执行然后提交的，所以对这行数据不能查询！
+
+那查啥？顺着这条数据的roll_pointer顺着undo log日志链条往下找，就会找到最近的一条undo log，发现trx_id=32，小于ReadView里的min_trx_id（45），说明该undo log版本在A开启前就执行且提交。那就查询最近那undo log里的值，这就是undo log多版本链的作用，可保存一个快照链，让你能读到之前的快照值：
+
+![](https://img-blog.csdnimg.cn/dc3062597ed344f788cbe780bc6745c3.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+
+多事务并发时，事务B更新的值，通过这套**ReadView+undo log**日志链机制，保证A不会读到并发执行的B更新的值，而只会读到之前最早的值。
+
+接着若事务A更新了这行数据的值，改成值a，trx_id修改为45，同时保存之前事务B修改的值的快照：
+
+![](https://img-blog.csdnimg.cn/2e5b2e26db8b465884b3160f13c792da.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+
+﻿此时A来查询这条数据的值，发现trx_id=45，和自己ReadView里的creator_trx_id（45）一样，说明这行数据就是自己修改的，自己修改的值当然可见。
+
+![](https://img-blog.csdnimg.cn/dfa8f7e7253c4914add54b99a85e30a9.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+
+﻿接着在事务A执行的过程中，突然开启事务C，事务id=78，然后他更新那行数据为值C，还提交了：
+
+![](https://img-blog.csdnimg.cn/1e0acc50194e4738824ebac3bf86063f.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+
+这时A再查询，发现当前数据trx_id=78＞自己ReadView的max_trx_id（60)，说明A开启后，然后有个事务更新了数据，自己当然不能看到！
+
+﻿就顺undo log多版本链往下找，先找到值a，自己之前修改的过的那个版本，因为那个trx_id=45跟自己的ReadView里的creator_trx_id一样，所以此时直接读取自己之前修改的那个版本。
+
+## 4 小结
+
+通过undo log多版本链，加上开启事务时产生的ReadView，然后再有一个查询时，根据ReadView进行判断，就能知你应读取哪个版本数据，保证你
+
+### 能读到
+
+- 你事务开启前，其它已提交事务更新的值
+
+- 还有你自己事务更新的值
+
+### 读不到
+
+- 若你事务开启前，就有其它事务在运行，当你事务开启后，其它事务更新了值
+- 你事务开启后，比你晚开启的事务更新了值
+
+通过这套机制就可以实现多个事务并发执行时候的数据隔离。
+
+## 5 RC级实现
+
+事务运行期，只要其它事务修改数据并提交，即可读到人家修改的数据，所以会不可重复读、幻读。
+
+ReadView机制基于undo log版本链实现的一套读视图机制，事务生成一个ReadView：
+
+- 若为事务自己更新的数据，自己可读到
+- 或你生成ReadView之前的已提交的事务所修改值，也可读到
+- 但若你生成ReadView时，就已经活跃的事务，但如果它在你生成ReadView之后修改的数据并提交了，此时你读不到
+- 或你生成ReadView以后再开启的事务修改了数据，还提交了，也读不到
+
+所以上面那套机制就是ReadView的一个原理。咋基于ReadView实现RC？当一个事务设置RC，他是每次发起查询，都重新生成一个ReadView！
+
+数据库有行数据，是事务id=50的一个事务很久前插入的，而当前活跃事务：
+
+- 事务A（id=60）
+- 事务B（id=70）
+
+现在事务B发起update，更新这条数据为b，所以此时数据的trx_id会变为事务B的id=70，同时生成一条undo log：
+
+![](https://img-blog.csdnimg.cn/c55a614c17014744bf3e8f727412c0f1.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+
+这时，事务A要发起一次查询操作，就生成一个ReadView：
+
+![](https://img-blog.csdnimg.cn/e0114e59efb54cdd8fba780b5d9abc66.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+
+这时事务A发起查询，发现当前数据trx_id=70。即属于ReadView的事务id范围之间，说明是他生成ReadView之前就有这活跃的事务，是这事务修改了这条数据的值，但此时事务B还没提交，所以ReadView的m_ids活跃事务列表里，有[60, 70]两个id，此时根据ReadView机制，事务A无法查到事务B修改的值b。
+
+就顺undo log版本链往下找，就找到一个原始值，发现其trx_id是50，小于当前ReadView里的min_trx_id，说明是他生成ReadView之前，就有一个事务插入了这个值并且早就提交了，因此可以查到这个原始值。
+
+接着，假设事务B提交，提交了就说明事务B不会活跃于数据库里了。事务A下次再查询，就可以读到事务B修改过的值了。那到底是怎么让事务A能够读到提交的事务B修改过的值呢？
+
+让事务A下次发起查询，再生成一个ReadView，数据库内活跃的事务只有事务A，因此：
+
+- min_trx_id是60
+- mac_trx_id是71
+- m_ids=60，事务B的id=70不会出现在m_ids活跃事务列表
+
+此时事务A再基于这ReadView去查询，会发现这条数据的trx_id=70，虽然在ReadView的min_trx_id和max_trx_id范围之间，但是此时并不在m_ids列表内，说明事务B在生成本次ReadView之前就已提交。说明这次你查询就可以查到事务B修改过的这个值了， 此时事务A就会查到值B。
+
+## 6 RR级实现
+
+咋同时避免不可重复读问题、幻读？
+
+MySQL让多事务并发运行的时候能互相隔离，避免同时读写一条数据时有影响，是借助undo log版本链和ReadView机制。
+
+RR级别下，你这事务读一条数据，无论读多少次，都是一个值：
+
+- 别的事务修改数据了后即使提交了，你也看不到人家修改的值，这就解决了不可重复读
+- 其它事务插入一些新数据，你也读不到，这就避免幻读
+
+若有一条数据是事务id=50的一个事务插入的，此时有事务A、B同时在运行。﻿事务A发起一个查询，第一次查询就生成一个ReadView：
+
+- creator_trx_id=60
+- min_trx_id=60
+- max_trx_id=71
+- m_ids=[60, 70]
+
+这时，事务A基于该ReadView去查这条数据，发现这条数据的trx_id为50，小于ReadView﻿里的min_trx_id的，说明他发起查询之前，早就有事务插入这条数据还提交了，所以此时可以查到这条原始值的
+
+![](https://img-blog.csdnimg.cn/8db3a28dcea14f7da75098ca5e7212b6.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+
+接着事务B此时更新了这条数据的值为b，修改trx_id=70，同时生成一个undo log，事务B此时提交
+
+![](https://img-blog.csdnimg.cn/e9fc43838a4d477cac74c192568236c2.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+
+ReadView中的m_ids此时还是60、70，因为ReadView一旦生成了就不会改变！
+
+这时虽然事务B已提交，但事务A的ReadView里， 还是有60、70，即在你事务A开启查询时，事务B当时是在运行的意思而已。
+
+然后事务A查询这条数据，发现此时数据的trx_id=70，在ReadView的min_trx_id和max_trx_id的范围，还在m_ids列表，这说明啥？
+
+事务A开启查询时，id=70的这个事务B还在运行，然后由这个事务B更新了这条数据，所以此时事务A不能查询到事务B更新的这个值，因此顺着指针往历史版本链条上去找，找到trx_id=50，是小于ReadView的min_trx_id的，说明在他开启查询之前，就已提交该事务，所以事务A可查询到该值，此时事务A查到的就是原始值。这就解决了不可重复读。
+
+事务A多次读同一个数据，每次读到的都是一样的值，除非是他自己修改的值，否则读到的一直一样。不管别的事务如何修改数据，事务A的ReadView始终不变，他基于这ReadView看到的值始终如一！
+
+### 解决幻读
+
+假设事务A先
+
+```sql
+select * from x where id>10
+```
+
+此时可能查到的就是一条数据，而且读到的是这条数据的原始值的那个版本：
+
+![](https://img-blog.csdnimg.cn/47f75068dda147eab73288c81285540d.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+
+现在，有个事务C插入一条数据，然后提交：
+
+![](https://img-blog.csdnimg.cn/78756b3a3f924daa9413d21dbe518cf8.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_SmF2YUVkZ2U=,size_20,color_FFFFFF,t_70,g_se,x_16)
+
+﻿接着，事务A再查询，发现符合条件的有2条数据：
+
+- 原始值那个数据
+
+- 事务C插入的那条数据
+
+  但C插入的那条数据的trx_id=80 ＞ ReadView的max_trx_id，说明是自己发起查询后，这个事务才启动，所以此时这条数据不能查询。
+
+﻿因此事务A本次查询，还是只能查到原始值那一条数据。所以这里事务A不会发生幻读，他根据条件范围查询的时候，每次读到的数据都是一样的，不会读到人家插入进去的数据，这都是依托ReadView机制实现的。
+
+## 7 MySQL的两个“视图”
+
+- view：一个用查询语句定义的虚拟表，调用时，执行查询语句并生成结果。创建视图的语法 create view … ，其查询方法与表一样
+- InnoDB实现MVCC时用的一致性读视图（consistent read view）：用于支持**读提交**、**可重复读**。没有物理结构，事务执行期间用来定义“我能看到啥数据”。
+
+## 8 “快照”在MVCC咋工作的？
+
+RR下，事务启动时就“拍了个快照”。该快照是基于整库的。若某库有100G，则启动一个事务，MySQL就要拷贝100G数据出来，这得多慢。实际上，并不需要拷贝出这100G数据。
+
+### 8.1 快照的实现
+
+InnoDB每个事务有**唯一事务ID**：transaction id，在事务开始时向InnoDB事务系统申请的，按申请顺序严格递增。
+
+#### 每行数据也有多版本
+
+每次事务更新数据时，都生成一个新**数据版本**，并把`transaction id`赋给该**数据版本**的**事务ID**，记为row trx_id。同时，旧数据版本要保留，并在新数据版本中，能有办法可直接拿到它。
+
+即一行记录可能有多个版本(row)，每个版本有自己的row trx_id。
+
+如图，就是一个记录被多个事务连续更新后的状态。行状态变更图：
+
+![](https://learn.lianglianglee.com/%e4%b8%93%e6%a0%8f/MySQL%e5%ae%9e%e6%88%9845%e8%ae%b2/assets/68d08d277a6f7926a41cc5541d3dfced.png)
+
+虚线框里是同一行数据的4个版本，当前最新版本是V4，k=22，它是被transaction id=25的事务更新，因此它的row trx_id=25。
+
+- 语句更新会生成undo log（回滚日志），在哪呢？
+  三个虚线箭头，就是undo log。V1、V2、V3并非物理上真实存在，而是每次需要时，根据当前版本和undo log计算而得。比如，需要V2时，就通过V4依次执行U3、U2计得。
+
+那InnoDB如何定义那个“100G”快照？
+按可重复读定义，一个事务启动时，能够看到所有已提交的事务结果。但之后，该事务执行期间，其他事务的更新对它不可见。
+
+因此，一个事务只需在启动时说，以我启动时刻为准：
+
+- 若一个数据版本是在我启动前生成，就认
+- 启动后才生成，我不认，我必须要找到它的上一个版本。若上个版本也不可见，就继续往前找。若是该事务自己更新的数据，它自己还是要认的。
+
+### 视图数组
+
+InnoDB为每个事务构造了一个数组，以保存该事务启动瞬间，当前正“活跃”（启动了，但尚未提交）的所有事务ID。
+
+在该数组里：
+
+- 事务ID的最小值，记为低水位
+- 当前系统里已创建过的事务ID的最大值加1，记为高水位
+
+这个视图数组和高水位，就组成了当前事务的一致性视图（read-view）。
+
+而数据版本的可见性规则，就是基于数据的row trx_id和这个一致性视图的对比结果而得。
+
+该视图数组把所有row trx_id 分成：
+数据版本可见性规则：
+
+![](https://img-blog.csdnimg.cn/20210615102540744.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_16,color_FFFFFF,t_70)
+
+对于当前事务的启动瞬间，一个数据版本的row trx_id，有如下可能：
+
+1. 若落在绿色，表示该版本是已提交的事务或当前事务自己生成的，这个数据是可见的
+2. 若落在土色，表示该版本是由将来启动的事务生成的，肯定不可见
+3. 若落在黄色，包括两种情况：
+   a. 若 row trx_id在数组中，表示该版本是由尚未提交的事务生成的，不可见
+   b. 若 row trx_id不在数组中，表示该版本是已提交的事务生成的，可见
+
+比如，对于【行状态变更图】的数据，若有一个事务，它的低水位是18，则当它访问这一行数据时，就会从V4通过U3计算出V3，所以在它看来，这一行值是11。
+
+有了该声明后，系统里随后发生的更新，就跟该事务看到的内容无关了。因为之后的更新，生成的版本一定属于上面的2或者3(a)，而对它来说，这些新的数据版本是不存在的，所以这个事务的快照，就是“静态”的了。
+
+所以InnoDB利用了“所有数据都有多版本”的特性，实现了“秒级创建快照”能力。
+
+接下来，我们开始分析一开始的三个事务
+
+## 事务案例分析
+
+假设：
+
+- 事务A开始前，系统里只有一个活跃事务ID=99
+- 事务A、B、C版本号分别是100、101、102，且当前系统里只有这四个事务
+- 三个事务开始前，(1,1）这一行数据的row trx_id是90
+
+于是：
+
+- 事务A的视图数组[99,100]
+- 事务B的视图数组是[99,100,101]
+- 事务C的视图数组是[99,100,101,102]
+
+为简化分析，先把其他干扰语句去掉，只画出跟事务A查询逻辑有关的操作：
+
+事务A查询数据逻辑图：
+
+![](https://learn.lianglianglee.com/%e4%b8%93%e6%a0%8f/MySQL%e5%ae%9e%e6%88%9845%e8%ae%b2/assets/9416c310e406519b7460437cb0c5c149.png)
+
+
+
+- 第一个有效更新是事务C，(1,1)=》(1,2)。这时，该数据的最新版本的row trx_id=102，版本90已成为历史版本
+- 第二个有效更新是事务B，(1,2)=》(1,3)。这时，该数据的最新版本（即row trx_id）=101，版本102成为历史版本
+
+事务A查询时，事务B还没提交，但它生成的(1,3)这版本已变成当前版本。但这版本对事务A必须不可见，否则就变成脏读。
+
+现在事务A要来读数据了，它的视图数组是[99,100]。读数据都是从当前版本读起的。所以，事务A查询语句的读数据流程是这样的：
+
+- 找到(1,3)的时候，判断出row trx_id=101，比高水位大，处于红色区域，不可见
+- 接着，找到上一个历史版本，一看row trx_id=102，比高水位大，处于红色区域，不可见
+- 再往前找，终于找到了（1,1)，它的row trx_id=90，比低水位小，处于绿色区域，可见
+
+这样执行下来，虽然期间这一行数据被修改过，但是事务A不论在什么时候查询，看到这行数据的结果都是一致的，所以称之为一致性读。
+
+一个数据版本，对于一个事务视图来说，除了自己的更新总是可见之外，还有如下情况：
+
+1. 版本未提交，不可见
+2. 版本已提交，但是是在视图创建后提交的，不可见
+3. 版本已提交，而且是在视图创建前提交的，可见。
+
+现在，让我们用这些规则判断查询结果，事务A的查询语句的视图数组是在事务A启动时生成的，这时：
+
+- (1,3)还没提交，属于case1，不可见
+- (1,2)虽然提交了，但却在视图数组创建之后提交，属于case2，不可见
+- (1,1)是在视图数组创建之前提交的，可见
+
+现在只需通过时间先后分析即可。
+
+## 更新逻辑
+
+事务B的update语句，若按一致性读，好像结果不对呢？
+
+你看下图，事务B的视图数组是先生成的，之后事务C才提交，不是应该看不见(1,2)吗，怎么能算出(1,3)？
+
+事务B更新逻辑图：
+
+![](https://learn.lianglianglee.com/%e4%b8%93%e6%a0%8f/MySQL%e5%ae%9e%e6%88%9845%e8%ae%b2/assets/86ad7e8abe7bf16505b97718d8ac149f.png)
+
+若事务B在更新前查询一次数据，该查询返回的k的值确实是1。
+但当它要去更新数据时，就不能再在历史版本上更新了，否则事务C的更新就丢失了。因此，事务B此时的set k=k+1是在（1,2）的基础上进行的操作。
+
+所以，这里用到规则：**更新数据，都是先读后写。这个读，只能读当前的值，即“当前读”（current read）。**
+
+因此，在更新时，当前读拿到的数据是(1,2)，更新后生成了新版本数据(1,3)，这个新版本的row trx_id是101。
+
+所以，在执行事务B查询语句时，一看自己的版本号是101，最新数据的版本号也是101，是自己的更新，可以直接使用，所以查询得到的k的值是3。
+
+#### 当前读（current read）
+
+除了update语句外，select语句若加锁，也是当前读。
+
+所以，若修改事务A的查询语句
+
+```sql
+select * from t where id=1
+```
+
+加上：
+
+- lock in share mode
+- 或for update
+
+都可读到version=101的数据，返回的k的值是3。
+
+```sql
+// 加了读锁（S锁，共享锁）
+mysql> select k from t where id=1 lock in share mode;
+// 写锁（X锁，排他锁）
+mysql> select k from t where id=1 for update;
+```
+
+假设事务C不是马上提交的，而是变成下面的事务C’，会咋样？
+事务A、B、C'的执行流程：
+
+| 事务A                                       | 事务B                                                        | 事务C'                                                       |
+| ------------------------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
+| start transaction with consistent snapshot; |                                                              |                                                              |
+|                                             | start transaction with consistent snapshot;                  |                                                              |
+|                                             |                                                              | start transaction with consistent snapshot;<br>update t set k=k+1 where id=1; |
+|                                             | update t set k=k+1 where id=1;<br>select k from t where id=1; |                                                              |
+| select k from t where id=1;<br>commit;      |                                                              | commit;                                                      |
+|                                             | commit;                                                      |                                                              |
+
+事务C’不同在于更新后并没有马上提交，在它提交前，事务B的更新语句先发起了。前面说过了，虽然事务C’还没提交，但(1,2)这个版本也已经生成了，并且是当前的最新版本。
+
+### 事务B的更新语句会咋处理？
+
+“两阶段锁协议”。事务C’没提交，即(1,2)这个版本上的写锁还没释放。而事务B是当前读，必须要读最新版本，而且必须加锁，因此就被锁住了，必须等到事务C’释放这个锁，才能继续它的当前读。
+
+事务B更新逻辑图（配合事务C'）：
+
+![](https://p.ipic.vip/7zdjb8.png)
+
+至此，一致性读、当前读和行锁就串起来了。
+
+## 事务咋实现可重复读？
+
+- 可重复读的核心是一致性读（consistent read）
+- 而事务更新数据时，只能用当前读
+
+若当前记录的行锁被其他事务占用，需进入锁等待。
+
+RC和RR最主要区别：
+
+- RR，事务开始时创建一致性视图，之后事务里的其他查询都共用该一致性视图
+- RC，每个语句执行前都会重新算出一个新视图
+
+RC下的事务A、B的查询语句查到的k，分别是啥呢？
+
+```sql
+# 从这语句开始，创建一个持续整个事务的一致性快照
+start transaction with consistent snapshot; 
+```
+
+所以，RC下的这个用法就没意义，等于普通的start transaction。
+
+#### RC时的状态图
+
+这两个查询语句的创建视图数组的时机发生了变化，即图中的read view框。（这用的还是事务C的逻辑直接提交，而非事务C’）
+
+RC下的事务状态图：
+
+![](https://p.ipic.vip/9rwszj.png)
+
+事务A的查询语句的视图数组，是在执行这语句时创建的。时序上(1,2)、(1,3)的生成时间都在创建这个视图数组的时刻之前。但在这个时刻：
+
+- (1,3)还没提交，属于情况1，不可见
+- (1,2)提交了，属于情况3，可见
+
+所以，此时：
+
+- 事务A查询语句返回的是k=2
+- 事务B查询结果k=3
+
+## 总结
+
+InnoDB的行数据有多个版本，每个数据版本有自己的row trx_id，每个事务或者语句有自己的一致性视图。普通查询语句是一致性读，一致性读会根据`row trx_id`和`一致性视图`确定数据版本的可见性。
+
+- RR：查询只承认在事务启动前，就已提交完成的数据
+- RC：查询只承认在语句启动前，就已提交完成的数据
+- 当前读：总读取已提交完成的最新版本
+
+Q：为啥表结构不支持“可重复读”？
+
+A：表结构没有对应的行数据，也没row trx_id，因此只能遵循当前读的逻辑。MySQL 8.0已可将表结构放在InnoDB字典里了，也许以后会支持表结构的可重复读。
\ No newline at end of file
diff --git a/docs/md/mysql/optimize-slow-queries-massive-row-deletions.md b/docs/md/mysql/optimize-slow-queries-massive-row-deletions.md
new file mode 100644
index 000000000..8a44e50ac
--- /dev/null
+++ b/docs/md/mysql/optimize-slow-queries-massive-row-deletions.md
@@ -0,0 +1,105 @@
+# 千万级数据删除导致的慢查询优化
+
+## 0 前言
+
+有人删了千万级的数据，结果导致频繁的慢查询。
+
+线上收到大量慢查询告警，于是检查慢查询的SQL，发现不是啥复杂SQL，这些SQL主要针对一个表，基本都是单行查询，看起来应该不会有慢查询。这种SQL基本上都是直接根据索引查找出来的，性能应该极高。
+
+是否可能慢查询不是SQL问题，而是MySQL生产服务器的问题？特殊情况下，MySQL出现慢查询还真不是SQL问题，而是他自己生产服务器的负载太高，导致SQL语句执行慢。比如现在MySQL服务器的
+
+## 1 磁盘I/O
+
+磁盘I/O负载高，每秒执行大量高负载的随机I/O，但磁盘本身每秒能执行的随机I/O有限，导致正常SQL在磁盘执行时，若跑一些随机IO，你的磁盘太忙，顾不上你了，导致你本来很快的一个SQL，要等很久才能执行完毕，这时就可能导致正常SQL也变成慢查询。
+
+## 2 网络
+
+也许网络负载高，导致你一个SQL语句要发到MySQL，光是等待获取一个和MySQL的连接，都很难，要等很久或MySQL自己网络负载太高，带宽打满，带宽打满后，你一个SQL也许执行很快，但其查出来的数据返回给你，网络都送不出去，也会变成慢查询。
+
+## 3 CPU
+
+若CPU负载过高，也会导致CPU过于繁忙去执行别的任务，没时间执行你的SQL。
+
+所以慢查询不一定是SQL本身导致，若觉得SQL不应该会慢查询，结果他那个时间段跑这个SQL  就是慢，应排查当时MySQL服务器的负载，尤其看看磁盘、网络及 CPU 的负载，是否正常。
+
+## 4 案例
+
+当某个离线作业瞬间大批量把数据往MySQL里灌入的时，他一瞬间服务器磁盘、网络以及CPU的负载会超高。
+
+此时你一个正常SQL执行下去，短时间内一定会慢查询，类似问题，优化手段更多是控制你导致MySQL负载过高的那些行为，比如灌入大量数据，最好在业务低峰期灌入，别影响高峰期的线上系统运行。
+
+但看了下MySQL服务器的磁盘、网络以及CPU负载，一切正常，似乎也不是这问题导致。看起来无解了？
+
+## 5 总结
+
+慢 SQL 的头两步排查手段：
+
+- 检查SQL是否有问题，看执行计划
+- 检查MySQL服务器的负载
+
+这两种办法都不奏效之后，第三步：用MySQL proﬁlling工具去细致的分析SQL语句的执行过程和耗时。
+
+这个工具可以对SQL语句的执行耗时进行非常深入和细致的分析
+
+## 6 使用
+
+打开proﬁling，使用
+
+```sql
+set proﬁling=1
+```
+
+接着MySQL就会自动记录查询语句的proﬁling信息。此时若执行show   proﬁles，就会给你列出各种查询语句的proﬁling信息，会记录下来每个查询语句的query   id，所以你要针对你需要分析的query找到对他的query   id，我们当时就是针对慢查询的那个SQL语句找到了query id。
+
+然后针对单个查询语句，看其proﬁling信息，使用show proﬁle cpu, block io for query xx，这里的xx是数字，此时就可以看到具体的proﬁle信息。
+
+除了cpu以及block  io以外，还能指定去看这个SQL语句执行时候的其他各项负载和耗时。
+
+会给你展示出来SQL语句执行时候的各种耗时，比如磁盘IO的耗时，CPU等待耗时，发送数据耗时，拷贝数据到临时表的耗时等，SQL执行过程中的各种耗时都会展示。
+
+检查该SQL语句的proﬁling信息后，发现问题，其Sending Data耗时最高，几乎使用1s，占据SQL执行耗时的99%！其他环节耗时低可以理解，毕竟这种简单SQL执行速度真的很快，基本就是10ms级别，结果跑成1s，那肯定Sending Data就是问题根源！
+
+这Sending Data在干啥呢？
+
+MySQL官方释义：为一个SELECT语句读取和处理数据行，同时发送数据给客户端的过程，简单来说就是为你的SELECT语句把数据读出来，同时发送给客户端。
+
+但这过程为啥这么慢？proﬁling确实是提供给我们更多的线索了，但似乎还是没法解决问题。但已经捕获到异常关键点，就是Sending  Data的耗时很高！
+
+接着：
+
+```sql
+show engine innodb status
+```
+
+看innodb存储引擎的一些状态，此时发现一个奇怪的指标：history list length，值特别高，达到上万。
+
+MVCC就是多个事务在对同一个数据， 有人写，有人读，此时可以有多种隔离级别，对一个数据有个多版本快照链条，才能实现MVCC和各种隔离级别。
+
+所以当你有大量事务执行时，就会构建这种undo多版本快照链条，此时history list length就会很高。然后在事务提交后，会有一个多版本快照链条的自动purge清理机制，清理了，该值就会降低。一般该值不应过高，所以注意到第二个线索：history list length过高，即大量的undo多版本链条数据没有清理。推测可能有的事务长时间运行，所以其多版本快照不能被purge清理，进而导致history list length过高。
+
+经过这俩线索推测，在大量简单SQL变成慢查询时，SQL因为Sending  Data环节异常，耗时过高；同时此时出现一些长事务长时间运行，大量的频繁更新数据，导致有大量undo多版本快照链条，还无法purge清理。
+
+## 7 这俩线索之间的关系是啥？
+
+因为发现有大量的更新语句在活跃，而且有那种长期活跃的长事务一直在跑而没有结束，问了下系统负责人，在后台跑了个定时任务：他居然开了一个事务，然后在一个事务里删除上千万数据，导致该事务一直在运行。
+
+这种长事务的运行会导致你删除时，仅只是对数据加了一个删除标记，事实上并没有彻底删除。此时你若和长事务同时运行的其它事务里再查询，他在查询时可能会把那上千万被标记为删除的数据都扫描一遍。因为每次扫描到一批数据，都发现标记为删除了，接着就会再继续往下扫描，所以才导致一些查询语句很慢。
+
+那为何你启动一个事务，在事务里查询，凭什么就要去扫描之前那个长事务标记为删除状态的上千万的垃圾数据？讲道理，那些数据都被删了，跟你没关系了呀，你可以不去扫描他们 嘛！
+
+### 问题症结
+
+那删除千万级数据的事务是长事务！当你启动新事务查询时，那删除千万级数据的长事务一直在运行，它是活跃的！结合MVCC Read View机制，当你启动一个新事务查询时，会生成一个Read View。新事务查询时，会根据ReadView判断：
+
+- 哪些数据可见
+- 可见的数据版本号
+
+因为每个数据都有版本链，有时你可见的仅是该数据的一个历史版。
+
+所以，正是该长事务一直在运行，还在删除大量数据，而这些数据仅是逻辑删除，此时你新开事务的查询还是会读到所有逻辑删除数据，也就会出现千万级数据扫描，导致慢查询！
+
+所以禁止业务高峰期运行删除大量数据的语句，因其可能导致正常SQL都变慢查询，因为那些SQL也许会不断扫描你标记为删除的大量数据，好不容易扫描到一批数据，结果发现是标记为删除的，于是继续扫描下去，导致慢查询！
+
+## 8 解决方案
+
+直接kill那个正在删除千万级数据的长事务，所有SQL很快恢复正常。此后，大量数据清理全部放在凌晨执行，那个时候就没什么人使用系统了，所以查询也很少。
\ No newline at end of file
diff --git "a/docs/md/tomcat/Tomcat\350\277\233\347\250\213\345\215\240\347\224\250CPU\350\277\207\351\253\230\346\200\216\344\271\210\345\212\236\357\274\237.md" b/docs/md/tomcat/how-to-solve-high-cpu-usage-in-tomcat-process.md
similarity index 86%
rename from "docs/md/tomcat/Tomcat\350\277\233\347\250\213\345\215\240\347\224\250CPU\350\277\207\351\253\230\346\200\216\344\271\210\345\212\236\357\274\237.md"
rename to docs/md/tomcat/how-to-solve-high-cpu-usage-in-tomcat-process.md
index ab04d4d1a..d4c6de753 100644
--- "a/docs/md/tomcat/Tomcat\350\277\233\347\250\213\345\215\240\347\224\250CPU\350\277\207\351\253\230\346\200\216\344\271\210\345\212\236\357\274\237.md"
+++ b/docs/md/tomcat/how-to-solve-high-cpu-usage-in-tomcat-process.md
@@ -28,11 +28,15 @@ java -Xss256k -jar demo-0.0.1-SNAPSHOT.jar
 
 线程栈大小指定256KB。对于测试程序，os默认值8192KB过大，因为需要创建4096个线程。
 
-top看到Java进程CPU使用率达961.6%，注意进程ID 55790：
+#### top
+
+见Java进程CPU使用率爆表：
 
 ![](https://img-blog.csdnimg.cn/ccc4bf66ef604b20a0875593d571c134.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_16,color_FFFFFF,t_70)
 
-精细化top查看这Java进程中各线程使用CPU情况：
+#### top细查
+
+这进程的各线程使用CPU情况：
 
 ```java
 $ top -H -p 55790
@@ -40,13 +44,17 @@ $ top -H -p 55790
 
 ![](https://img-blog.csdnimg.cn/513921500f344102b8857b0cf937b6f4.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_16,color_FFFFFF,t_70)
 
-有个“scheduling-1”线程占用较多CPU。下一步就找出这个线程在做啥。jstack生成线程快照。jstack输出较大，一般将其写入文件：
+“scheduling-1”线程占较多CPU。找这线程在做啥。
+
+#### jstack生成线程快照
+
+jstack输出较大，一般将其写入文件：
 
 ```java
 jstack 55790 > 55790.log
 ```
 
-打开55790.log，定位到第4步中找到的名为 **scheduling-1** 的线程，其线程栈：
+打开log并定位到第4步中找到的名为 **scheduling-1** 的线程，其线程栈：
 
 ![](https://img-blog.csdnimg.cn/fa069dc8e34e4c209d72b5b9a6fa8c40.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_SmF2YUVkZ2U=,size_16,color_FFFFFF,t_70)
 
@@ -89,5 +97,6 @@ grep -o 'pool-2-thread' 55790.log | wc -l
 
 ## 总结
 
-遇到CPU过高，首先定位哪个进程导致，之后可通过top -H -p pid命令定位到具体的线程。
-其次还要通jstack查看线程的状态，看看线程的个数或者线程的状态，如果线程数过多，可以怀疑是线程上下文切换的开销，我们可以通过vmstat和pidstat这两个工具进行确认。
\ No newline at end of file
+CPU过高，先定位啥进程导致，之后top -H -p pid定位具体线程。
+
+还要jstack查看线程状态，看线程个数或线程状态，若线程数过多，可怀疑是线程上下文切换开销，可通过vmstat和pidstat确认。
\ No newline at end of file
