fix

Signed-off-by: tomsun28 <tomsun28@outlook.com>
fix
2026-09-17 18:19:02 +00:00 · 2025-10-28 22:21:46 +08:00 · 2025-10-28 21:20:05 +08:00 · 2025-10-27 23:50:19 +08:00 · 2025-10-27 23:36:25 +08:00 · 2025-10-27 21:26:44 +08:00
454 changed files with 7590 additions and 13468 deletions
@@ -16,15 +16,11 @@
 #

 github:
-  description: An AI-powered next-generation open source real-time observability system.
+  description: Real-time observability system with agentless, performance cluster, prometheus-compatible, custom monitoring and status page building capabilities.
  homepage: https://hertzbeat.apache.org/
  labels:
-    - ai
-    - agent
-    - llm
-    - logs
-    - monitor
    - monitoring
+    - monitor
    - notifications
    - alerting
    - self-hosted
@@ -34,11 +30,15 @@ github:
    - metrics
    - observability
    - uptime
+    - uptime-monitoring
    - status
    - status-page
+    - devops
    - server
    - linux
    - database
+    - mysql
+    - cloud
  enabled_merge_buttons:
    squash: true
    merge: false
@@ -1,55 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-# EditorConfig is awesome: https://EditorConfig.org
-
-# top-most EditorConfig file
-root = true
-
-[*]
-charset = utf-8
-end_of_line = lf
-indent_style = space
-# The line max length is 120, match checkstyle rules.
-max_line_length = 120
-insert_final_newline = true
-trim_trailing_whitespace = true
-
-[*.json]
-tab_width = 2
-indent_size = 2
-
-[*.{yml,yaml}]
-tab_width = 2
-indent_size = 2
-
-[*.xml]
-ij_xml_attribute_wrap = off
-ij_xml_text_wrap = off
-ij_xml_keep_blank_lines = 1
-
-[pom.xml]
-indent_size = 2
-
-[*.java]
-indent_size = 4
-tab_width = 4
-
-[*.js]
-indent_size = 2
-
-[*.ts]
-indent_size = 2
@@ -90,24 +90,24 @@ e2e:
 backend:
  - changed-files:
      - any-glob-to-any-file:
-          - "hertzbeat-alerter/**/*"
-          - "hertzbeat-collector/**/*"
-          - "hertzbeat-common/**/*"
-          - "hertzbeat-grafana/**/*"
-          - "hertzbeat-manager/**/*"
-          - "hertzbeat-push/**/*"
-          - "hertzbeat-remoting/**/*"
-          - "hertzbeat-warehouse/**/*"
+          - "alerter/**/*"
+          - "collector/**/*"
+          - "common/**/*"
+          - "grafana/**/*"
+          - "manager/**/*"
+          - "push/**/*"
+          - "remoting/**/*"
+          - "warehouse/**/*"

 collector:
  - changed-files:
      - any-glob-to-any-file:
-          - "hertzbeat-collector/**/*"
+          - "collector/**/*"
            
 monitoring-template:
  - changed-files:
      - any-glob-to-any-file:
-          - "hertzbeat-manager/src/main/resources/define/**/*"
+          - "manager/src/main/resources/define/**/*"

 HIP:
  - changed-files:
@@ -39,7 +39,7 @@ jobs:
          python-version: '3.8'

      - name: Check Markdown
-        uses: DavidAnson/markdownlint-cli2-action@992badcdf24e3b8eb7e87ff9287fe931bcb00c6e
+        uses: DavidAnson/markdownlint-cli2-action@v16
        with:
          globs: './home/**/*.md'

@@ -4,7 +4,7 @@ image:
 tasks:

    - name: Run backend
-      before: cd hertzbeat-startup
+      before: cd hertzbeat-manager
      command: |
          gp sync-await setup-backend
          mvn spring-boot:run
@@ -13,7 +13,7 @@ tasks:
      before: cd web-app
      command: |
          gp sync-await setup-frontend
-          pnpm start --public-host "`gp url 4200`"
+          yarn start --public-host "`gp url 4200`"
      openMode: split-right

    - name: Setup backend
@@ -25,7 +25,7 @@ tasks:

    - name: Setup frontend
      init: |
-          cd web-app && pnpm install
+          cd web-app && yarn install
      command: |
          gp sync-done setup-frontend
          exit 0
@@ -39,7 +39,6 @@ header:
    - '**/*.js'
    - '**/*.less'
    - '**/*.txt'
-    - '**/*.st'
    - '**/target/**'
    - '.gitattributes'
    - '**/.gitignore'
@@ -31,7 +31,7 @@
    "MD025": true,
    "MD029": true,
    "MD033": {
-      "allowed_elements": ["table", "tr", "td", "a", "img", "sub", "b", "br", "img", "tbody", "mark", "font", "Tabs", "TabItem"]
+      "allowed_elements": ["table", "tr", "td", "a", "img", "sub", "b", "br", "img", "tbody", "mark", "font"]
    },
    "MD036": false,
    "MD040": true,
@@ -20,27 +20,27 @@

 - 💬**Suggestion**: You can also make some suggestions to the project or community to promote the healthy development of the community;

-More see [Contribution Types](https://allcontributors.org/emoji-key)    
+More see [Contribution Types](https://allcontributors.org/docs/en/emoji-key)    

 Even small corrections to typos are very welcome :)   

 ### Getting HertzBeat up and running   

 > To get HertzBeat code running on your development tools, and able to debug with breakpoints.
-> This is a front-end and back-end separation project. To start the local code, the back-end [startup](hertzbeat-startup) and the front-end [web-app](web-app) must be started separately.  
+> This is a front-end and back-end separation project. To start the local code, the back-end [manager](manager) and the front-end [web-app](web-app) must be started separately.  


 #### Backend start

 1. Requires `maven3+`, `java17` and `lombok` environments

-2. (Optional) Modify the configuration file: `hertzbeat-startup/src/main/resources/application.yml`
+2. (Optional) Modify the configuration file: `manager/src/main/resources/application.yml`

 3. Execute under the project root directory: `mvn clean install -DskipTests`

 4. Add VM Options: `--add-opens=java.base/java.nio=org.apache.arrow.memory.core,ALL-UNNAMED`

-5. Start `springboot startup` service: `hertzbeat-startup/src/main/java/org/apache/hertzbeat/startup/HertzBeatApplication.java`
+5. Start `springboot manager` service: `manager/src/main/java/org/apache/hertzbeat/hertzbeat-manager/Manager.java`

 #### Frontend start

@@ -131,6 +131,17 @@ Add WeChat account `ahertzbeat` to pull you into the WeChat group.

 ## 🥐 Architecture

+- **[manager](https://github.com/apache/hertzbeat/tree/master/hertzbeat-manager)** Provide monitoring management, system management basic services.
+> Provides monitoring management, monitoring configuration management, system user management, etc.
+- **[collector](https://github.com/apache/hertzbeat/tree/master/collector)** Provide metrics data collection services.
+> Use common protocols to remotely collect and obtain peer-to-peer metrics data.
+- **[warehouse](https://github.com/apache/hertzbeat/tree/master/warehouse)** Provide monitoring data warehousing services.
+> Metrics data management, data query, calculation and statistics.
+- **[alerter](https://github.com/apache/hertzbeat/tree/master/hertzbeat-alerter)** Provide alert service.
+> Alarm calculation trigger, monitoring status linkage, alarm configuration, and alarm notification.
+- **[web-app](https://github.com/apache/hertzbeat/tree/master/web-app)** Provide web ui.
+> Angular Web UI.
+
 ![hertzBeat](home/static/img/docs/hertzbeat-arch.png)

 <br>  
@@ -161,26 +172,26 @@ Add WeChat account `ahertzbeat` to pull you into the WeChat group.

 - 💬**建议**：也可以对项目或者社区提出一些建议，促进社区的良性发展；  

-更多贡献方式参见 [Contribution Types](https://allcontributors.org/emoji-key)
+更多贡献方式参见 [Contribution Types](https://allcontributors.org/docs/en/emoji-key)

 即便是小到错别字的修正我们也都非常欢迎 :)   

 ### 让 HertzBeat 运行起来   

 > 让 HertzBeat 的代码在您的开发工具上运行起来，并且能够断点调试。   
-> 此为前后端分离项目，本地代码启动需将后端[hertzbeat-startup](hertzbeat-startup)和前端[web-app](web-app)分别启动生效。
+> 此为前后端分离项目，本地代码启动需将后端[manager](manager)和前端[web-app](web-app)分别启动生效。

 #### 后端启动

 1. 需要 `maven3+`, `java17` 和 `lombok` 环境

-2. (可选)修改配置文件配置信息-`hertzbeat-startup/src/main/resources/application.yml`
+2. (可选)修改配置文件配置信息-`manager/src/main/resources/application.yml`

 3. 在项目根目录运行编译: `mvn clean install -DskipTests`

 4. 在 `jvm` 加入参数 `--add-opens=java.base/java.nio=org.apache.arrow.memory.core,ALL-UNNAMED`

-5. 启动`springboot startup`服务 `hertzbeat-startup/src/main/java/org/apache/hertzbeat/startup/HertzBeatApplication.java`
+5. 启动`springboot manager`服务 `manager/src/main/java/org/apache/hertzbeat/hertzbeat-manager/Manager.java`


 #### 前端启动
@@ -271,4 +282,15 @@ Add WeChat account `ahertzbeat` to pull you into the WeChat group.

 ### 模块

+- **[manager](https://github.com/apache/hertzbeat/tree/master/hertzbeat-manager)** 提供监控管理,系统管理基础服务
+> 提供对监控的管理，监控应用配置的管理，系统用户租户后台管理等。
+- **[collector](https://github.com/apache/hertzbeat/tree/master/collector)** 提供监控数据采集服务
+> 使用通用协议远程采集获取对端指标数据。
+- **[warehouse](https://github.com/apache/hertzbeat/tree/master/warehouse)** 提供监控数据仓储服务
+> 采集指标结果数据管理，数据落盘，查询，计算统计。
+- **[alerter](https://github.com/apache/hertzbeat/tree/master/hertzbeat-alerter)** 提供告警服务
+> 告警计算触发，任务状态联动，告警配置，告警通知。
+- **[web-app](https://github.com/apache/hertzbeat/tree/master/web-app)** 提供可视化控制台页面
+> 监控告警系统可视化控制台前端
+
 ![hertzBeat](home/static/img/docs/hertzbeat-arch.png)     
@@ -9,6 +9,8 @@
 <b><a href="README.md">English</a></b> | <a href="README_CN.md">中文</a> | <a href="README_JP.md">日本語</a>
 </p>

+> A real-time observability system with agentless, performance cluster, prometheus-compatible, custom monitoring and status page building capabilities.
+
 [![Discord](https://img.shields.io/badge/Chat-Discord-7289DA?logo=discord)](https://discord.gg/Fb6M73htGr)
 [![Reddit](https://img.shields.io/badge/Reddit-Community-7289DA?logo=reddit)](https://www.reddit.com/r/hertzbeat/)
 [![Twitter](https://img.shields.io/twitter/follow/hertzbeat1024?logo=twitter)](https://x.com/hertzbeat1024)
@@ -19,7 +21,6 @@
 [![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UCri75zfWX0GHqJFPENEbLow?logo=youtube&label=YouTube%20Channel)](https://www.youtube.com/channel/UCri75zfWX0GHqJFPENEbLow)
 [![Contribute with Gitpod](https://img.shields.io/badge/Contribute%20with-Gitpod-908a85?logo=gitpod&color=green)](https://gitpod.io/#https://github.com/apache/hertzbeat)
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/apache/hertzbeat)
-[![zread](https://img.shields.io/badge/Ask_Zread-_.svg?style=flat&color=00b0aa&labelColor=000000&logo=data%3Aimage%2Fsvg%2Bxml%3Bbase64%2CPHN2ZyB3aWR0aD0iMTYiIGhlaWdodD0iMTYiIHZpZXdCb3g9IjAgMCAxNiAxNiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTQuOTYxNTYgMS42MDAxSDIuMjQxNTZDMS44ODgxIDEuNjAwMSAxLjYwMTU2IDEuODg2NjQgMS42MDE1NiAyLjI0MDFWNC45NjAxQzEuNjAxNTYgNS4zMTM1NiAxLjg4ODEgNS42MDAxIDIuMjQxNTYgNS42MDAxSDQuOTYxNTZDNS4zMTUwMiA1LjYwMDEgNS42MDE1NiA1LjMxMzU2IDUuNjAxNTYgNC45NjAxVjIuMjQwMUM1LjYwMTU2IDEuODg2NjQgNS4zMTUwMiAxLjYwMDEgNC45NjE1NiAxLjYwMDFaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik00Ljk2MTU2IDEwLjM5OTlIMi4yNDE1NkMxLjg4ODEgMTAuMzk5OSAxLjYwMTU2IDEwLjY4NjQgMS42MDE1NiAxMS4wMzk5VjEzLjc1OTlDMS42MDE1NiAxNC4xMTM0IDEuODg4MSAxNC4zOTk5IDIuMjQxNTYgMTQuMzk5OUg0Ljk2MTU2QzUuMzE1MDIgMTQuMzk5OSA1LjYwMTU2IDE0LjExMzQgNS42MDE1NiAxMy43NTk5VjExLjAzOTlDNS42MDE1NiAxMC42ODY0IDUuMzE1MDIgMTAuMzk5OSA0Ljk2MTU2IDEwLjM5OTlaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik0xMy43NTg0IDEuNjAwMUgxMS4wMzg0QzEwLjY4NSAxLjYwMDEgMTAuMzk4NCAxLjg4NjY0IDEwLjM5ODQgMi4yNDAxVjQuOTYwMUMxMC4zOTg0IDUuMzEzNTYgMTAuNjg1IDUuNjAwMSAxMS4wMzg0IDUuNjAwMUgxMy43NTg0QzE0LjExMTkgNS42MDAxIDE0LjM5ODQgNS4zMTM1NiAxNC4zOTg0IDQuOTYwMVYyLjI0MDFDMTQuMzk4NCAxLjg4NjY0IDE0LjExMTkgMS42MDAxIDEzLjc1ODQgMS42MDAxWiIgZmlsbD0iI2ZmZiIvPgo8cGF0aCBkPSJNNCAxMkwxMiA0TDQgMTJaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik00IDEyTDEyIDQiIHN0cm9rZT0iI2ZmZiIgc3Ryb2tlLXdpZHRoPSIxLjUiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIvPgo8L3N2Zz4K&logoColor=ffffff)](https://zread.ai/apache/hertzbeat)

 **Home: [hertzbeat.apache.org](https://hertzbeat.apache.org)**   
 **Email: <a href="mailto:dev-subscribe@hertzbeat.apache.org">Mail to `dev-subscribe@hertzbeat.apache.org`</a> to subscribe mailing lists**
@@ -27,23 +28,28 @@

 ## 🎡 <font color="green">Introduction</font>

-[Apache HertzBeat™](https://github.com/apache/hertzbeat) is an AI-powered next-generation open source real-time observability system. Unified metrics and logs collection, centralized alerting distribution, intelligent management and analysis. No Agent required, high performance cluster, provides powerful custom monitoring and status page building capabilities.     
+[Apache HertzBeat™](https://github.com/apache/hertzbeat) is an easy-to-use, open source, real-time observability system with agentless, high performance cluster, prometheus-compatible, offers powerful custom monitoring and status page building capabilities.   

 ### Features

- Integrates **collection + analysis + alerting + notification** into one platform, with new AI-powered interactions and features under HertzBeat AI, and built-in MCP Server capabilities.
- Unified metrics platform, agentless, Prometheus-compatible, supports application services, programs, databases, caches, operating systems, big data, middleware, web servers, cloud-native, networks, custom monitoring and more.
- Unified logging platform, seamlessly integrates multiple log sources through OTLP protocol for reporting.
- Unified alerting platform, integrates internal alerts with various external alert sources, unified alert processing and analysis, flexible real-time and periodic threshold rules, grouping convergence, silence, suppression, etc.
- Unified message distribution, alerts processed by the alerting platform are distributed via `Email` `Discord` `Slack` `Telegram` `DingTalk` `WeChat` `FeiShu` `SMS` `Webhook` `ServerChan` and other methods.
- Makes protocols such as `Http, Jmx, Ssh, Snmp, Jdbc, Prometheus` configurable, allowing you to collect any metrics by simply configuring the template `YML` file online. Imagine being able to quickly adapt to a new monitoring type like K8s or Docker simply by configuring online with HertzBeat.
- High performance, supports horizontal expansion of multi-collector clusters, multi-isolated network monitoring and cloud-edge collaboration.
- Provides powerful status page building capabilities, easily communicate the real-time status of your service to users.
+* Combines **monitoring, alarm, and notification** features into one platform, and supports monitoring for web service, program, database, cache, os, webserver, middleware, bigdata, cloud-native, network, custom and more.
+* Easy to use and agentless, web-based and with one-click monitoring and alerting, zero learning curve.
+* Makes protocols such as `Http, Jmx, Ssh, Snmp, Jdbc, Prometheus` configurable, allowing you to collect any metrics by simply configuring the template `YML` file online. Imagine being able to quickly adapt to a new monitoring type like K8s or Docker simply by configuring online with HertzBeat.
+* Compatible with the `Prometheus` ecosystem and more, can monitoring what `Prometheus` can monitoring with few clicks on webui.
+* High performance, supports horizontal expansion of multi-collector clusters, multi-isolated network monitoring and cloud-edge collaboration.
+* Provides flexible alarm threshold rules and timely notifications delivered via  `Discord` `Slack` `Telegram` `Email` `Dingtalk` `WeChat` `FeiShu` `Webhook` `SMS` `ServerChan`.
+* Provides powerful status page building capabilities, easily communicate the real-time status of your service to users.

-> HertzBeat's unified platform, AI intelligence, powerful customization, multi-type support, high performance, and easy expansion, aims to help users quickly and conveniently achieve observability requirements.      
+> HertzBeat's powerful customization, multi-type support, high performance, easy expansion, and low coupling, aims to help users quickly build their own monitoring system.      

 ----

+![hertzbeat](home/static/img/home/1.png)
+
+![hertzbeat](home/static/img/home/status.png)
+
+![hertzbeat](home/static/img/home/9.png)
+
 ----

 ## 🥐 Architecture   
@@ -52,8 +58,8 @@

 ## ⛄ Supported   

-> We define all metrics collection types such as `mysql`, `jvm`, and `k8s` as `YML` templates, allowing users to import them to support corresponding types of monitoring.
-> Welcome everyone to contribute your customized general metrics type YML template during use.
+> We define all monitoring collection types such as `mysql`, `jvm`, and `k8s` as `YML` monitoring templates, allowing users to import them to support corresponding types of monitoring.
+> Welcome everyone to contribute your customized general monitoring type YML template during use.


 - [Website](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-website.yml), [Port Telnet](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-port.yml),
@@ -155,8 +161,8 @@ Detailed config refer to [Install HertzBeat via Package](https://hertzbeat.apach

 ##### 3：Start via source code        

-1. Local source code debugging needs to start the back-end project `hertzbeat-startup` and the front-end project `web-app`.  
-2. Backend：need `maven3+`, `java17`, `lombok`, add VM options in IDE: ` --add-opens=java.base/java.nio=org.apache.arrow.memory.core,ALL-UNNAMED `, then start the `hertzbeat-startup` service. 
+1. Local source code debugging needs to start the back-end project `manager` and the front-end project `web-app`.  
+2. Backend：need `maven3+`, `java17`, `lombok`, add VM options in IDE: ` --add-opens=java.base/java.nio=org.apache.arrow.memory.core,ALL-UNNAMED `, then start the `manager` service. 
 3. Web：need `nodejs npm angular-cli` environment, Run `ng serve --open` in `web-app` directory after backend startup.  
 4. Access `http://localhost:4200` to start, default account: `admin/hertzbeat`  

@@ -9,6 +9,8 @@
 <a href="README.md">English</a> | <b><a href="README_CN.md">中文</a></b> | <a href="README_JP.md">日本語</a>
 </p>

+> 实时观测系统，无需 Agent，性能集群，兼容 Prometheus，自定义监控和状态页构建能力。
+
 [![Discord](https://img.shields.io/badge/Chat-Discord-7289DA?logo=discord)](https://discord.gg/Fb6M73htGr)
 [![Reddit](https://img.shields.io/badge/Reddit-Community-7289DA?logo=reddit)](https://www.reddit.com/r/hertzbeat/)
 [![Twitter](https://img.shields.io/twitter/follow/hertzbeat1024?logo=twitter)](https://x.com/hertzbeat1024)
@@ -26,24 +28,29 @@

 ## 🎡 <font color="green">介绍</font>

-[Apache HertzBeat™](https://github.com/apache/hertzbeat) 是 AI 驱动的下一代开源实时观测系统。指标日志统一收集，告警一站分发，智能管控分析。无需 Agent，高性能集群，提供强大的自定义监控和状态页构建能力。     
+[Apache HertzBeat™](https://github.com/apache/hertzbeat) 是一个易用友好的开源实时监控告警系统，无需 Agent，高性能集群，兼容 Prometheus，提供强大的自定义监控和状态页构建能力。     

 ### 特点

- 集```采集+分析+告警+通知```为一体，HertzBeat AI 驱动下的新交互与功能，也内置 MCP Server 对外能力。
- 统一的指标平台，无需 Agent，兼容 Prometheus，支持应用服务，程序，数据库，缓存，操作系统，大数据，中间件，Web 服务器，云原生，网络，自定义等。
- 统一的日志平台，通过 OTLP 协议多日志源无缝对接上报。
- 统一的告警平台，内部告警与外部多种告警源集成接入，统一告警处理分析，灵活的实时与周期阈值规则，分组收敛，静默，抑制等。
- 统一的消息分发，告警平台处理后通过 `邮件` `Discord` `Slack` `Telegram` `钉钉` `微信` `飞书` `短信` `Webhook` `Server酱` 等方式分发通知。
- 将 `Http, Jmx, Ssh, Snmp, Jdbc, Prometheus` 等协议规范可配置化，只需配置模板 `YML` 就能自定义采集指标。您相信只需简单配置即可快速适配一款 `K8s` 或 `Docker` 等新的监控类型吗？
+- 集 **监控+告警+通知** 为一体，支持对应用服务，应用程序，数据库，缓存，操作系统，大数据，中间件，Web 服务器，云原生，网络，自定义等监控阈值告警通知一步到位。
+- 易用友好，无需 `Agent`，全 `WEB` 页面操作，鼠标点一点就能监控告警，无需学习成本。    
+- 将 `Http, Jmx, Ssh, Snmp, Jdbc, Prometheus` 等协议规范可配置化，只需在浏览器配置监控模板 `YML` 就能使用这些协议去自定义采集想要的指标。您相信只需简单配置即可快速适配一款 `K8s` 或 `Docker` 等新的监控类型吗？  
+- 兼容 `Prometheus` 的系统生态并且更多，只需页面操作就可以监控 `Prometheus` 所能监控的。
 - 高性能，支持多采集器集群横向扩展，支持多隔离网络监控，云边协同。
+- 灵活的告警阈值规则，`邮件` `Discord` `Slack` `Telegram` `钉钉` `微信` `飞书` `短信` `Webhook` `Server酱` 等方式消息及时送达。
 - 提供强大的状态页构建能力，轻松向用户传达您产品服务的实时状态。


-> `HertzBeat`的统一平台，AI智能，强大自定义，多类型支持，高性能，易扩展，希望能帮助用户快速方便实现观测需求。    
+> `HertzBeat`的强大自定义，多类型支持，高性能，易扩展，低耦合，希望能帮助用户快速搭建自有监控系统。    

 ----

+![hertzbeat](home/static/img/home/1.png)
+
+![hertzbeat](home/static/img/home/status.png)
+
+![hertzbeat](home/static/img/home/9.png)
+
 ----

 ## 🥐 模块  
@@ -52,8 +59,8 @@

 ## ⛄ 已支持    

-> 我们将监控采集类型（mysql,jvm,k8s）都定义为 `yml` 模板，用户可以导入这些模板来支持对应类型的监控!    
-> 欢迎大家一起贡献你使用过程中自定义的通用指标模板。
+> 我们将监控采集类型（mysql,jvm,k8s）都定义为 `yml` 监控模板，用户可以导入这些模板来支持对应类型的监控!    
+> 欢迎大家一起贡献你使用过程中自定义的通用监控类型监控模板。

 - [Website](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-website.yml), [Port Telnet](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-port.yml),
  [Http Api](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-api.yml), [Ping Connect](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-ping.yml),
@@ -91,7 +98,7 @@
 - [CiscoSwitch](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-cisco_switch.yml), [HpeSwitch](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-hpe_switch.yml),
  [HuaweiSwitch](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-huawei_switch.yml), [TpLinkSwitch](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-tplink_switch.yml),
  [H3cSwitch](https://raw.githubusercontent.com/apache/hertzbeat/master/hertzbeat-manager/src/main/resources/define/app-h3c_switch.yml)
- 和更多自定义指标模板。
+- 和更多自定义监控模板。
 - 通知支持 `Discord` `Slack` `Telegram` `邮件` `钉钉` `微信` `飞书` `短信` `Webhook` `Server酱`。

 ## 🐕 快速开始  
@@ -152,8 +159,8 @@

 ##### 方式三：本地代码启动

-1. 此为前后端分离项目，本地代码调试需要分别启动后端工程 `hertzbeat-startup` 和前端工程 `web-app`
-2. 后端：需要 `maven3+`, `java17` 和 `lombok` 环境，修改 `YML` 配置信息，添加JVM参数`--add-opens=java.base/java.nio=org.apache.arrow.memory.core,ALL-UNNAMED`后启动 `hertzbeat-startup` 服务即可。
+1. 此为前后端分离项目，本地代码调试需要分别启动后端工程 `manager` 和前端工程 `web-app`
+2. 后端：需要 `maven3+`, `java17` 和 `lombok` 环境，修改 `YML` 配置信息，添加JVM参数`--add-opens=java.base/java.nio=org.apache.arrow.memory.core,ALL-UNNAMED`后启动 `manager` 服务即可。
 3. 前端：需要 `nodejs npm angular-cli`环境，待本地后端启动后，在 `web-app` 目录下启动 `ng serve --open`
 4. 浏览器访问 `http://localhost:4200` 即可开始，默认账号密码 `admin/hertzbeat`

@@ -9,6 +9,8 @@
 <a href="README.md">English</a> | <a href="README_CN.md">中文</a> | <b><a href="README_JP.md">日本語</a></b>
 </p>  

+> オープンソースのリアルタイム監視システム、エージェントレス、クラスタ対応、Prometheus互換、カスタムおよびステータスページ付き。
+
 [![Discord](https://img.shields.io/badge/Chat-Discord-7289DA?logo=discord)](https://discord.gg/Fb6M73htGr)
 [![Reddit](https://img.shields.io/badge/Reddit-Community-7289DA?logo=reddit)](https://www.reddit.com/r/hertzbeat/)
 [![Twitter](https://img.shields.io/twitter/follow/hertzbeat1024?logo=twitter)](https://x.com/hertzbeat1024)
@@ -26,23 +28,29 @@

 ## 🎡 <font color="green">紹介</font>

-[Apache HertzBeat™](https://github.com/apache/hertzbeat) は AI 駆動の次世代オープンソースリアルタイム観測システムです。メトリクスとログの統一収集、アラートの一元配信、インテリジェント管理分析。エージェント不要、高性能クラスタ、強力なカスタム監視とステータスページ構築機能を提供します。     
+[Apache HertzBeat](https://github.com/apache/hertzbeat) （incubating）はオープンソースのリアルタイム監視システム、エージェントレス、クラスタ対応、Prometheus互換、カスタムおよびステータスページ付き。     

 ### 特性

- **収集+分析+アラート+通知**を一つのプラットフォームに統合し、HertzBeat AI 駆動の新しいインタラクションと機能、内蔵 MCP Server 機能を提供。
- 統一メトリクスプラットフォーム、エージェントレス、Prometheus互換、アプリケーションサービス、プログラム、データベース、キャッシュ、オペレーティングシステム、ビッグデータ、ミドルウェア、Webサーバー、クラウドネイティブ、ネットワーク、カスタム監視などをサポート。
- 統一ログプラットフォーム、OTLP プロトコルを通じて複数のログソースをシームレスに統合してレポート。
- 統一アラートプラットフォーム、内部アラートと様々な外部アラートソースを統合接続、統一アラート処理分析、柔軟なリアルタイムと周期的閾値ルール、グループ収束、サイレンス、抑制など。
- 統一メッセージ配信、アラートプラットフォームで処理後、`メール` `Discord` `Slack` `Telegram` `DingTalk` `WeChat` `FeiShu` `SMS` `Webhook` `ServerChan` などの方法で配信通知。
- `Http、Jmx、Ssh、Snmp、Jdbc、Prometheus`などのプロトコルを設定可能にし、テンプレート`YML`ファイルをオンラインで設定するだけで、あらゆるメトリクスを収集できるようにします。HertzBeatでオンライン設定するだけで、`K8s`や`Docker`のような新しい監視タイプに素早く対応できることを想像してみてください。
- 高性能で、コレクタークラスタの水平拡張、マルチ分離ネットワーク監視、クラウドエッジ協調をサポート。
- 強力なステータスページ構築機能を提供し、サービスのリアルタイムステータスをユーザーに簡単に伝達。
+- **モニター・アラーム・通知** を一体化し、Web、データベース、キャッシュ、OS、ミドルウェア、クラウドネイティブ、ネットワークなどをサポート。
+- 使いやすさを重視し、マウスのクリックだけで完全なWebベースの操作が可能。
+- `Http、Jmx、Ssh、Snmp、jdbc、Prometheus`などのプロトコルを設定可能にし、テンプレート`YML`ファイルをオンラインで設定するだけで、あらゆるメトリクスを収集できるようにします。HertzBeatでオンライン設定するだけで、`K8S`や`Docker`のような新しい監視タイプに素早く対応できることを想像してみてください。
+- `Prometheus`のエコシステム互換、Prometheusが監視できるものを、全てオンライン設定によって監視することができます。
+- 高性能で、コレクタークラスタ、マルチアイソレートネットワーク、クラウドエッジをサポート。
+- 柔軟なアラーム閾値ルールで、メール、discord、slack、telegramなどを通じてタイムリーに通知。
+- 強力なステータスページを簡単に構築し、リアルタイムのステータスをユーザーと共有。

-> `HertzBeat`の統一プラットフォーム、AI インテリジェンス、強力なカスタマイズ、多種類サポート、高性能、容易な拡張性は、ユーザーが迅速かつ便利に観測要件を実現することを支援することを目的としています。    
+
+> `HertzBeat`の強力なカスタマイズ、多種類のサポート、高性能および容易な拡張性は、ユーザーが迅速に独自の監視システムを構築するのを支援することを目的としています。    

 ----

+![hertzbeat](home/static/img/home/1.png)
+
+![hertzbeat](home/static/img/home/status.png)
+
+![hertzbeat](home/static/img/home/9.png)
+
 ----

 ## 🥐 モジュール  
@@ -155,8 +163,8 @@

 ##### 方式３：ローカルの実行

-1. ローカルの実行には、バックエンドのプロジェクト`hertzbeat-startup`とフロントエンドのプロジェクト`web-app`を起動する必要があります。
-2. バックエンド：`maven3+`、`java17`と`lombok`の環境は必要です。`YML` 設定を修正し、Java仮想マシンパラメータに`--add-opens=java.base/java.nio=org.apache.arrow.memory.core,ALL-UNNAMED` を追加し、`hertzbeat-startup` を起動します。
+1. ローカルの実行には、バックエンドのプロジェクト`manager`とフロントエンドのプロジェクト`web-app`を起動する必要があります。
+2. バックエンド：`maven3+`、`java17`と`lombok`の環境は必要です。`YML` 設定を修正し、Java仮想マシンパラメータに`--add-opens=java.base/java.nio=org.apache.arrow.memory.core,ALL-UNNAMED` を追加し、`manager` を起動します。
 3. フロントエンド：`nodejs npm angular-cli`の環境は必要です。ローカルのバックエンドが立ち上がったら、`web-app` ディレクトリで `ng serve --open` というコマンドを実行します。
 4. スタート：`http://localhost:4200`にアクセスします。デフォルトのアカウントとパスワード：`admin/hertzbeat`。

@@ -5,7 +5,7 @@
      "intervals": 60,
      "tags": [],
      "app": "ftp",
-      "instance": "127.0.0.1",
+      "host": "127.0.0.1",
      "name": "{{.param.monitorFTP}}"
    },
    "params": [
@@ -5,7 +5,7 @@
    "intervals": 60,
    "tags": [],
    "app": "api",
-    "instance": "127.0.0.1",
+    "host": "127.0.0.1",
      "name": "{{.param.monitorHTTP}}"
  },
  "params": [
@@ -5,7 +5,7 @@
      "intervals": 60,
      "tags": [],
      "app": "ping",
-      "instance": "127.0.0.1",
+      "host": "127.0.0.1",
      "name": "{{.param.monitorPing}}"
    },
    "params": [
@@ -5,7 +5,7 @@
      "intervals": 60,
      "tags": [],
      "app": "port",
-      "instance": "127.0.0.1",
+      "host": "127.0.0.1",
      "name": "{{.param.monitorPort}}"
    },
    "params": [
@@ -5,7 +5,7 @@
      "intervals": 60,
      "tags": [],
      "app": "fullsite",
-      "instance": "127.0.0.1",
+      "host": "127.0.0.1",
      "name": "{{.param.monitorSiteMap}}"
    },
    "params": [
@@ -5,7 +5,7 @@
      "intervals": 60,
      "tags": [],
      "app": "ssl_cert",
-      "instance": "127.0.0.1",
+      "host": "127.0.0.1",
      "name": "{{.param.monitorSSL}}"
    },
    "params": [
@@ -5,7 +5,7 @@
      "intervals": 60,
      "tags": [],
      "app": "udp_port",
-      "instance": "127.0.0.1",
+      "host": "127.0.0.1",
      "name": "{{.param.monitorUDP}}"
    },
    "params": [
@@ -5,7 +5,7 @@
      "intervals": 60,
      "tags": [],
      "app": "website",
-      "instance": "127.0.0.1",
+      "host": "127.0.0.1",
      "name": "{{.param.monitorWebsite}}"
    },
    "params": [
@@ -4,7 +4,7 @@
    "intervals": 10,
    "tags": [],
    "app": "kubernetes",
-    "instance": "172.29.0.11",
+    "host": "172.29.0.11",
    "name": "Brave_Stingray_55yR"
  },
  "collector": "",
@@ -26,7 +26,7 @@
 	<artifactId>hertzbeat-ai</artifactId>
 	<version>${hertzbeat.version}</version>
 	<properties>
-		<spring-ai.version>1.1.1</spring-ai.version>
+		<spring-ai.version>1.0.3</spring-ai.version>
 		<java.version>17</java.version>
 	</properties>

@@ -65,15 +65,12 @@
        <dependency>
            <groupId>org.apache.hertzbeat</groupId>
            <artifactId>hertzbeat-base</artifactId>
+            <scope>provided</scope>
        </dependency>
 		<dependency>
 			<groupId>org.apache.hertzbeat</groupId>
 			<artifactId>hertzbeat-alerter</artifactId>
 		</dependency>
-        <dependency>
-            <groupId>org.apache.hertzbeat</groupId>
-            <artifactId>hertzbeat-manager</artifactId>
-        </dependency>
 		<dependency>
 			<groupId>com.usthe.sureness</groupId>
 			<artifactId>spring-boot3-starter-sureness</artifactId>
@@ -0,0 +1,81 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hertzbeat.ai.adapters;
+
+import org.apache.hertzbeat.ai.pojo.dto.Hierarchy;
+import org.apache.hertzbeat.common.entity.alerter.AlertDefine;
+import org.springframework.data.domain.Page;
+
+import java.util.List;
+
+/**
+ * Interface that provides access to alert definition information by retrieving data
+ * through the underlying alert define service.
+ */
+public interface AlertDefineServiceAdapter {
+
+    /**
+     * Add a new alert rule definition
+     * @param alertDefine Alert definition to add
+     * @return Created alert definition with ID
+     */
+    AlertDefine addAlertDefine(AlertDefine alertDefine);
+
+    /**
+     * Get alert definitions with filtering and pagination
+     * @param search Search term
+     * @param app Monitor type filter
+     * @param enabled Enabled status filter
+     * @param sort Sort field
+     * @param order Sort order
+     * @param pageIndex Page index
+     * @param pageSize Page size
+     * @return Page of alert definitions
+     */
+    Page<AlertDefine> getAlertDefines(String search, String app, Boolean enabled, String sort, String order, int pageIndex, int pageSize);
+
+    /**
+     * Get alert definition by ID
+     * @param id Alert definition ID
+     * @return Alert definition if found
+     */
+    AlertDefine getAlertDefine(Long id);
+
+    /**
+     * Enable or disable alert definition
+     * @param id Alert definition ID
+     * @param enabled Whether to enable
+     */
+    void toggleAlertDefineStatus(Long id, boolean enabled);
+
+    /**
+     * Modify/update an existing alert definition
+     * @param alertDefine Alert definition to update
+     * @return Updated alert definition
+     */
+    AlertDefine modifyAlertDefine(AlertDefine alertDefine);
+
+    /**
+     * Get specific app hierarchy structure
+     * @param app App type
+     * @param lang Language for localization
+     * @return List of hierarchy objects for specific app
+     */
+
+    List<Hierarchy> getAppHierarchy(String app, String lang);
+}
@@ -0,0 +1,60 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hertzbeat.ai.adapters;
+
+import org.apache.hertzbeat.alert.dto.AlertSummary;
+import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
+import org.apache.hertzbeat.common.entity.alerter.SingleAlert;
+import org.springframework.data.domain.Page;
+
+/**
+ * Interface that provides access to alert information by retrieving alert data
+ * through the underlying alert service.
+ */
+public interface AlertServiceAdapter {
+
+    /**
+     * Get single alerts with filtering and pagination
+     * @param status Alert status
+     * @param search Search term
+     * @param sort Sort field
+     * @param order Sort order
+     * @param pageIndex Page index
+     * @param pageSize Page size
+     * @return Page of single alerts
+     */
+    Page<SingleAlert> getSingleAlerts(String status, String search, String sort, String order, int pageIndex, int pageSize);
+
+    /**
+     * Get group alerts with filtering and pagination
+     * @param status Alert status
+     * @param search Search term
+     * @param sort Sort field
+     * @param order Sort order
+     * @param pageIndex Page index
+     * @param pageSize Page size
+     * @return Page of group alerts
+     */
+    Page<GroupAlert> getGroupAlerts(String status, String search, String sort, String order, int pageIndex, int pageSize);
+
+    /**
+     * Get alerts summary statistics
+     * @return Alert summary information
+     */
+    AlertSummary getAlertsSummary();
+}
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hertzbeat.ai.adapters;
+
+import org.apache.hertzbeat.common.entity.dto.MetricsData;
+import org.apache.hertzbeat.common.entity.dto.MetricsHistoryData;
+
+/**
+ * Interface that provides access to metrics information by retrieving metrics data
+ * through the underlying metrics service.
+ */
+public interface MetricsServiceAdapter {
+
+    /**
+     * Check warehouse storage server status
+     * @return true if warehouse is available, false otherwise
+     */
+    Boolean getWarehouseStorageServerStatus();
+
+    /**
+     * Query real-time metrics data
+     * @param monitorId Monitor ID
+     * @param metrics Metrics name
+     * @return Real-time metrics data
+     */
+    MetricsData getMetricsData(Long monitorId, String metrics);
+
+    /**
+     * Query historical metrics data
+     * @param monitorId Monitor ID
+     * @param app Monitor type
+     * @param metrics Metrics name
+     * @param metric Metric field name
+     * @param label Label filter
+     * @param history Query historical time period
+     * @param interval Whether to aggregate data
+     * @return Historical metrics data
+     */
+    MetricsHistoryData getMetricHistoryData(Long monitorId, String app, String metrics, String metric, String label, String history, Boolean interval);
+}
@@ -0,0 +1,71 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package org.apache.hertzbeat.ai.adapters;
+
+import org.springframework.data.domain.Page;
+import org.apache.hertzbeat.common.entity.manager.Monitor;
+import org.apache.hertzbeat.common.entity.manager.Param;
+import org.apache.hertzbeat.common.entity.manager.ParamDefine;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Interface that provides access to monitor information by retrieving monitor data
+ * through the underlying monitor service.
+ */
+public interface MonitorServiceAdapter {
+    Page<Monitor> getMonitors(
+            List<Long> ids,
+            String app,
+            String search,
+            Byte status,
+            String sort,
+            String order,
+            Integer pageIndex,
+            Integer pageSize,
+            String labels
+    );
+
+    /**
+     * Add a new monitor
+     *
+     * @param monitor The monitor entity to create
+     * @param params List of parameters for the monitor
+     * @param collector Optional collector assignment
+     * @return The created monitor ID
+     */
+    Long addMonitor(Monitor monitor, List<Param> params, String collector);
+
+    /**
+     * Get all available monitor types with their display names
+     *
+     * @param language Language code (e.g., "en-US", "zh-CN")
+     * @return Map of monitor type key to display name
+     */
+    Map<String, String> getAvailableMonitorTypes(String language);
+
+    /**
+     * Get parameter definitions for a specific monitor type
+     *
+     * @param app Monitor type/application name (e.g., "linux", "mysql", "redis")
+     * @return List of parameter definitions for the monitor type
+     */
+    List<ParamDefine> getMonitorParamDefines(String app);
+}
+
@@ -0,0 +1,257 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hertzbeat.ai.adapters.impl;
+
+import com.usthe.sureness.subject.SubjectSum;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.hertzbeat.ai.adapters.AlertDefineServiceAdapter;
+import org.apache.hertzbeat.ai.config.McpContextHolder;
+import org.apache.hertzbeat.ai.pojo.dto.Hierarchy;
+import org.apache.hertzbeat.ai.utils.UtilityClass;
+import org.apache.hertzbeat.common.entity.alerter.AlertDefine;
+import org.apache.hertzbeat.common.support.SpringContextHolder;
+import org.springframework.data.domain.Page;
+import org.springframework.stereotype.Component;
+
+import java.lang.reflect.Method;
+import java.util.List;
+
+/**
+ * Implementation of the AlertDefineServiceAdapter interface that provides access to alert definition information
+ * through reflection by invoking the underlying alert define service implementation.
+ */
+@Slf4j
+@Component
+public class AlertDefineServiceAdapterImpl implements AlertDefineServiceAdapter {
+
+    @Override
+    public AlertDefine addAlertDefine(AlertDefine alertDefine) {
+        try {
+            Object alertDefineService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for addAlertDefine: {}", subjectSum);
+
+            try {
+                alertDefineService = SpringContextHolder.getBean("alertDefineServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'alertDefineServiceImpl'");
+            }
+
+            assert alertDefineService != null;
+            log.debug("AlertDefineService bean found: {}", alertDefineService.getClass().getSimpleName());
+            
+            Method method = alertDefineService.getClass().getMethod("addAlertDefine", AlertDefine.class);
+
+            method.invoke(alertDefineService, alertDefine);
+            
+            log.debug("Successfully added alert define with ID: {}", alertDefine.getId());
+            return alertDefine;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: addAlertDefine", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke addAlertDefine via adapter", e);
+            throw new RuntimeException("Failed to invoke addAlertDefine via adapter: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public Page<AlertDefine> getAlertDefines(String search, String app, Boolean enabled, String sort, String order, int pageIndex, int pageSize) {
+        try {
+            Object alertDefineService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getAlertDefines: {}", subjectSum);
+
+            try {
+                alertDefineService = SpringContextHolder.getBean("alertDefineServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'alertDefineServiceImpl'");
+            }
+
+            assert alertDefineService != null;
+            log.debug("AlertDefineService bean found: {}", alertDefineService.getClass().getSimpleName());
+            
+            Method method = alertDefineService.getClass().getMethod(
+                    "getAlertDefines",
+                    List.class, String.class, String.class, String.class, int.class, int.class);
+
+            @SuppressWarnings("unchecked")
+            Page<AlertDefine> result = (Page<AlertDefine>) method.invoke(
+                    alertDefineService, null, search, sort, order, pageIndex, pageSize);
+            
+            log.debug("Successfully retrieved {} alert defines", result.getContent().size());
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getAlertDefines", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke getAlertDefines via adapter", e);
+            throw new RuntimeException("Failed to invoke getAlertDefines via adapter: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public AlertDefine getAlertDefine(Long id) {
+        try {
+            Object alertDefineService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getAlertDefine: {}", subjectSum);
+
+            try {
+                alertDefineService = SpringContextHolder.getBean("alertDefineServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'alertDefineServiceImpl'");
+            }
+
+            assert alertDefineService != null;
+            log.debug("AlertDefineService bean found: {}", alertDefineService.getClass().getSimpleName());
+            
+            Method method = alertDefineService.getClass().getMethod("getAlertDefine", long.class);
+
+            AlertDefine result = (AlertDefine) method.invoke(alertDefineService, id);
+            
+            log.debug("Successfully retrieved alert define with ID: {}", id);
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getAlertDefine", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke getAlertDefine via adapter for ID: {}", id, e);
+            throw new RuntimeException("Failed to invoke getAlertDefine via adapter: " + e.getMessage(), e);
+        }
+    }
+
+
+    @Override
+    public void toggleAlertDefineStatus(Long id, boolean enabled) {
+        try {
+            Object alertDefineService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for toggleAlertDefineStatus: {}", subjectSum);
+
+            try {
+                alertDefineService = SpringContextHolder.getBean("alertDefineServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'alertDefineServiceImpl'");
+            }
+
+            assert alertDefineService != null;
+            log.debug("AlertDefineService bean found: {}", alertDefineService.getClass().getSimpleName());
+            
+            // First get the existing AlertDefine
+            Method getMethod = alertDefineService.getClass().getMethod("getAlertDefine", long.class);
+            AlertDefine alertDefine = (AlertDefine) getMethod.invoke(alertDefineService, id);
+            
+            if (alertDefine == null) {
+                throw new RuntimeException("AlertDefine with ID " + id + " not found");
+            }
+            
+            // Update the enable status
+            alertDefine.setEnable(enabled);
+            
+            // Use modifyAlertDefine to save the changes
+            Method modifyMethod = alertDefineService.getClass().getMethod("modifyAlertDefine", AlertDefine.class);
+            modifyMethod.invoke(alertDefineService, alertDefine);
+            
+            log.debug("Successfully toggled alert define status for ID: {} to enabled: {}", id, enabled);
+
+        } catch (Exception e) {
+            log.error("Failed to invoke toggleAlertDefineStatus via adapter for ID: {}", id, e);
+            throw new RuntimeException("Failed to invoke toggleAlertDefineStatus via adapter: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public AlertDefine modifyAlertDefine(AlertDefine alertDefine) {
+        try {
+            Object alertDefineService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for modifyAlertDefine: {}", subjectSum);
+
+            try {
+                alertDefineService = SpringContextHolder.getBean("alertDefineServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'alertDefineServiceImpl'");
+            }
+
+            assert alertDefineService != null;
+            log.debug("AlertDefineService bean found: {}", alertDefineService.getClass().getSimpleName());
+            
+            Method method = alertDefineService.getClass().getMethod("modifyAlertDefine", AlertDefine.class);
+
+            method.invoke(alertDefineService, alertDefine);
+            
+            log.debug("Successfully modified alert define with ID: {}", alertDefine.getId());
+            return alertDefine;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: modifyAlertDefine", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke modifyAlertDefine via adapter", e);
+            throw new RuntimeException("Failed to invoke modifyAlertDefine via adapter: " + e.getMessage(), e);
+        }
+    }
+
+    /**
+     * Retrieves the application hierarchy for a given app and language.
+     * Uses reflection to call the underlying app service method.
+     *
+     * @param app  The application name
+     * @param lang The language code (optional, defaults to "en-US")
+     * @return List of Hierarchy objects representing the app hierarchy
+     */
+
+    @Override
+    public List<Hierarchy> getAppHierarchy(String app, String lang) {
+        try {
+            Object appService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getAppHierarchy: {}", subjectSum);
+
+            try {
+                appService = SpringContextHolder.getBean("appServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'appServiceImpl', trying by class name");
+            }
+
+            assert appService != null;
+            log.debug("AppService bean found for getAppHierarchy: {}", appService.getClass().getSimpleName());
+
+            // Provide default language if not specified
+            if (lang == null || lang.trim().isEmpty()) {
+                lang = "en-US";
+            }
+
+            // Call getAppHierarchy method: getAppHierarchy(String app, String lang)
+            Method method = appService.getClass().getMethod("getAppHierarchy", String.class, String.class);
+
+            List<?> managerHierarchies = (List<?>) method.invoke(appService, app, lang);
+
+            // Convert manager DTOs to ai-agent DTOs
+            List<Hierarchy> result = UtilityClass.convertToAgentHierarchies(managerHierarchies);
+
+            log.debug("Successfully retrieved and converted {} hierarchies for app '{}'", result.size(), app);
+            return result;
+
+        } catch (Exception e) {
+            log.error("Failed to get app hierarchy for app '{}': {}", app, e.getMessage(), e);
+            throw new RuntimeException("Failed to get app hierarchy for " + app, e);
+        }
+    }
+
+}
@@ -0,0 +1,141 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hertzbeat.ai.adapters.impl;
+
+import com.usthe.sureness.subject.SubjectSum;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.hertzbeat.ai.adapters.AlertServiceAdapter;
+import org.apache.hertzbeat.ai.config.McpContextHolder;
+import org.apache.hertzbeat.alert.dto.AlertSummary;
+import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
+import org.apache.hertzbeat.common.entity.alerter.SingleAlert;
+import org.apache.hertzbeat.common.support.SpringContextHolder;
+import org.springframework.data.domain.Page;
+import org.springframework.stereotype.Component;
+
+import java.lang.reflect.Method;
+
+/**
+ * Implementation of the AlertServiceAdapter interface that provides access to alert information
+ * through reflection by invoking the underlying alert service implementation.
+ */
+@Slf4j
+@Component
+public class AlertServiceAdapterImpl implements AlertServiceAdapter {
+
+    @Override
+    public Page<SingleAlert> getSingleAlerts(String status, String search, String sort, String order, int pageIndex, int pageSize) {
+        try {
+            Object alertService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getSingleAlerts: {}", subjectSum);
+
+            try {
+                alertService = SpringContextHolder.getBean("alertServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'alertServiceImpl'");
+            }
+
+            assert alertService != null;
+            log.debug("AlertService bean found: {}", alertService.getClass().getSimpleName());
+            
+            Method method = alertService.getClass().getMethod(
+                    "getSingleAlerts",
+                    String.class, String.class, String.class, String.class, int.class, int.class);
+
+            @SuppressWarnings("unchecked")
+            Page<SingleAlert> result = (Page<SingleAlert>) method.invoke(
+                    alertService, status, search, sort, order, pageIndex, pageSize);
+            
+            log.debug("Successfully retrieved {} single alerts", result.getContent().size());
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getSingleAlerts", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke getSingleAlerts via adapter", e);
+            throw new RuntimeException("Failed to invoke getSingleAlerts via adapter: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public Page<GroupAlert> getGroupAlerts(String status, String search, String sort, String order, int pageIndex, int pageSize) {
+        try {
+            Object alertService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getGroupAlerts: {}", subjectSum);
+
+            try {
+                alertService = SpringContextHolder.getBean("alertServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'alertServiceImpl'");
+            }
+
+            assert alertService != null;
+            log.debug("AlertService bean found: {}", alertService.getClass().getSimpleName());
+            
+            Method method = alertService.getClass().getMethod(
+                    "getGroupAlerts",
+                    String.class, String.class, String.class, String.class, int.class, int.class);
+
+            @SuppressWarnings("unchecked")
+            Page<GroupAlert> result = (Page<GroupAlert>) method.invoke(
+                    alertService, status, search, sort, order, pageIndex, pageSize);
+            
+            log.debug("Successfully retrieved {} group alerts", result.getContent().size());
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getGroupAlerts", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke getGroupAlerts via adapter", e);
+            throw new RuntimeException("Failed to invoke getGroupAlerts via adapter: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public AlertSummary getAlertsSummary() {
+        try {
+            Object alertService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getAlertsSummary: {}", subjectSum);
+
+            try {
+                alertService = SpringContextHolder.getBean("alertServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'alertServiceImpl'");
+            }
+
+            assert alertService != null;
+            log.debug("AlertService bean found: {}", alertService.getClass().getSimpleName());
+            
+            Method method = alertService.getClass().getMethod("getAlertsSummary");
+
+            AlertSummary result = (AlertSummary) method.invoke(alertService);
+            
+            log.debug("Successfully retrieved alerts summary");
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getAlertsSummary", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke getAlertsSummary via adapter", e);
+            throw new RuntimeException("Failed to invoke getAlertsSummary via adapter: " + e.getMessage(), e);
+        }
+    }
+}
@@ -0,0 +1,136 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hertzbeat.ai.adapters.impl;
+
+import com.usthe.sureness.subject.SubjectSum;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.hertzbeat.ai.adapters.MetricsServiceAdapter;
+import org.apache.hertzbeat.ai.config.McpContextHolder;
+import org.apache.hertzbeat.common.entity.dto.MetricsData;
+import org.apache.hertzbeat.common.entity.dto.MetricsHistoryData;
+import org.apache.hertzbeat.common.support.SpringContextHolder;
+import org.springframework.stereotype.Component;
+
+import java.lang.reflect.Method;
+
+/**
+ * Implementation of the MetricsServiceAdapter interface that provides access to metrics information
+ * through reflection by invoking the underlying metrics service implementation.
+ */
+@Slf4j
+@Component
+public class MetricsServiceAdapterImpl implements MetricsServiceAdapter {
+
+    @Override
+    public Boolean getWarehouseStorageServerStatus() {
+        try {
+            Object metricsDataService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getWarehouseStorageServerStatus: {}", subjectSum);
+
+            try {
+                metricsDataService = SpringContextHolder.getBean("metricsDataServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'metricsDataServiceImpl'");
+            }
+
+            assert metricsDataService != null;
+            log.debug("MetricsDataService bean found: {}", metricsDataService.getClass().getSimpleName());
+            
+            Method method = metricsDataService.getClass().getMethod("getWarehouseStorageServerStatus");
+
+            Boolean result = (Boolean) method.invoke(metricsDataService);
+            
+            log.debug("Successfully retrieved warehouse storage server status: {}", result);
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getWarehouseStorageServerStatus", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke getWarehouseStorageServerStatus via adapter", e);
+            throw new RuntimeException("Failed to invoke getWarehouseStorageServerStatus via adapter: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public MetricsData getMetricsData(Long monitorId, String metrics) {
+        try {
+            Object metricsDataService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getMetricsData: {}", subjectSum);
+
+            try {
+                metricsDataService = SpringContextHolder.getBean("metricsDataServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'metricsDataServiceImpl'");
+            }
+
+            assert metricsDataService != null;
+            log.debug("MetricsDataService bean found: {}", metricsDataService.getClass().getSimpleName());
+            
+            Method method = metricsDataService.getClass().getMethod(
+                    "getMetricsData",
+                    Long.class, String.class);
+
+            MetricsData result = (MetricsData) method.invoke(metricsDataService, monitorId, metrics);
+            
+            log.debug("Successfully retrieved metrics data for monitor {} and metrics {}", monitorId, metrics);
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getMetricsData", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke getMetricsData via adapter for monitor {} and metrics {}", monitorId, metrics, e);
+            throw new RuntimeException("Failed to invoke getMetricsData via adapter: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public MetricsHistoryData getMetricHistoryData(Long monitorId, String app, String metrics, String metric, String label, String history, Boolean interval) {
+        try {
+            Object metricsDataService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getMetricHistoryData: {}", subjectSum);
+
+            try {
+                metricsDataService = SpringContextHolder.getBean("metricsDataServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'metricsDataServiceImpl'");
+            }
+
+            assert metricsDataService != null;
+            log.debug("MetricsDataService bean found: {}", metricsDataService.getClass().getSimpleName());
+            
+            Method method = metricsDataService.getClass().getMethod(
+                    "getMetricHistoryData",
+                    Long.class, String.class, String.class, String.class, String.class, String.class, Boolean.class);
+
+            MetricsHistoryData result = (MetricsHistoryData) method.invoke(
+                    metricsDataService, monitorId, app, metrics, metric, label, history, interval);
+            
+            log.debug("Successfully retrieved historical metrics data for monitor {} and metrics {}", monitorId, metrics);
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getMetricHistoryData", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke getMetricHistoryData via adapter for monitor {} and metrics {}", monitorId, metrics, e);
+            throw new RuntimeException("Failed to invoke getMetricHistoryData via adapter: " + e.getMessage(), e);
+        }
+    }
+}
@@ -0,0 +1,214 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package org.apache.hertzbeat.ai.adapters.impl;
+
+import com.usthe.sureness.subject.SubjectSum;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.hertzbeat.ai.adapters.MonitorServiceAdapter;
+import org.apache.hertzbeat.ai.config.McpContextHolder;
+import org.springframework.data.domain.Page;
+import org.apache.hertzbeat.common.entity.manager.Monitor;
+import org.apache.hertzbeat.common.entity.manager.Param;
+import org.apache.hertzbeat.common.entity.manager.ParamDefine;
+import org.apache.hertzbeat.common.support.SpringContextHolder;
+import org.springframework.stereotype.Component;
+
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Implementation of the MonitorServiceAdapter interface that provides access to monitor information
+ * through reflection by invoking the underlying monitor service implementation.
+ */
+@Slf4j
+@Component
+public class MonitorServiceAdapterImpl implements MonitorServiceAdapter {
+
+    @Override
+    public Page<Monitor> getMonitors(
+            List<Long> ids,
+            String app,
+            String search,
+            Byte status,
+            String sort,
+            String order,
+            Integer pageIndex,
+            Integer pageSize,
+            String labels) {
+        try {
+            // Provide default values for all nullable parameters
+            if (sort == null || sort.trim().isEmpty()) {
+                sort = "gmtCreate";
+            }
+            if (order == null || order.trim().isEmpty()) {
+                order = "desc";
+            }
+            if (pageIndex == null) {
+                pageIndex = 0;
+            }
+            if (pageSize == null) {
+                pageSize = 8;
+            }
+
+            Object monitorService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject: {}", subjectSum);
+
+            try {
+                monitorService = SpringContextHolder.getBean("monitorServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'monitorServiceImpl', trying by class name");
+            }
+
+            assert monitorService != null;
+            log.debug("MonitorService bean found: {}", monitorService.getClass().getSimpleName());
+            Method method = monitorService.getClass().getMethod(
+                    "getMonitors",
+                    List.class, String.class, String.class, Byte.class,
+                    String.class, String.class, int.class, int.class, String.class);
+
+
+            @SuppressWarnings("unchecked")
+            Page<Monitor> result = (Page<Monitor>) method.invoke(
+                    monitorService,
+                    ids, app, search, status, sort, order, pageIndex, pageSize, labels);
+            log.debug("MonitorServiceAdapter.getMonitors result: {}", result.getContent());
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getMonitors", e);
+        } catch (Exception e) {
+            log.debug("Failed to invoke getMonitors via adapter", e);
+            throw new RuntimeException("Failed to invoke getMonitors via adapter", e);
+        }
+    }
+
+    @Override
+    public Long addMonitor(Monitor monitor, List<Param> params, String collector) {
+        try {
+            Object monitorService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for addMonitor: {}", subjectSum);
+
+            try {
+                monitorService = SpringContextHolder.getBean("monitorServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'monitorServiceImpl', trying by class name");
+            }
+
+            assert monitorService != null;
+            log.debug("MonitorService bean found for addMonitor: {}", monitorService.getClass().getSimpleName());
+
+            // Call addMonitor method: addMonitor(Monitor monitor, List<Param> params, String collector, GrafanaDashboard dashboard)
+            Method method = monitorService.getClass().getMethod(
+                    "addMonitor",
+                    Monitor.class, List.class, String.class,
+                    Class.forName("org.apache.hertzbeat.common.entity.grafana.GrafanaDashboard"));
+
+            // Call the method with null dashboard
+            method.invoke(monitorService, monitor, params, collector, null);
+
+            log.debug("Successfully added monitor: {} with ID: {}", monitor.getName(), monitor.getId());
+            return monitor.getId();
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: addMonitor", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke addMonitor via adapter", e);
+            throw new RuntimeException("Failed to invoke addMonitor via adapter: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public Map<String, String> getAvailableMonitorTypes(String language) {
+        try {
+            Object appService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getAvailableMonitorTypes: {}", subjectSum);
+
+            try {
+                appService = SpringContextHolder.getBean("appServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'appServiceImpl', trying by class name");
+            }
+
+            assert appService != null;
+            log.debug("AppService bean found for getAvailableMonitorTypes: {}", appService.getClass().getSimpleName());
+
+            // Provide default language if not specified
+            if (language == null || language.trim().isEmpty()) {
+                language = "en-US";
+            }
+
+            // Call getI18nApps method: getI18nApps(String lang)
+            Method method = appService.getClass().getMethod("getI18nApps", String.class);
+
+            @SuppressWarnings("unchecked")
+            Map<String, String> result = (Map<String, String>) method.invoke(appService, language);
+
+            log.debug("Successfully retrieved {} monitor types", result.size());
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getI18nApps", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke getI18nApps via adapter", e);
+            throw new RuntimeException("Failed to invoke getI18nApps via adapter: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public List<ParamDefine> getMonitorParamDefines(String app) {
+        try {
+            Object appService = null;
+            SubjectSum subjectSum = McpContextHolder.getSubject();
+            log.debug("Current security subject for getMonitorParamDefines: {}", subjectSum);
+
+            try {
+                appService = SpringContextHolder.getBean("appServiceImpl");
+            } catch (Exception e) {
+                log.debug("Could not find bean by name 'appServiceImpl', trying by class name");
+            }
+
+            assert appService != null;
+            log.debug("AppService bean found for getMonitorParamDefines: {}", appService.getClass().getSimpleName());
+
+            // Validate app parameter
+            if (app == null || app.trim().isEmpty()) {
+                throw new IllegalArgumentException("Monitor type/app parameter is required");
+            }
+
+            // Call getAppParamDefines method: getAppParamDefines(String app)
+            Method method = appService.getClass().getMethod("getAppParamDefines", String.class);
+
+            @SuppressWarnings("unchecked")
+            List<ParamDefine> result = (List<ParamDefine>) method.invoke(appService, app.toLowerCase().trim());
+
+            log.debug("Successfully retrieved {} parameter definitions for monitor type: {}", result.size(), app);
+            return result;
+
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Method not found: getAppParamDefines", e);
+        } catch (Exception e) {
+            log.error("Failed to invoke getAppParamDefines via adapter for app: {}", app, e);
+            throw new RuntimeException("Failed to invoke getAppParamDefines via adapter: " + e.getMessage(), e);
+        }
+    }
+}
@@ -0,0 +1,246 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hertzbeat.ai.config;
+
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.usthe.sureness.mgt.SurenessSecurityManager;
+import com.usthe.sureness.subject.SubjectSum;
+import io.modelcontextprotocol.spec.McpError;
+import io.modelcontextprotocol.spec.McpSchema;
+import io.modelcontextprotocol.spec.McpServerSession;
+import io.modelcontextprotocol.spec.McpServerTransport;
+import io.modelcontextprotocol.spec.McpServerTransportProvider;
+import io.modelcontextprotocol.util.Assert;
+import java.io.IOException;
+import java.time.Duration;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.servlet.function.RouterFunction;
+import org.springframework.web.servlet.function.RouterFunctions;
+import org.springframework.web.servlet.function.ServerRequest;
+import org.springframework.web.servlet.function.ServerResponse;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+/**
+ * Custom Server-Sent Events transport provider for Model Context Protocol.
+ */
+@Slf4j
+public class CustomSseServerTransport implements McpServerTransportProvider {
+    private final ObjectMapper objectMapper;
+    private final String messageEndpoint;
+    private final String sseEndpoint;
+    private final String baseUrl;
+    @Getter
+    private final RouterFunction<ServerResponse> routerFunction;
+    @Setter
+    private McpServerSession.Factory sessionFactory;
+    private final Map<String, Object> sessionRequest = new HashMap<>();
+    private final ConcurrentHashMap<String, McpServerSession> sessions;
+    private volatile boolean isClosing;
+
+    public CustomSseServerTransport(ObjectMapper objectMapper, String messageEndpoint) {
+        this(objectMapper, messageEndpoint, "/sse");
+    }
+
+
+    public CustomSseServerTransport(ObjectMapper objectMapper, String messageEndpoint, String sseEndpoint) {
+        this(objectMapper, "", messageEndpoint, sseEndpoint);
+    }
+
+    public CustomSseServerTransport(ObjectMapper objectMapper, String baseUrl, String messageEndpoint, String sseEndpoint) {
+        this.sessions = new ConcurrentHashMap();
+        this.isClosing = false;
+        Assert.notNull(objectMapper, "ObjectMapper must not be null");
+        Assert.notNull(baseUrl, "Message base URL must not be null");
+        Assert.notNull(messageEndpoint, "Message endpoint must not be null");
+        Assert.notNull(sseEndpoint, "SSE endpoint must not be null");
+        this.objectMapper = objectMapper;
+        this.baseUrl = baseUrl;
+        this.messageEndpoint = messageEndpoint;
+        this.sseEndpoint = sseEndpoint;
+        this.routerFunction = RouterFunctions.route().GET(this.sseEndpoint, this::handleSseConnection).POST(this.messageEndpoint, this::handleMessage).build();
+    }
+
+    public Mono<Void> notifyClients(String method, Object params) {
+        if (this.sessions.isEmpty()) {
+            log.debug("No active sessions to broadcast message to");
+            return Mono.empty();
+        } else {
+            log.debug("Attempting to broadcast message to {} active sessions", this.sessions.size());
+            return Flux.fromIterable(this.sessions.values())
+                    .flatMap((session) -> session.sendNotification(method, params)
+                            .doOnError((e) -> log.error("Failed to send message to session {}: {}", session.getId(), e.getMessage()))
+                            .onErrorComplete())
+                    .then();
+        }
+    }
+
+    public Mono<Void> closeGracefully() {
+        return Flux.fromIterable(this.sessions.values()).doFirst(() -> {
+            this.isClosing = true;
+            log.debug("Initiating graceful shutdown with {} active sessions", this.sessions.size());
+        }).flatMap(McpServerSession::closeGracefully).then().doOnSuccess((v) -> log.debug("Graceful shutdown completed"));
+    }
+
+    private ServerResponse handleSseConnection(ServerRequest request) {
+        log.debug("Handling SSE connection for request: {}", request);
+        HttpServletRequest servletRequest = request.servletRequest();
+
+        try {
+
+            log.debug("Processing SSE connection for servlet request: {}", servletRequest);
+            log.debug("Authorization header: {}", servletRequest.getHeader("Authorization"));
+
+
+        } catch (Exception e) {
+            log.error("Authentication failed for SSE connection: {}", e.getMessage());
+            return ServerResponse.status(HttpStatus.UNAUTHORIZED).body("Unauthorized: " + e.getMessage());
+        }
+
+
+
+        if (this.isClosing) {
+            return ServerResponse.status(HttpStatus.SERVICE_UNAVAILABLE).body("Server is shutting down");
+        } else {
+            String sessionId = UUID.randomUUID().toString();
+            log.debug("Generated session ID for SSE connection: {}", sessionId);
+            log.debug("Creating new SSE connection for session: {}", sessionId);
+
+
+            return ServerResponse.sse((sseBuilder) -> {
+                sseBuilder.onComplete(() -> {
+                    log.debug("SSE connection completed for session: {}", sessionId);
+                    this.sessions.remove(sessionId);
+                });
+                sseBuilder.onTimeout(() -> {
+                    log.debug("SSE connection timed out for session: {}", sessionId);
+                    this.sessions.remove(sessionId);
+                });
+                CustomSseServerTransport.WebMvcMcpSessionTransport sessionTransport = new CustomSseServerTransport.WebMvcMcpSessionTransport(sessionId, sseBuilder);
+                McpServerSession session = this.sessionFactory.create(sessionTransport);
+                this.sessionRequest.put(sessionId, request.servletRequest());
+                this.sessions.put(sessionId, session);
+
+                try {
+                    sseBuilder.id(sessionId).event("endpoint").data(this.baseUrl + this.messageEndpoint + "?sessionId=" + sessionId);
+                } catch (Exception e) {
+                    log.error("Failed to send initial endpoint event: {}", e.getMessage());
+                    sseBuilder.error(e);
+                }
+
+            }, Duration.ZERO);
+
+        }
+    }
+
+    private ServerResponse handleMessage(ServerRequest request) {
+        if (this.isClosing) {
+            return ServerResponse.status(HttpStatus.SERVICE_UNAVAILABLE).body("Server is shutting down");
+        } else if (request.param("sessionId").isEmpty()) {
+            return ServerResponse.badRequest().body(new McpError("Session ID missing in message endpoint"));
+        } else {
+            String sessionId = (String) request.param("sessionId").get();
+            McpServerSession session = (McpServerSession) this.sessions.get(sessionId);
+            log.debug("Authorization header for message request: {}", request.servletRequest().getHeader("Authorization"));
+            SubjectSum subject = SurenessSecurityManager.getInstance().checkIn(sessionRequest.get(sessionId));
+            McpContextHolder.setSubject(subject);
+
+
+            if (session == null) {
+                return ServerResponse.status(HttpStatus.NOT_FOUND).body(new McpError("Session not found: " + sessionId));
+            } else {
+                try {
+                    String body = request.body(String.class);
+                    McpSchema.JSONRPCMessage message = McpSchema.deserializeJsonRpcMessage(this.objectMapper, body);
+                    session.handle(message).block();
+                    return ServerResponse.ok().build();
+                } catch (IOException | IllegalArgumentException e) {
+                    log.error("Failed to deserialize message: {}", ((Exception) e).getMessage());
+                    return ServerResponse.badRequest().body(new McpError("Invalid message format"));
+                } catch (Exception e) {
+                    log.error("Error handling message: {}", e.getMessage());
+                    return ServerResponse.status(HttpStatus.INTERNAL_SERVER_ERROR).body(new McpError(e.getMessage()));
+                }
+            }
+        }
+    }
+
+    private class WebMvcMcpSessionTransport implements McpServerTransport {
+        private final String sessionId;
+        private final ServerResponse.SseBuilder sseBuilder;
+
+        WebMvcMcpSessionTransport(String sessionId, ServerResponse.SseBuilder sseBuilder) {
+            this.sessionId = sessionId;
+            this.sseBuilder = sseBuilder;
+            log.debug("Session transport {} initialized with SSE builder", sessionId);
+        }
+
+        public Mono<Void> sendMessage(McpSchema.JSONRPCMessage message) {
+            return Mono.fromRunnable(() -> {
+                try {
+                    String jsonText = CustomSseServerTransport.this.objectMapper.writeValueAsString(message);
+                    this.sseBuilder.id(this.sessionId).event("message").data(jsonText);
+                    log.debug("Message sent to session {}", this.sessionId);
+                } catch (Exception e) {
+                    log.error("Failed to send message to session {}: {}", this.sessionId, e.getMessage());
+                    this.sseBuilder.error(e);
+                }
+
+            });
+        }
+
+        public <T> T unmarshalFrom(Object data, TypeReference<T> typeRef) {
+            return (T) CustomSseServerTransport.this.objectMapper.convertValue(data, typeRef);
+        }
+
+        public Mono<Void> closeGracefully() {
+            return Mono.fromRunnable(() -> {
+                log.debug("Closing session transport: {}", this.sessionId);
+
+                try {
+                    this.sseBuilder.complete();
+                    log.debug("Successfully completed SSE builder for session {}", this.sessionId);
+                } catch (Exception e) {
+                    log.warn("Failed to complete SSE builder for session {}: {}", this.sessionId, e.getMessage());
+                }
+
+            });
+        }
+
+        public void close() {
+            try {
+                this.sseBuilder.complete();
+                log.debug("Successfully completed SSE builder for session {}", this.sessionId);
+            } catch (Exception e) {
+                log.warn("Failed to complete SSE builder for session {}: {}", this.sessionId, e.getMessage());
+            }
+
+        }
+    }
+}
@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hertzbeat.ai.config;
+
+import lombok.extern.slf4j.Slf4j;
+import org.apache.hertzbeat.ai.pojo.dto.ModelProviderConfig;
+import org.apache.hertzbeat.base.dao.GeneralConfigDao;
+import org.apache.hertzbeat.common.entity.manager.GeneralConfig;
+import org.apache.hertzbeat.common.util.JsonUtil;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.ai.model.ApiKey;
+import org.springframework.stereotype.Component;
+
+/**
+ * Dynamic LLM Provider API Key implementation that retrieves the API key
+ */
+@Slf4j
+@Component
+public class DynamicOpenAiApiKey implements ApiKey {
+
+    private final GeneralConfigDao generalConfigDao;
+    
+    public DynamicOpenAiApiKey(GeneralConfigDao generalConfigDao) {
+        this.generalConfigDao = generalConfigDao;
+    }
+
+    @NotNull
+    @Override
+    public String getValue() {
+        GeneralConfig providerConfig = generalConfigDao.findByType("provider");
+        ModelProviderConfig modelProviderConfig = JsonUtil.fromJson(providerConfig.getContent(), ModelProviderConfig.class);
+
+        if (modelProviderConfig != null && modelProviderConfig.isEnable() && modelProviderConfig.isStatus()) {
+            log.debug("Retrieved {} API key from configuration service", modelProviderConfig.getCode());
+            return modelProviderConfig.getApiKey();
+        } else {
+            log.warn("No valid LLM Provider API key found in configuration");
+            return "";
+        }
+    }
+}
@@ -20,7 +20,7 @@ package org.apache.hertzbeat.ai.config;

 import lombok.extern.slf4j.Slf4j;
 import org.apache.hertzbeat.common.support.event.AiProviderConfigChangeEvent;
-import org.apache.hertzbeat.common.entity.dto.ModelProviderConfig;
+import org.apache.hertzbeat.ai.pojo.dto.ModelProviderConfig;
 import org.apache.hertzbeat.base.dao.GeneralConfigDao;
 import org.apache.hertzbeat.common.entity.manager.GeneralConfig;
 import org.apache.hertzbeat.common.util.JsonUtil;
@@ -72,7 +72,12 @@ public class LlmConfig {
        }
        ModelProviderConfig modelProviderConfig = JsonUtil.fromJson(providerConfig.getContent(), ModelProviderConfig.class);

-        if (modelProviderConfig == null || modelProviderConfig.getApiKey() == null) {
+        if (!modelProviderConfig.isEnable() || !modelProviderConfig.isStatus()) {
+            log.warn("LLM Provider is not enabled or status is not valid, ChatClient bean will not be created");
+            return null;
+        }
+
+        if (modelProviderConfig.getApiKey() == null) {
            log.warn("LLM Provider configuration is incomplete, ChatClient bean will not be created");
            return null;
        }
@@ -33,8 +33,8 @@ public final class McpContextHolder {
     * Attaches the user's context to the current thread.
     */
    public static void setSubject(SubjectSum subject) {
-
        subjectHolder.set(subject);
+
    }

    /**
@@ -0,0 +1,182 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package org.apache.hertzbeat.ai.config;
+
+import org.springframework.stereotype.Component;
+
+/**
+ * Provider for system prompts used in the AI agent
+ */
+
+@Component
+public class PromptProvider {
+    /**
+     * Static version of the HertzBeat monitoring prompt
+     */
+    public static final String HERTZBEAT_SYSTEM_PROMPT = """
+            You are an AI Assistant specialized in monitoring infrastructure and applications with HertzBeat.
+            HertzBeat is an open-source, real-time monitoring system that supports infrastructure, applications,
+            services, APIs, databases, middleware, and custom monitoring through 50+ types of monitors.
+            Your role is to help users manage monitors, analyze metrics data, configure alerts, and troubleshoot monitoring issues.
+            *******
+            VERY IMPORTANT: Always use the tools provided to interact with HertzBeat's monitoring system.
+            If the user doesn't provide required parameters, ask them iteratively to provide the necessary parameters.
+            ********
+            
+            ## Available HertzBeat Tools:
+            
+            ### Monitor Management Tools:
+            - **query_monitors**: Query monitor information with flexible filtering (ID, name, type, host, status, labels)
+            - **add_monitor**: Add a new monitor with dynamic app-specific parameter support
+            - **list_monitor_types**: List all available monitor types (website, mysql, redis, linux, etc.)
+            - **get_monitor_additional_params**: Get parameter definitions required for specific monitor types
+            
+            ### Alert Rule Management Tools:
+            - **create_alert_rule**: Create alert rules with threshold configuration and automatic monitor binding
+            - **list_alert_rules**: List existing alert rules with filtering by type, status, etc.
+            - **toggle_alert_rule**: Enable or disable alert rules
+            - **get_alert_rule_details**: Get detailed information about specific alert rules
+            - **get_apps_metrics_hierarchy**: Get exact app and metric names for alert rule creation (CRITICAL for alerts)
+            - **bind_monitors_to_alert_rule**: Bind monitors to alert rules for targeted alerting
+
+            
+            ### Alert & Alarm Analysis Tools:
+            - **query_alerts**: Query fired alerts with comprehensive filtering and pagination
+            - **get_alerts_summary**: Get alert statistics and status distribution
+            
+            ### Metrics Data Analysis Tools:
+            - **query_realtime_metrics**: Get current real-time metrics data for monitors
+            - **get_historical_metrics**: Get historical time-series metrics with flexible time ranges
+            - **get_warehouse_status**: Check metrics storage system status
+            
+            ## Natural Language Examples:
+            
+            ### Monitor Management:
+            - "Add a MySQL monitor for database server at 192.168.1.10 with user admin"
+            - "Monitor website https://example.com with SSL checking every 60 seconds"
+            - "Show me all Linux servers that are currently offline"
+            - "List all Redis monitors with their connection status"
+            
+            ### Alert Configuration:
+            -  ALERT RULE means when to alert a user
+            - "Create an alert for Kafka JVM when VmName equals 'vm-w2'"
+            - "Alert when OpenAI credit grants exceed 1000"
+            - "Set up HBase Master alert when heap memory usage is over 80%"
+            
+            ### Metrics Analysis:
+            - "Show me current CPU usage for server 192.168.1.5"
+            - "Get memory usage trend for the last 24 hours"
+            - "Which servers have high disk usage right now?"
+            - "Show me network traffic patterns for the past week"
+            
+            ### Alert Investigation:
+            - "What alerts are currently firing?"
+            - "Show me the most frequent alerts in the last 6 hours"
+            - "Find all alerts for monitor ID 1234 in the past day"
+            - "Which monitors are currently abnormal?"
+            
+            
+            ## Workflow Guidelines:
+            
+            1. **Adding Monitors**:
+               - ALWAYS use get_monitor_additional_params first to check required parameters
+               - Use list_monitor_types to show available types
+               - Collect all required parameters from the list_monitor_types tool and ask user to give them all, before calling add_monitor
+               - Example: "To monitor MySQL, I need host, port, username, password, and database name"
+            
+            2. **Creating Alert Rules or Alerts**:
+            THESE ARE ALERT RULES WITH THRESHOLD VALUES. USERS CAN SPECIFY THE THRESHOLD VALUES FOR EXAMPLE,
+            IF THE USER SAYS "ALERT ME WHEN MY COST EXCEEDS 700, THE EXPRESSION SHOULD BE 'cost > 700' NOT 'cost < 700'.
+            APPLY THE SAME LOGIC FOR LESS THAN OPERATOR.
+            It is important to first understand the hierarchy of apps, metrics, and field conditions
+            Each app has its own metrics and each metric has its own field conditions.
+            The operators will be applied to the field conditions, and the final expression will be constructed
+            based on the user's input of app name and the metric they choose.
+            Read the create_alert_rule tool description for even more details
+            *******
+            CRITICAL WORKFLOW Do all of this iteratively with user interaction at each step:
+                1. ALWAYS use list_monitor_types tool FIRST to get exact app name according to what user specifies
+                2. use get_apps_metrics_hierarchy by passing that name, to get the hierarchy of corresponding metrics and field conditions
+                3. Do not spit out the entire hierarchy, instead: first spit out the metrics available for the app
+                4. Ask the user to choose a metric from the available metrics
+                5. Based on the metric chosen, present the available field conditions
+                6. You will construct the proper expression with field conditions
+                VERY VERY IMPORTANT:
+                 - ALWAYS USE the value field from the get_apps_metrics_hierarchy's json response when creating alert expressions on the field parameters
+            *********
+          
+               - Field Condition Expression format: [field_conditions]
+               - Give all the available fieldConditions to the user, so they can choose the one they want to use
+               - Field conditions can be simple (equals, greater than) or complex (logical expressions)
+               - Use parentheses for complex conditions to ensure correct evaluation order
+               - Do not create alert rules on your own, always ask the user to provide the app, metrics and fieldConditions parameters specifically
+           
+               EXAMPLES FOR FIELD CONDITION EXPRESSION ( Do not copy these examples, they are just for reference ):
+               - Kafka JVM: app="kafka", metrics="jvm_basic", fieldConditions="equals(VmName, \"my-vm\")"
+                 →  equals(VmName, "my-vm")
+               - Complex OpenAI: app="openai", metrics="credit_grants",
+                 fieldConditions="total_used > 123 and total_granted > 333 and (total_granted > 3444 and total_paid_available < 5556)"
+                 → total_used > 123 and total_granted > 333 and (total_granted > 3444 and total_paid_available < 5556)
+            
+               - Priority levels: 0=critical, 1=warning, 2=info
+            
+            3. **Analyzing Performance**:
+               - Use get_realtime_metrics for current status
+               - Use get_historical_metrics for trends
+               - Use get_high_usage_monitors to find problems
+               - Provide actionable recommendations based on data
+            
+            4. **Troubleshooting Alerts**:
+               - Use query_alerts to find current issues
+               - Use get_monitor_alerts for specific monitor problems
+               - Use get_frequent_alerts to identify recurring issues
+               - Suggest root cause analysis steps
+            
+            ## Parameter Guidelines:
+            - **Monitor Status**: 1=online, 2=offline, 3=unreachable, 0=paused, 9=all
+            - **Time Ranges**: 1h, 6h, 24h, 7d, 30d
+            - **Alert Priorities**: critical, warning, info
+            - **Sort Options**: name, gmtCreate, gmtUpdate, status, startAt, triggerTimes
+            - **Metric Types**: cpu, memory, disk, network, custom
+            - **Collection Intervals**: 30s-3600s (recommend 60s-600s for most cases)
+
+            
+            ## Best Practices:
+            - Never create alert rules without exact user input on app, metrics, and field conditions
+            - Always validate monitor types and parameters before adding monitors
+            - ALWAYS use get_apps_metrics_hierarchy before creating alert rules to understand available fields
+            - Construct field conditions based on metric's children
+            - Use exact app and metric names from hierarchy (case-sensitive)
+            - Set appropriate alert thresholds based on baseline performance
+            - Use time-series data to identify trends and predict issues
+            - Correlate alerts with metrics data for root cause analysis
+            - Recommend monitoring intervals based on service criticality
+            - Provide clear explanations of monitoring data and actionable insights
+            
+            ## Avoid these common errors:
+            - Using Label name instead of the value from the heirarchy JSON while creating alert rules.
+            - Inside the field parameters expression using '&&' instead of 'and', using '||' instead of 'or' for logical operators
+            - This process is to trigger alarms, when certain rule or set of rules exceed a threshold value.
+            So when a user says that the threshold should be less than 1000. the operator used should be '>' not '<',
+            because we want the alarm to be triggered when the threshold value is exceeded. apply the same logic in vice versa for less than operator
+            
+            Keep responses focused on monitoring topics and HertzBeat's comprehensive capabilities.
+            When users request monitoring setup, guide them through the complete process from monitor creation to alert configuration.
+            """;
+}
@@ -25,9 +25,9 @@ import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.hertzbeat.ai.config.McpContextHolder;
 import org.apache.hertzbeat.ai.pojo.dto.ChatRequestContext;
-import org.apache.hertzbeat.ai.pojo.dto.ChatResponseChunk;
+import org.apache.hertzbeat.ai.pojo.dto.ChatResponseDto;
+import org.apache.hertzbeat.ai.pojo.dto.ConversationDto;
 import org.apache.hertzbeat.ai.service.ConversationService;
-import org.apache.hertzbeat.common.entity.ai.ChatConversation;
 import org.apache.hertzbeat.common.entity.dto.Message;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.ResponseEntity;
@@ -63,6 +63,23 @@ public class ChatController {
        this.conversationService = conversationService;
    }

+    /**
+     * Create a new conversation
+     *
+     * @return Created conversation details
+     */
+    @PostMapping(path = "/conversations")
+    @Operation(summary = "Create a new conversation", description = "Create a new conversation")
+    public ResponseEntity<Message<ConversationDto>> createConversation() {
+        try {
+            ConversationDto conversation = conversationService.createConversation();
+            return ResponseEntity.ok(Message.success(conversation));
+        } catch (Exception e) {
+            log.error("Error creating conversation: ", e);
+            return ResponseEntity.ok(Message.fail((byte) -1, "Failed to create conversation"));
+        }
+    }
+
    /**
     * Send a message and get a streaming response with conversation tracking
     *
@@ -71,13 +88,14 @@ public class ChatController {
     */
    @PostMapping(value = "/stream", produces = TEXT_EVENT_STREAM_VALUE)
    @Operation(summary = "Send a chat message with streaming response", description = "Send a message to AI and get a streaming response with conversation tracking")
-    public Flux<ServerSentEvent<ChatResponseChunk>> streamChat(@Valid @RequestBody ChatRequestContext context) {
+    public Flux<ServerSentEvent<ChatResponseDto>> streamChat(@Valid @RequestBody ChatRequestContext context) {
        try {
            // Validate message is not empty
            SubjectSum subject = SurenessContextHolder.getBindSubject();
+            log.info(subject.toString());
            McpContextHolder.setSubject(subject);
            if (context.getMessage() == null || context.getMessage().trim().isEmpty()) {
-                ChatResponseChunk errorResponse = ChatResponseChunk.builder()
+                ChatResponseDto errorResponse = ChatResponseDto.builder()
                        .conversationId(context.getConversationId())
                        .response("Error: Message cannot be empty")
                        .build();
@@ -91,7 +109,7 @@ public class ChatController {

        } catch (Exception e) {
            log.error("Error in stream chat endpoint: ", e);
-            ChatResponseChunk errorResponse = ChatResponseChunk.builder()
+            ChatResponseDto errorResponse = ChatResponseDto.builder()
                    .conversationId(context.getConversationId())
                    .response("An error occurred: " + e.getMessage())
                    .build();
@@ -101,18 +119,6 @@ public class ChatController {
        }
    }

-    /**
-     * Create a new conversation
-     *
-     * @return Created conversation details
-     */
-    @PostMapping(path = "/conversations")
-    @Operation(summary = "Create a new conversation", description = "Create a new conversation")
-    public ResponseEntity<Message<ChatConversation>> createConversation() {
-        ChatConversation conversation = conversationService.createConversation();
-        return ResponseEntity.ok(Message.success(conversation));
-    }
-
    /**
     * Get all conversations
     *
@@ -120,9 +126,14 @@ public class ChatController {
     */
    @GetMapping(path = "/conversations")
    @Operation(summary = "List all conversations", description = "Get a list of all conversations")
-    public ResponseEntity<Message<List<ChatConversation>>> listConversations() {
-        List<ChatConversation> conversations = conversationService.getAllConversations();
-        return ResponseEntity.ok(Message.success(conversations));
+    public ResponseEntity<Message<List<ConversationDto>>> listConversations() {
+        try {
+            List<ConversationDto> conversations = conversationService.getAllConversations();
+            return ResponseEntity.ok(Message.success(conversations));
+        } catch (Exception e) {
+            log.error("Error listing conversations: ", e);
+            return ResponseEntity.ok(Message.fail((byte) -1, "Failed to retrieve conversations"));
+        }
    }

    /**
@@ -133,10 +144,26 @@ public class ChatController {
     */
    @GetMapping(path = "/conversations/{conversationId}")
    @Operation(summary = "Get conversation history", description = "Get detailed information and message history for a specific conversation")
-    public ResponseEntity<Message<ChatConversation>> getConversation(
-            @Parameter(description = "Conversation ID", example = "12345678") @PathVariable(value = "conversationId") Long conversationId) {
-        ChatConversation conversation = conversationService.getConversation(conversationId);
-        return ResponseEntity.ok(Message.success(conversation));
+    public ResponseEntity<Message<ConversationDto>> getConversation(
+            @Parameter(description = "Conversation ID", example = "conv-12345678") @PathVariable("conversationId") String conversationId) {
+        try {
+            // Validate conversation ID
+            if (conversationId == null || conversationId.trim().isEmpty()) {
+                return ResponseEntity.ok(Message.fail((byte) -1, "Conversation ID is required"));
+            }
+
+            ConversationDto conversation = conversationService.getConversation(conversationId);
+
+            if (conversation == null) {
+                return ResponseEntity.ok(Message.fail((byte) -1, "Conversation not found: " + conversationId));
+            }
+
+            return ResponseEntity.ok(Message.success(conversation));
+
+        } catch (Exception e) {
+            log.error("Error getting conversation: ", e);
+            return ResponseEntity.ok(Message.fail((byte) -1, "Failed to retrieve conversation"));
+        }
    }

    /**
@@ -148,8 +175,23 @@ public class ChatController {
    @DeleteMapping(path = "/conversations/{conversationId}")
    @Operation(summary = "Delete conversation", description = "Delete a specific conversation and all its messages")
    public ResponseEntity<Message<Void>> deleteConversation(
-            @Parameter(description = "Conversation ID", example = "2345678") @PathVariable("conversationId") Long conversationId) {
-        conversationService.deleteConversation(conversationId);
-        return ResponseEntity.ok(Message.success());
+            @Parameter(description = "Conversation ID", example = "conv-12345678") @PathVariable("conversationId") String conversationId) {
+        try {
+            // Validate conversation ID
+            if (conversationId == null || conversationId.trim().isEmpty()) {
+                return ResponseEntity.ok(Message.fail((byte) -1, "Conversation ID is required"));
+            }
+
+            boolean deleted = conversationService.deleteConversation(conversationId);
+            if (!deleted) {
+                return ResponseEntity.ok(Message.fail((byte) -1, "Conversation not found: " + conversationId));
+            }
+
+            return ResponseEntity.ok(Message.success("Conversation deleted successfully"));
+        } catch (Exception e) {
+            log.error("Error deleting conversation: ", e);
+            return ResponseEntity.ok(Message.fail((byte) -1, "Failed to delete conversation"));
+        }
+
    }
 }
@@ -15,74 +15,66 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.entity.ai;
+package org.apache.hertzbeat.ai.entity;

 import static io.swagger.v3.oas.annotations.media.Schema.AccessMode.READ_ONLY;
+import static io.swagger.v3.oas.annotations.media.Schema.AccessMode.READ_WRITE;
+
 import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.EntityListeners;
-import jakarta.persistence.GeneratedValue;
-import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
-import jakarta.persistence.Index;
-import jakarta.persistence.Lob;
-
 import jakarta.persistence.Table;
 import jakarta.validation.constraints.NotBlank;
-import java.time.LocalDateTime;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
 import org.springframework.data.annotation.CreatedBy;
 import org.springframework.data.annotation.CreatedDate;
 import org.springframework.data.annotation.LastModifiedBy;
 import org.springframework.data.annotation.LastModifiedDate;
 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;

 /**
- * Entity for storing individual chat messages in conversations
+ * OpenAI Agent Config Entity
 */
+@Entity
+@Table(name = "hzb_ai_agent_config")
@Data
@Builder
-@Entity
-@EntityListeners(AuditingEntityListener.class)
-@Table(name = "hzb_ai_message", indexes = {
-    @Index(name = "idx_message_conversation_id", columnList = "conversation_id")
-})
@AllArgsConstructor
@NoArgsConstructor
-public class ChatMessage {
+@Schema(description = "OpenAI Agent config entity")
+@EntityListeners(AuditingEntityListener.class)
+public class OpenAiConfig {

    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-    
-    @Schema(title = "conversation id")
-    private Long conversationId;
+    @Schema(title = "Config type: openai, primary key", description = "Config type: openai, primary key",
+            accessMode = READ_WRITE)
+    @NotBlank(message = "type can not null")
+    private String type;

-    @Schema(title = "message content")
-    @Lob
-    @NotBlank
+    @Schema(title = "Config content", description = "Config content，format json", accessMode = READ_WRITE)
+    @Column(length = 8192)
    private String content;

-    @Schema(title = "message role: user, system")
-    private String role;
-
    @Schema(title = "The creator of this record", example = "tom", accessMode = READ_ONLY)
    @CreatedBy
    private String creator;

-    @Schema(title = "The modifier of this record", example = "tom", accessMode = READ_ONLY)
+    @Schema(title = "This record was last modified by", example = "tom", accessMode = READ_ONLY)
    @LastModifiedBy
    private String modifier;

-    @Schema(title = "Record create time", example = "1612198922000", accessMode = READ_ONLY)
+    @Schema(title = "This record creation time (millisecond timestamp)", accessMode = READ_ONLY)
    @CreatedDate
    private LocalDateTime gmtCreate;

-    @Schema(title = "Record modify time", example = "1612198444000", accessMode = READ_ONLY)
+    @Schema(title = "Record the latest modification time (timestamp in milliseconds)", accessMode = READ_ONLY)
    @LastModifiedDate
    private LocalDateTime gmtUpdate;
-    
 }
@@ -24,7 +24,6 @@ import lombok.Data;
 import lombok.NoArgsConstructor;

 import java.util.List;
-import org.apache.hertzbeat.common.entity.ai.ChatMessage;

 /**
 * Chat request context for AI chat endpoint.
@@ -41,10 +40,10 @@ public class ChatRequestContext {
    /**
     * Optional conversation ID for context
     */
-    private Long conversationId;
+    private String conversationId;

    /**
     * Conversation history messages for context
     */
-    private List<ChatMessage> conversationHistory;
+    private List<MessageDto> conversationHistory;
 }
@@ -31,18 +31,17 @@ import lombok.NoArgsConstructor;
@NoArgsConstructor
@AllArgsConstructor
@Schema(description = "Chat response")
-public class ChatResponseChunk {
+public class ChatResponseDto {

-    @Schema(description = "Conversation ID", example = "123")
-    private Long conversationId;
+    @Schema(description = "Conversation ID", example = "conv-123")
+    private String conversationId;

    @Schema(description = "AI response message", example = "Here are your monitors...")
    private String response;

-    @Schema(description = "User message ID", example = "123")
-    private Long userMessageId;
-    
-    @Schema(description = "Assistant message ID", example = "123")
-    private Long assistantMessageId;
+    @Schema(description = "User message ID", example = "msg-user-123")
+    private String userMessageId;

+    @Schema(description = "Assistant message ID", example = "msg-assistant-123")
+    private String assistantMessageId;
 }
@@ -15,36 +15,39 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.constants;
+package org.apache.hertzbeat.ai.pojo.dto;

+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.AllArgsConstructor;
-import lombok.Getter;
-import lombok.ToString;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+import java.util.List;

 /**
- * Theme Enum
+ * Conversation DTO for AI chat conversations.
 */
-@Getter
+@Data
+@Builder
+@NoArgsConstructor
@AllArgsConstructor
-@ToString
-public enum ThemeEnum {
+@Schema(description = "Conversation information")
+public class ConversationDto {

-    COMPACT("compact"), DEFAULT("default"), LIGHT("light"), DARK("dark");
+    @Schema(description = "Conversation ID", example = "conv-123")
+    private String conversationId;

-    private final String value;
+    @Schema(description = "Creation time")
+    private LocalDateTime createdAt;

-    /**
-     * Convert theme to standard theme
-     *
-     * @param theme the input theme
-     * @return the converted theme
-     */
-    public static String convert(String theme) {
-        if ((theme == null || theme.isEmpty())
-            || ThemeEnum.COMPACT.getValue().equals(theme)
-            || ThemeEnum.DEFAULT.getValue().equals(theme)) {
-            return ThemeEnum.LIGHT.getValue();
-        }
-        return theme;
-    }
+    @Schema(description = "Last updated time")
+    private LocalDateTime updatedAt;
+
+    @Schema(description = "Messages in this conversation")
+    private List<MessageDto> messages;
+
+    @Schema(description = "Message count")
+    private Integer messageCount;
 }
@@ -0,0 +1,87 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hertzbeat.ai.pojo.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+import static io.swagger.v3.oas.annotations.media.Schema.AccessMode.READ_WRITE;
+
+/**
+ * Hierarchical structure
+ * eg: Monitoring Type metrics Information Hierarchy Relationship
+ */
+@AllArgsConstructor
+@NoArgsConstructor
+@Data
+@Schema(description = "Monitor Hierarchy")
+public class Hierarchy {
+
+    /**
+     * Category value
+     */
+    @Schema(description = "Category Value", example = "os", accessMode = READ_WRITE)
+    String category;
+
+    /**
+     * Attribute value
+     */
+    @Schema(description = "Attribute value", example = "linux", accessMode = READ_WRITE)
+    String value;
+
+    /**
+     * Attribute internationalization tag
+     */
+    @Schema(description = "Attribute internationalization tag", example = "Linux system", accessMode = READ_WRITE)
+    String label;
+
+    /**
+     * Is it a leaf node
+     */
+    @Schema(description = "Is it a leaf node", example = "true", accessMode = READ_WRITE)
+    Boolean isLeaf = false;
+
+    /**
+     * Is hide this app type in main menus layout
+     */
+    @Schema(description = "Is hide this app in main menus layout, only for app type, default true.", example = "true")
+    Boolean hide = true;
+    
+    /**
+     * For leaf metric
+     * metric type 0-number: number 1-string: string
+     */
+    @Schema(description = "metric type 0-number: number 1-string: string")
+    private Byte type;
+    
+    /**
+     * metric unit
+     */
+    @Schema(description = "metric unit")
+    private String unit;
+
+    /**
+     * Next level of association
+     */
+    @Schema(description = "Next Hierarchy", accessMode = READ_WRITE)
+    private List<Hierarchy> children;
+}
@@ -15,31 +15,38 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.ai.dao;
+package org.apache.hertzbeat.ai.pojo.dto;

-import org.apache.hertzbeat.common.entity.ai.ChatMessage;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;

-import java.util.List;
+import java.time.LocalDateTime;

 /**
- * Repository interface for Message entities
+ * Message DTO for chat messages.
 */
-@Repository
-public interface ChatMessageDao extends JpaRepository<ChatMessage, Long> {
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Schema(description = "Chat message")
+public class MessageDto {

-    /**
-     * Find all messages by conversation id, ordered by create time
-     * @param conversationId conversation id
-     * @return list of messages
-     */
-    List<ChatMessage> findByConversationIdOrderByGmtCreateAsc(Long conversationId);
+    @Schema(description = "Message ID", example = "msg-123")
+    private String messageId;

-    /**
-     * Find all messages by conversation ids, ordered by create time
-     * @param conversationIds list of conversation ids
-     * @return list of messages
-     */
-    List<ChatMessage> findByConversationIdInOrderByGmtCreateAsc(List<Long> conversationIds);
+    @Schema(description = "Conversation ID", example = "conv-123")
+    private String conversationId;
+
+    @Schema(description = "Message content", example = "List all monitors")
+    private String content;
+
+    @Schema(description = "Message role", example = "user", allowableValues = {"user", "assistant"})
+    private String role;
+
+    @Schema(description = "Message timestamp")
+    private LocalDateTime timestamp;
 }
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.entity.dto;
+package org.apache.hertzbeat.ai.pojo.dto;

 import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotBlank;
@@ -32,6 +32,15 @@ import lombok.NoArgsConstructor;
@Schema(description = "LLM Model Provider configuration")
 public class ModelProviderConfig {
    
+    @Schema(title = "Enable Provider", description = "Whether Provider is enabled", example = "true")
+    private boolean enable = false;
+    
+    @Schema(title = "Check the provider available status")
+    private boolean status = false;
+    
+    @Schema(title = "The error message when provider status check failed")
+    private String error;
+    
    @Schema(title = "Model type, text-generate, vision")
    private String type;
    
@@ -0,0 +1,60 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hertzbeat.ai.service;
+
+/**
+ * Ai Configuration Service
+ */
+public interface AiConfigService {
+
+    /**
+     * Validate OpenAI API key by calling the OpenAI API
+     * @param apiKey the API key to validate
+     * @return validation result with success status and message
+     */
+    ValidationResult validateApiKey(String apiKey);
+
+    /**
+     * Validation result class
+     */
+    class ValidationResult {
+        private final boolean valid;
+        private final String message;
+
+        private ValidationResult(boolean valid, String message) {
+            this.valid = valid;
+            this.message = message;
+        }
+
+        public static ValidationResult success(String message) {
+            return new ValidationResult(true, message);
+        }
+
+        public static ValidationResult failure(String message) {
+            return new ValidationResult(false, message);
+        }
+
+        public boolean isValid() {
+            return valid;
+        }
+
+        public String getMessage() {
+            return message;
+        }
+    }
+}
@@ -18,8 +18,8 @@

 package org.apache.hertzbeat.ai.service;

-import org.apache.hertzbeat.ai.pojo.dto.ChatResponseChunk;
-import org.apache.hertzbeat.common.entity.ai.ChatConversation;
+import org.apache.hertzbeat.ai.pojo.dto.ChatResponseDto;
+import org.apache.hertzbeat.ai.pojo.dto.ConversationDto;
 import org.springframework.http.codec.ServerSentEvent;
 import reactor.core.publisher.Flux;

@@ -30,6 +30,13 @@ import java.util.List;
 */
 public interface ConversationService {

+    /**
+     * Create a new conversation
+     *
+     * @return Created conversation data
+     */
+    ConversationDto createConversation();
+
    /**
     * Send a message and receive a streaming response
     *
@@ -37,14 +44,8 @@ public interface ConversationService {
     * @param conversationId Optional conversation ID for continuing a chat
     * @return Flux of ServerSentEvent for streaming the response
     */
-    Flux<ServerSentEvent<ChatResponseChunk>> streamChat(String message, Long conversationId);
+    Flux<ServerSentEvent<ChatResponseDto>> streamChat(String message, String conversationId);

-    /**
-     * Create a new conversation
-     *
-     * @return Created conversation data
-     */
-    ChatConversation createConversation();

    /**
     * Get conversation history for a specific conversation
@@ -52,19 +53,28 @@ public interface ConversationService {
     * @param conversationId Conversation ID
     * @return Conversation data including messages
     */
-    ChatConversation getConversation(Long conversationId);
+    ConversationDto getConversation(String conversationId);

    /**
     * Get all conversations for the current user
     *
     * @return List of conversations
     */
-    List<ChatConversation> getAllConversations();
+    List<ConversationDto> getAllConversations();

    /**
     * Delete a conversation
     *
     * @param conversationId Conversation ID to delete
+     * @return true if deleted, false if conversation not found
     */
-    void deleteConversation(Long conversationId);
+    boolean deleteConversation(String conversationId);
+
+    /**
+     * Check if a conversation exists
+     *
+     * @param conversationId Conversation ID to check
+     * @return true if conversation exists, false otherwise
+     */
+    boolean conversationExists(String conversationId);
 }
@@ -18,7 +18,12 @@

 package org.apache.hertzbeat.ai.service;

+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.hertzbeat.ai.config.CustomSseServerTransport;
+import org.springframework.ai.mcp.server.autoconfigure.McpServerProperties;
 import org.springframework.ai.tool.ToolCallbackProvider;
+import org.springframework.web.servlet.function.RouterFunction;
+import org.springframework.web.servlet.function.ServerResponse;

 /**
 * Service interface for MCP server operations.
@@ -30,4 +35,22 @@ public interface McpServerService {
     * @return ToolCallbackProvider with all HertzBeat monitoring tools
     */
    ToolCallbackProvider hertzbeatTools();
+
+    /**
+     * Provides a custom SSE server transport for the MCP server
+     * @param objectMapper the ObjectMapper instance for JSON serialization
+     * @param serverProperties the properties for the MCP server configuration
+     * @return a CustomSseServerTransport instance configured with the provided properties
+     */
+    CustomSseServerTransport webMvcSseServerTransportProvider(
+            ObjectMapper objectMapper,
+            McpServerProperties serverProperties
+    );
+
+    /**
+     * Provides the MCP server router function for web MVC
+     * @param transport Custom SSE server transport
+     * @return RouterFunction for handling MCP server requests
+     */
+    RouterFunction<ServerResponse> mvcMcpRouterFunction(CustomSseServerTransport transport);
 }
@@ -0,0 +1,100 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hertzbeat.ai.service.impl;
+
+import lombok.extern.slf4j.Slf4j;
+import org.apache.hertzbeat.ai.service.AiConfigService;
+import org.apache.hertzbeat.base.dao.GeneralConfigDao;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+import org.springframework.web.client.RestTemplate;
+
+/**
+ * Ai Configuration Service Implementation
+ */
+@Slf4j
+@Service
+public class AiConfigServiceImpl implements AiConfigService {
+    
+    private static final String OPENAI_MODELS_ENDPOINT = "https://api.openai.com/v1/models";
+    private final RestTemplate restTemplate;
+
+    private final GeneralConfigDao generalConfigDao;
+
+    public AiConfigServiceImpl(GeneralConfigDao generalConfigDao, RestTemplate restTemplate) {
+        this.restTemplate = restTemplate;
+        this.generalConfigDao = generalConfigDao;
+    }
+
+    @Override
+    public ValidationResult validateApiKey(String apiKey) {
+        if (!StringUtils.hasText(apiKey)) {
+            return ValidationResult.failure("API key cannot be empty");
+        }
+
+        if (!apiKey.startsWith("sk-")) {
+            return ValidationResult.failure("Invalid API key format. OpenAI API keys should start with 'sk-'");
+        }
+
+        try {
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("Authorization", "Bearer " + apiKey);
+            headers.set("Content-Type", "application/json");
+            
+            HttpEntity<String> entity = new HttpEntity<>(headers);
+            
+            log.debug("Validating OpenAI API key by calling models endpoint");
+            ResponseEntity<String> response = restTemplate.exchange(
+                OPENAI_MODELS_ENDPOINT,
+                HttpMethod.GET,
+                entity,
+                String.class
+            );
+
+            if (response.getStatusCode() == HttpStatus.OK) {
+                log.info("OpenAI API key validation successful");
+                return ValidationResult.success("API key is valid");
+            } else {
+                log.warn("OpenAI API key validation failed with status: {}", response.getStatusCode());
+                return ValidationResult.failure("API key validation failed: " + response.getStatusCode());
+            }
+
+        } catch (Exception e) {
+            log.error("Error validating OpenAI API key", e);
+            String errorMessage = e.getMessage();
+            
+            // Parse common error messages
+            if (errorMessage.contains("401")) {
+                return ValidationResult.failure("Invalid API key - authentication failed");
+            } else if (errorMessage.contains("403")) {
+                return ValidationResult.failure("API key does not have permission to access models");
+            } else if (errorMessage.contains("429")) {
+                return ValidationResult.failure("Rate limit exceeded - please try again later");
+            } else if (errorMessage.contains("timeout") || errorMessage.contains("connect")) {
+                return ValidationResult.failure("Network error - unable to connect to OpenAI API");
+            } else {
+                return ValidationResult.failure("API key validation failed: " + errorMessage);
+            }
+        }
+    }
+}
@@ -19,15 +19,13 @@
 package org.apache.hertzbeat.ai.service.impl;

 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.common.entity.ai.ChatMessage;
-import org.apache.hertzbeat.common.entity.dto.ModelProviderConfig;
+import org.apache.hertzbeat.ai.config.PromptProvider;
+import org.apache.hertzbeat.ai.pojo.dto.MessageDto;
+import org.apache.hertzbeat.ai.pojo.dto.ModelProviderConfig;
 import org.apache.hertzbeat.ai.service.ChatClientProviderService;
 import org.apache.hertzbeat.base.dao.GeneralConfigDao;
 import org.apache.hertzbeat.common.entity.manager.GeneralConfig;
 import org.apache.hertzbeat.common.util.JsonUtil;
-import org.springframework.ai.chat.prompt.SystemPromptTemplate;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.core.io.Resource;
 import org.springframework.stereotype.Service;
 import org.apache.hertzbeat.ai.pojo.dto.ChatRequestContext;
 import org.springframework.ai.chat.client.ChatClient;
@@ -36,6 +34,7 @@ import org.springframework.ai.chat.messages.Message;
 import org.springframework.ai.chat.messages.UserMessage;
 import org.springframework.ai.tool.ToolCallbackProvider;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.context.ApplicationContext;
 import reactor.core.publisher.Flux;

@@ -54,21 +53,27 @@ public class ChatClientProviderServiceImpl implements ChatClientProviderService
    private final ApplicationContext applicationContext;

    private final GeneralConfigDao generalConfigDao;
-    
+
+    @Qualifier("hertzbeatTools")
    @Autowired
    private ToolCallbackProvider toolCallbackProvider;
    
    private boolean isConfigured = false;

-    @Value("classpath:/prompt/system-message.st")
-    private Resource systemResource;
-
    @Autowired
    public ChatClientProviderServiceImpl(ApplicationContext applicationContext, GeneralConfigDao generalConfigDao) {
        this.applicationContext = applicationContext;
        this.generalConfigDao = generalConfigDao;
    }

+    public String complete(String message) {
+        ChatClient chatClient = applicationContext.getBean("openAiChatClient", ChatClient.class);
+        return chatClient.prompt()
+                .user(message)
+                .call()
+                .content();
+    }
+
    @Override
    public Flux<String> streamChat(ChatRequestContext context) {
        try {
@@ -79,7 +84,7 @@ public class ChatClientProviderServiceImpl implements ChatClientProviderService

            // Add conversation history if available
            if (context.getConversationHistory() != null && !context.getConversationHistory().isEmpty()) {
-                for (ChatMessage historyMessage : context.getConversationHistory()) {
+                for (MessageDto historyMessage : context.getConversationHistory()) {
                    if ("user".equals(historyMessage.getRole())) {
                        messages.add(new UserMessage(historyMessage.getContent()));
                    } else if ("assistant".equals(historyMessage.getRole())) {
@@ -94,7 +99,7 @@ public class ChatClientProviderServiceImpl implements ChatClientProviderService

            return chatClient.prompt()
                    .messages(messages)
-                    .system(SystemPromptTemplate.builder().resource(systemResource).build().getTemplate())
+                    .system(PromptProvider.HERTZBEAT_SYSTEM_PROMPT)
                    .toolCallbacks(toolCallbackProvider)
                    .stream()
                    .content()
@@ -112,7 +117,7 @@ public class ChatClientProviderServiceImpl implements ChatClientProviderService
        if (!isConfigured) {
            GeneralConfig providerConfig = generalConfigDao.findByType("provider");
            ModelProviderConfig modelProviderConfig = JsonUtil.fromJson(providerConfig.getContent(), ModelProviderConfig.class);
-            isConfigured = modelProviderConfig != null && modelProviderConfig.getApiKey() != null;   
+            isConfigured = modelProviderConfig != null && modelProviderConfig.isStatus();   
        }
        return isConfigured;
    }
@@ -18,26 +18,24 @@
 package org.apache.hertzbeat.ai.service.impl;

 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.ai.dao.ChatConversationDao;
-import org.apache.hertzbeat.ai.dao.ChatMessageDao;
 import org.apache.hertzbeat.ai.pojo.dto.ChatRequestContext;
-import org.apache.hertzbeat.ai.pojo.dto.ChatResponseChunk;
+import org.apache.hertzbeat.ai.pojo.dto.ChatResponseDto;
+import org.apache.hertzbeat.ai.pojo.dto.ConversationDto;
+import org.apache.hertzbeat.ai.pojo.dto.MessageDto;
 import org.apache.hertzbeat.ai.service.ChatClientProviderService;
 import org.apache.hertzbeat.ai.service.ConversationService;
-import org.apache.hertzbeat.common.entity.ai.ChatConversation;
-import org.apache.hertzbeat.common.entity.ai.ChatMessage;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.data.domain.Sort;
 import org.springframework.http.codec.ServerSentEvent;
 import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-import org.springframework.util.CollectionUtils;
 import reactor.core.publisher.Flux;

-import java.util.Collections;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;

 /**
@@ -47,21 +45,34 @@ import java.util.stream.Collectors;
@Service
 public class ConversationServiceImpl implements ConversationService {

-    @Autowired
-    private ChatConversationDao conversationDao;
-
-    @Autowired
-    private ChatMessageDao messageDao;
+    private final Map<String, Map<String, Object>> conversations = new ConcurrentHashMap<>();
+    private final Map<String, List<Map<String, Object>>> conversationMessages = new ConcurrentHashMap<>();

    @Autowired
    private ChatClientProviderService chatClientProviderService;
+    
+    @Override
+    public ConversationDto createConversation() {
+        String conversationId = createNewConversation();
+        return getConversation(conversationId);
+    }

    @Override
-    public Flux<ServerSentEvent<ChatResponseChunk>> streamChat(String message, Long conversationId) {
+    public Flux<ServerSentEvent<ChatResponseDto>> streamChat(String message, String conversationId) {
+        // Validate conversation exists
+        if (!conversationExists(conversationId)) {
+            ChatResponseDto errorResponse = ChatResponseDto.builder()
+                    .conversationId(conversationId)
+                    .response("Error: Conversation not found: " + conversationId)
+                    .build();
+            return Flux.just(ServerSentEvent.builder(errorResponse)
+                    .event("error")
+                    .build());
+        }

-        // Check if provider is properly configured
+        // Check if OpenAI is properly configured
        if (!chatClientProviderService.isConfigured()) {
-            ChatResponseChunk errorResponse = ChatResponseChunk.builder()
+            ChatResponseDto errorResponse = ChatResponseDto.builder()
                    .conversationId(conversationId)
                    .response("Provider is not configured. Please configure your AI Provider.")
                    .build();
@@ -71,63 +82,52 @@ public class ConversationServiceImpl implements ConversationService {
        }

        log.info("Starting streaming conversation: {}", conversationId);
-        ChatConversation conversation = conversationDao.findById(conversationId)
-                .orElseThrow(() -> new IllegalArgumentException("Conversation not found: " + conversationId));
-
-        // Manually load messages for conversation history
-        List<ChatMessage> messages = messageDao.findByConversationIdOrderByGmtCreateAsc(conversationId);
-        conversation.setMessages(messages);
-
-        if (conversation.getTitle().startsWith("conversation")) {
-            // Auto-generate title from first user message
-            String title = message.length() > 30 ? message.substring(0, 27) + "..." : message;
-            conversation.setTitle(title);
-            conversationDao.save(conversation);
-        }

        // Add user message to conversation
-        ChatMessage chatMessage = ChatMessage.builder()
-            .conversationId(conversationId)
-            .content(message)
-            .role("user")
-            .build();
-        chatMessage = messageDao.save(chatMessage);
+        String userMessageId = addMessageToConversation(conversationId, message, "user");
+
+        // Get conversation history for context
+        List<Map<String, Object>> messagesList = conversationMessages.get(conversationId);
+        List<MessageDto> conversationHistory = new ArrayList<>();
+
+        if (messagesList != null && messagesList.size() > 1) {
+            // Get all messages except the last one (which is the current user message we just added)
+            for (int i = 0; i < messagesList.size() - 1; i++) {
+                Map<String, Object> msgMap = messagesList.get(i);
+                conversationHistory.add(mapToMessageDto(msgMap));
+            }
+        }

        ChatRequestContext context = ChatRequestContext.builder()
                .message(message)
                .conversationId(conversationId)
-                .conversationHistory(CollectionUtils.isEmpty(conversation.getMessages()) ? null
-                        : conversation.getMessages().subList(0, conversation.getMessages().size() - 1))
+                .conversationHistory(conversationHistory)
                .build();

        // Stream response from AI service
        StringBuilder fullResponse = new StringBuilder();
-        ChatMessage finalChatMessage = chatMessage;
        return chatClientProviderService.streamChat(context)
                .map(chunk -> {
                    fullResponse.append(chunk);
-                    ChatResponseChunk responseChunk = ChatResponseChunk.builder()
+                    ChatResponseDto responseDto = ChatResponseDto.builder()
                            .conversationId(conversationId)
-                            .userMessageId(finalChatMessage.getId())
                            .response(chunk)
+                            .userMessageId(userMessageId)
                            .build();

-                    return ServerSentEvent.builder(responseChunk)
+                    return ServerSentEvent.builder(responseDto)
                            .event("message")
                            .build();
                })
                .concatWith(Flux.defer(() -> {
                    // Add the complete AI response to conversation
-                    ChatMessage assistantMessage = ChatMessage.builder()
-                        .conversationId(conversationId)
-                        .content(fullResponse.toString())
-                        .role("assistant")
-                        .build();
-                    assistantMessage = messageDao.save(assistantMessage);
-                    ChatResponseChunk finalResponse = ChatResponseChunk.builder()
+                    String assistantMessageId = addMessageToConversation(conversationId, fullResponse.toString(), "assistant");
+
+                    ChatResponseDto finalResponse = ChatResponseDto.builder()
                            .conversationId(conversationId)
                            .response("")
-                            .assistantMessageId(assistantMessage.getId())
+                            .userMessageId(userMessageId)
+                            .assistantMessageId(assistantMessageId)
                            .build();

                    return Flux.just(ServerSentEvent.builder(finalResponse)
@@ -137,10 +137,10 @@ public class ConversationServiceImpl implements ConversationService {
                .doOnComplete(() -> log.info("Streaming completed for conversation: {}", conversationId))
                .doOnError(error -> log.error("Error in streaming chat for conversation {}: {}", conversationId, error.getMessage(), error))
                .onErrorResume(error -> {
-                    ChatResponseChunk errorResponse = ChatResponseChunk.builder()
+                    ChatResponseDto errorResponse = ChatResponseDto.builder()
                            .conversationId(conversationId)
                            .response("An error occurred: " + error.getMessage())
-                            .userMessageId(finalChatMessage.getId())
+                            .userMessageId(userMessageId)
                            .build();
                    return Flux.just(ServerSentEvent.builder(errorResponse)
                            .event("error")
@@ -149,51 +149,124 @@ public class ConversationServiceImpl implements ConversationService {
    }

    @Override
-    public ChatConversation createConversation() {
-        ChatConversation conversation = new ChatConversation();
-        conversation.setTitle("conversation-" + UUID.randomUUID().toString().substring(0, 4));
-        return conversationDao.save(conversation);
-    }
-
-    @Override
-    public ChatConversation getConversation(Long conversationId) {
-        if (conversationId == null) {
+    public ConversationDto getConversation(String conversationId) {
+        if (conversationId == null || conversationId.isEmpty()) {
            return null;
        }
-        ChatConversation conversation = conversationDao.findById(conversationId).orElse(null);
+
+        Map<String, Object> conversation = conversations.get(conversationId);
+        if (conversation == null) {
+            return null;
+        }
+
+        List<Map<String, Object>> messagesList = conversationMessages.get(conversationId);
+        List<MessageDto> messages = messagesList != null
+                ? messagesList.stream().map(this::mapToMessageDto).collect(Collectors.toList()) :
+                new ArrayList<>();
+
+        return ConversationDto.builder()
+                .conversationId((String) conversation.get("conversationId"))
+                .createdAt((LocalDateTime) conversation.get("createdAt"))
+                .updatedAt((LocalDateTime) conversation.get("updatedAt"))
+                .messages(messages)
+                .build();
+    }
+
+    @Override
+    public List<ConversationDto> getAllConversations() {
+        List<ConversationDto> result = new ArrayList<>();
+
+        for (Map.Entry<String, Map<String, Object>> entry : conversations.entrySet()) {
+            Map<String, Object> conv = entry.getValue();
+            List<Map<String, Object>> messages = conversationMessages.get(entry.getKey());
+
+            ConversationDto dto = ConversationDto.builder()
+                    .conversationId((String) conv.get("conversationId"))
+                    .createdAt((LocalDateTime) conv.get("createdAt"))
+                    .updatedAt((LocalDateTime) conv.get("updatedAt"))
+                    .messages(new ArrayList<>()) // Don't include messages in list view for performance
+                    .build();
+            result.add(dto);
+        }
+
+        result.sort((a, b) -> b.getUpdatedAt().compareTo(a.getUpdatedAt()));
+
+        return result;
+    }
+
+    @Override
+    public boolean deleteConversation(String conversationId) {
+        if (conversationId == null || conversationId.isEmpty()) {
+            return false;
+        }
+
+        boolean existed = conversations.containsKey(conversationId);
+        if (existed) {
+            conversations.remove(conversationId);
+            conversationMessages.remove(conversationId);
+            log.info("Deleted conversation: {}", conversationId);
+        }
+        return existed;
+    }
+
+    @Override
+    public boolean conversationExists(String conversationId) {
+        return conversationId != null && !conversationId.isEmpty() && conversations.containsKey(conversationId);
+    }
+
+    private String createNewConversation() {
+        String conversationId = "conv-" + UUID.randomUUID().toString().substring(0, 8);
+        LocalDateTime now = LocalDateTime.now();
+
+        Map<String, Object> conversation = new HashMap<>();
+        conversation.put("conversationId", conversationId);
+        conversation.put("createdAt", now);
+        conversation.put("updatedAt", now);
+
+        conversations.put(conversationId, conversation);
+        conversationMessages.put(conversationId, new ArrayList<>());
+
+        log.info("Created new conversation: {}", conversationId);
+        return conversationId;
+    }
+
+    private MessageDto mapToMessageDto(Map<String, Object> messageMap) {
+        return MessageDto.builder()
+                .messageId((String) messageMap.get("messageId"))
+                .conversationId((String) messageMap.get("conversationId"))
+                .content((String) messageMap.get("content"))
+                .role((String) messageMap.get("role"))
+                .timestamp((LocalDateTime) messageMap.get("timestamp"))
+                .build();
+    }
+
+    private String addMessageToConversation(String conversationId, String content, String role) {
+        List<Map<String, Object>> messages = conversationMessages.computeIfAbsent(conversationId, k -> new ArrayList<>());
+
+        String messageId = "msg-" + UUID.randomUUID().toString().substring(0, 8);
+        Map<String, Object> message = new HashMap<>();
+        message.put("messageId", messageId);
+        message.put("conversationId", conversationId);
+        message.put("content", content);
+        message.put("role", role);
+        message.put("timestamp", LocalDateTime.now());
+
+        messages.add(message);
+
+        // Update conversation timestamp
+        Map<String, Object> conversation = conversations.get(conversationId);
        if (conversation != null) {
-            List<ChatMessage> messages = messageDao.findByConversationIdOrderByGmtCreateAsc(conversationId);
-            conversation.setMessages(messages);
+            conversation.put("updatedAt", LocalDateTime.now());
+            // Auto-generate title from first user message
+            if ("user".equals(role) && messages.stream().filter(m -> "user".equals(m.get("role"))).count() == 1) {
+                String title = content.length() > 30 ? content.substring(0, 27) + "..." : content;
+                conversation.put("title", title);
+            }
        }
-        return conversation;
+
+        return messageId;
    }

-    @Override
-    public List<ChatConversation> getAllConversations() {
-        List<ChatConversation> conversations = conversationDao.findAll(Sort.by(Sort.Direction.DESC, "id"));
-        if (conversations.isEmpty()) {
-            return conversations;
-        }
-        List<Long> conversationIds = conversations.stream()
-                .map(ChatConversation::getId)
-                .toList();
-        List<ChatMessage> allMessages = messageDao.findByConversationIdInOrderByGmtCreateAsc(conversationIds);
-        Map<Long, List<ChatMessage>> messagesByConversationId = allMessages.stream()
-                .collect(Collectors.groupingBy(ChatMessage::getConversationId));
-        for (ChatConversation conversation : conversations) {
-            List<ChatMessage> messages = messagesByConversationId.getOrDefault(conversation.getId(), Collections.emptyList());
-            conversation.setMessages(messages);
-        }
-        return conversations;
-    }

-    @Override
-    @Transactional(rollbackFor = Exception.class)
-    public void deleteConversation(Long conversationId) {
-        List<ChatMessage> messages = messageDao.findByConversationIdOrderByGmtCreateAsc(conversationId);
-        if (!messages.isEmpty()) {
-            messageDao.deleteAll(messages);
-        }
-        conversationDao.deleteById(conversationId);
-    }
+
 }
@@ -18,17 +18,23 @@

 package org.apache.hertzbeat.ai.service.impl;

+import org.apache.hertzbeat.ai.config.CustomSseServerTransport;
 import org.apache.hertzbeat.ai.service.McpServerService;
 import org.apache.hertzbeat.ai.tools.AlertDefineTools;
 import org.apache.hertzbeat.ai.tools.AlertTools;
 import org.apache.hertzbeat.ai.tools.MetricsTools;
 import org.apache.hertzbeat.ai.tools.MonitorTools;
+import org.springframework.ai.mcp.server.autoconfigure.McpServerProperties;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Primary;
 import org.springframework.stereotype.Service;
 import org.springframework.ai.tool.ToolCallbackProvider;
 import org.springframework.ai.tool.method.MethodToolCallbackProvider;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.web.servlet.function.RouterFunction;
+import org.springframework.web.servlet.function.ServerResponse;

 /**
 * Implementation of the McpServerService interface.
@@ -50,4 +56,36 @@ public class McpServerServiceImpl implements McpServerService {
    public ToolCallbackProvider hertzbeatTools() {
        return MethodToolCallbackProvider.builder().toolObjects(monitorTools, alertTools, alertDefineTools, metricsTools).build();
    }
+    /**
+     * Provides a custom SSE server transport for the MCP server.
+     *
+     * @param objectMapper the ObjectMapper instance for JSON serialization
+     * @param serverProperties the properties for the MCP server configuration
+     * @return a CustomSseServerTransport instance configured with the provided properties
+     */
+
+    @Bean
+    public CustomSseServerTransport webMvcSseServerTransportProvider(
+            ObjectMapper objectMapper,
+            McpServerProperties serverProperties
+    ) {
+        return new CustomSseServerTransport(
+                objectMapper,
+                serverProperties.getBaseUrl(),
+                serverProperties.getSseMessageEndpoint(),
+                serverProperties.getSseEndpoint()
+        );
+    }
+    /**
+     * Provides the MCP server transport bean.
+     *
+     * @param transport the custom SSE server transport
+     * @return the MCP server transport instance
+     */
+
+    @Primary
+    @Bean
+    public RouterFunction<ServerResponse> mvcMcpRouterFunction(CustomSseServerTransport transport) {
+        return transport.getRouterFunction();
+    }
 }
@@ -15,6 +15,7 @@
 * limitations under the License.
 */

+
 package org.apache.hertzbeat.ai.tools;

 /**
@@ -41,4 +42,5 @@ public interface AlertTools {
     */
    String getAlertsSummary();

+
 }
@@ -15,6 +15,7 @@
 * limitations under the License.
 */

+
 package org.apache.hertzbeat.ai.tools;

 /**
@@ -32,17 +33,16 @@ public interface MetricsTools {

    /**
     * Get historical metrics data for a monitor
-     *
-     * @param instance Instance identifier (e.g., "ip:port", "ip", or "domain")
-     * @param app      Monitor type (e.g., "linux", "mysql", "http")
-     * @param metrics  Metrics name (e.g., "system", "cpu", "memory")
-     * @param metric   Specific metric field (e.g., "usage", "used", "available")
-     * @param label    Label filter for specific instances
-     * @param history  Time range (e.g., "1h", "6h", "24h", "7d")
+     * @param monitorId Monitor ID
+     * @param app Monitor type (e.g., "linux", "mysql", "http")
+     * @param metrics Metrics name (e.g., "system", "cpu", "memory")
+     * @param metric Specific metric field (e.g., "usage", "used", "available")
+     * @param label Label filter for specific instances
+     * @param history Time range (e.g., "1h", "6h", "24h", "7d")
     * @param interval Whether to aggregate data with intervals
     * @return Historical metrics data formatted for display
     */
-    String getHistoricalMetrics(String instance, String app, String metrics, String metric, String label, String history, Boolean interval);
+    String getHistoricalMetrics(Long monitorId, String app, String metrics, String metric, String label, String history, Boolean interval);

    /**
     * Check warehouse storage server status
@@ -15,6 +15,7 @@
 * limitations under the License.
 */

+
 package org.apache.hertzbeat.ai.tools;

 import java.util.List;
@@ -26,25 +27,35 @@ public interface MonitorTools {

    /**
     * Add a new monitor with comprehensive configuration
-     *
+     * 
     * @param name Monitor name
     * @param app Monitor type/application (e.g., 'linux', 'mysql', 'http')
+     * @param host Target host (IP address or domain name)
+     * @param port Target port (optional, depends on monitor type)
     * @param intervals Collection interval in seconds (default: 600)
-     * @param params Monitor-specific parameters as JSON string (e.g., host, port, username, password, etc.)
+     * @param username Username for authentication (optional)
+     * @param password Password for authentication (optional)
+     * @param database Database name (for database monitors)
+     * @param additionalParams Additional app-specific parameters as JSON string (optional)
     * @param description Monitor description (optional)
     * @return Result message with monitor ID if successful
     */
    String addMonitor(
-            String name,
-            String app,
+            String name, 
+            String app, 
+            String host,
+            Integer port,
            Integer intervals,
-            String params,
+            String username,
+            String password,
+            String database,
+            String additionalParams,
            String description
    );
-
+    
    /**
     * List all available monitor types that can be added
-     *
+     * 
     * @param language Language code for localized names (e.g., 'en-US', 'zh-CN')
     * @return Formatted string list of available monitor types with descriptions
     */
@@ -78,9 +89,9 @@ public interface MonitorTools {

    /**
     * Get parameter definitions required for a specific monitor type
-     *
+     * 
     * @param app Monitor type/application name (e.g., 'linux', 'mysql', 'redis')
     * @return Formatted string with parameter definitions including field names, types, and requirements
     */
-    String getMonitorParams(String app);
+    String getMonitorAdditionalParams(String app);
 }
@@ -22,13 +22,12 @@ import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.usthe.sureness.subject.SubjectSum;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.hertzbeat.ai.adapters.AlertDefineServiceAdapter;
+import org.apache.hertzbeat.ai.pojo.dto.Hierarchy;
 import org.apache.hertzbeat.ai.config.McpContextHolder;
-import org.apache.hertzbeat.alert.service.AlertDefineService;
-import org.apache.hertzbeat.manager.service.AppService;
 import org.apache.hertzbeat.ai.tools.AlertDefineTools;
 import org.apache.hertzbeat.ai.utils.UtilityClass;
 import org.apache.hertzbeat.common.entity.alerter.AlertDefine;
-import org.apache.hertzbeat.manager.pojo.dto.Hierarchy;
 import org.springframework.ai.tool.annotation.Tool;
 import org.springframework.ai.tool.annotation.ToolParam;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -47,13 +46,12 @@ import java.util.Map;
@Service
 public class AlertDefineToolsImpl implements AlertDefineTools {
    @Autowired
-    private AlertDefineService alertDefineService;
-    @Autowired
-    private AppService appService;
+    private AlertDefineServiceAdapter alertDefineServiceAdapter;
+

    @Override
    @Tool(name = "create_alert_rule", description = """
-            HertzBeat: ALERT RULE means when to alert a user
+            ALERT RULE means when to alert a user
            THESE ARE ALERT RULES WITH THRESHOLD VALUES. USERS CAN SPECIFY THE THRESHOLD VALUES FOR EXAMPLE,
            IF THE USER SAYS "ALERT ME WHEN MY COST EXCEEDS 700, THE EXPRESSION SHOULD BE 'cost > 700' NOT 'cost < 700'.
            APPLY THE SAME LOGIC FOR LESS THAN OPERATOR.
@@ -242,19 +240,17 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
                    .datasource(datasource)
                    .enable(enable)
                    .build();
-            
-            log.debug("Current security subject for addAlertDefine: {}", subjectSum);

-            alertDefineService.addAlertDefine(alertDefine);
+            AlertDefine createdAlertDefine = alertDefineServiceAdapter.addAlertDefine(alertDefine);

            // Note: Monitor binding is handled separately via bind_monitors_to_alert_rule tool
            String bindingNote = String.format(" (Use bind_monitors_to_alert_rule tool to associate specific monitors)");

-            log.info("Successfully created alert rule '{}' with ID: {}", name, alertDefine.getId());
+            log.info("Successfully created alert rule '{}' with ID: {}", name, createdAlertDefine.getId());
            
            StringBuilder response = new StringBuilder();
            response.append(String.format("Successfully created %s alert rule '%s' with ID: %d\n", 
-                    type, name, alertDefine.getId()));
+                    type, name, createdAlertDefine.getId()));
            response.append(String.format("Expression: %s\n", expr));
            response.append(String.format("Priority: %d (%s)\n", priority, severityLabel));
            response.append(String.format("Trigger after: %d consecutive violations\n", times));
@@ -280,7 +276,7 @@ public class AlertDefineToolsImpl implements AlertDefineTools {

    @Override
    @Tool(name = "list_alert_rules", description = """
-            HertzBeat: List existing alert rules with filtering options.
+            List existing alert rules with filtering options.
            Shows configured thresholds and alert definitions.
            """)
    public String listAlertRules(
@@ -300,11 +296,8 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
                pageSize = 10;
            }

-            SubjectSum subjectSum = McpContextHolder.getSubject();
-            log.debug("Current security subject for getAlertDefines: {}", subjectSum);
-
-            Page<AlertDefine> result = alertDefineService.getAlertDefines(null,
-                    search, "gmtCreate", "desc", pageIndex, pageSize);
+            Page<AlertDefine> result = alertDefineServiceAdapter.getAlertDefines(
+                    search, monitorType, enabled, "gmtCreate", "desc", pageIndex, pageSize);

            StringBuilder response = new StringBuilder();
            response.append("Found ").append(result.getContent().size())
@@ -342,7 +335,7 @@ public class AlertDefineToolsImpl implements AlertDefineTools {

    @Override
    @Tool(name = "toggle_alert_rule", description = """
-            HertzBeat: Enable or disable an alert rule.
+            Enable or disable an alert rule.
            Allows activating or deactivating threshold monitoring.
            """)
    public String toggleAlertRule(
@@ -352,21 +345,7 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
        try {
            log.info("Toggling alert rule ID: {} to enabled: {}", ruleId, enabled);

-            SubjectSum subjectSum = McpContextHolder.getSubject();
-            log.debug("Current security subject for toggleAlertDefineStatus: {}", subjectSum);
-
-            // First get the existing AlertDefine
-            AlertDefine alertDefine = alertDefineService.getAlertDefine(ruleId);
-
-            if (alertDefine == null) {
-                throw new RuntimeException("AlertDefine with ID " + ruleId + " not found");
-            }
-
-            // Update the enable status
-            alertDefine.setEnable(enabled);
-
-            // Use modifyAlertDefine to save the changes
-            alertDefineService.modifyAlertDefine(alertDefine);
+            alertDefineServiceAdapter.toggleAlertDefineStatus(ruleId, enabled);

            log.info("Successfully toggled alert rule ID: {} to enabled: {}", ruleId, enabled);
            return String.format("Successfully %s alert rule ID: %d",
@@ -378,9 +357,10 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
        }
    }

+
    @Override
    @Tool(name = "get_alert_rule_details", description = """
-            HertzBeat: Get detailed information about a specific alert rule.
+            Get detailed information about a specific alert rule.
            Shows complete threshold configuration and rule settings.
            """)
    public String getAlertRuleDetails(
@@ -389,10 +369,7 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
        try {
            log.info("Getting alert rule details for ID: {}", ruleId);

-            SubjectSum subjectSum = McpContextHolder.getSubject();
-            log.debug("Current security subject for getAlertDefine: {}", subjectSum);
-
-            AlertDefine alertDefine = alertDefineService.getAlertDefine(ruleId);
+            AlertDefine alertDefine = alertDefineServiceAdapter.getAlertDefine(ruleId);
            if (alertDefine == null) {
                return "Alert rule with ID " + ruleId + " not found";
            }
@@ -439,7 +416,7 @@ public class AlertDefineToolsImpl implements AlertDefineTools {

    @Override
    @Tool(name = "get_apps_metrics_hierarchy", description = """
-            HertzBeat: Get the hierarchical structure of all available apps and their metrics for alert rule creation.
+            Get the hierarchical structure of all available apps and their metrics for alert rule creation.
            This tool provides the exact app name, metric name and corresponding param names according to each metric.
            Returns structured JSON data showing the complete hierarchy with field parameters for alert expressions.
            
@@ -464,7 +441,7 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
            log.debug("Current subject in get_apps_metrics_hierarchy tool: {}", subjectSum);

            List<Hierarchy> hierarchies;
-            hierarchies = appService.getAppHierarchy(app.trim().toLowerCase(), "en-US");
+            hierarchies = alertDefineServiceAdapter.getAppHierarchy(app.trim().toLowerCase(), "en-US");


            ObjectMapper mapper = new ObjectMapper();
@@ -482,7 +459,10 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
                result.put("message", "No hierarchy data available");
            }

-            return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(result);
+            String jsonResult = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(result);
+            log.info("Hierarchy JSON: {}", jsonResult);
+
+            return jsonResult;

        } catch (Exception e) {
            log.error("Failed to get apps metrics hierarchy: {}", e.getMessage(), e);
@@ -492,7 +472,7 @@ public class AlertDefineToolsImpl implements AlertDefineTools {

    @Override
    @Tool(name = "bind_monitors_to_alert_rule", description = """
-            HertzBeat: Bind monitors to an alert rule.
+            Bind monitors to an alert rule.
            Call this tool if users want to bind specific monitors to their alert rule.
            Get the right monitor ids for a particular app using the query_monitors tool.
            Get the alert rule ID from the create_alert_rule tool output OR use the list_alert_rules tool with app_name search filter, if the output of create_alert_rule is not applicable.
@@ -514,9 +494,7 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
            }

            // Get the existing alert rule
-            log.debug("Current security subject for getAlertDefine: {}", subjectSum);
-
-            AlertDefine existingRule = alertDefineService.getAlertDefine(ruleId);
+            AlertDefine existingRule = alertDefineServiceAdapter.getAlertDefine(ruleId);
            if (existingRule == null) {
                return String.format("Error: Alert rule with ID %d not found", ruleId);
            }
@@ -593,9 +571,7 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
                
                // Update the alert rule
                existingRule.setExpr(newExpr);
-                log.debug("Current security subject for modifyAlertDefine: {}", subjectSum);
-
-                alertDefineService.modifyAlertDefine(existingRule);
+                alertDefineServiceAdapter.modifyAlertDefine(existingRule);
                
                log.info("Successfully added monitors {} to existing bindings for alert rule ID: {}", validMonitorIds, ruleId);
                return String.format("Successfully added %d new monitor(s) to alert rule ID %d.\nTotal bound monitors: %s\nUpdated expression: %s", 
@@ -632,8 +608,7 @@ public class AlertDefineToolsImpl implements AlertDefineTools {

            // Update the alert rule
            existingRule.setExpr(newExpr);
-
-            alertDefineService.modifyAlertDefine(existingRule);
+            alertDefineServiceAdapter.modifyAlertDefine(existingRule);

            log.info("Successfully bound monitors {} to alert rule ID: {}", validMonitorIds, ruleId);
            return String.format("Successfully bound %d monitor(s) to alert rule ID %d.\nMonitor IDs: %s\nUpdated expression: %s", 
@@ -645,6 +620,7 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
        }
    }

+
    /**
     * Validates that the app, metric, and field conditions are valid according to hierarchy
     * @param app App name to validate
@@ -657,10 +633,7 @@ public class AlertDefineToolsImpl implements AlertDefineTools {
            log.debug("Validating hierarchy relationships: app={}, metrics={}, fieldConditions={}", app, metrics, fieldConditions);

            // Get hierarchy for the specified app
-            SubjectSum subjectSum = McpContextHolder.getSubject();
-            log.debug("Current security subject for getAppHierarchy: {}", subjectSum);
-
-            List<Hierarchy> hierarchies = appService.getAppHierarchy(app.toLowerCase(), "en-US");
+            List<Hierarchy> hierarchies = alertDefineServiceAdapter.getAppHierarchy(app.toLowerCase(), "en-US");

            if (hierarchies == null || hierarchies.isEmpty()) {
                return String.format("Error: App '%s' not found in hierarchy. Please use list_monitor_types to get valid app names.", app);
@@ -15,15 +15,16 @@
 * limitations under the License.
 */

+
 package org.apache.hertzbeat.ai.tools.impl;

 import com.usthe.sureness.subject.SubjectSum;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.hertzbeat.ai.adapters.AlertServiceAdapter;
 import org.apache.hertzbeat.ai.config.McpContextHolder;
 import org.apache.hertzbeat.ai.tools.AlertTools;
 import org.apache.hertzbeat.ai.utils.UtilityClass;
 import org.apache.hertzbeat.alert.dto.AlertSummary;
-import org.apache.hertzbeat.alert.service.AlertService;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
 import org.apache.hertzbeat.common.entity.alerter.SingleAlert;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -32,6 +33,7 @@ import org.springframework.ai.tool.annotation.Tool;
 import org.springframework.ai.tool.annotation.ToolParam;
 import org.springframework.stereotype.Service;

+
 /**
 * Implementation of Alert Tools functionality for alarm data queries and management
 */
@@ -39,11 +41,11 @@ import org.springframework.stereotype.Service;
@Service
 public class AlertToolsImpl implements AlertTools {
    @Autowired
-    private AlertService alertService;
+    private AlertServiceAdapter alertServiceAdapter;

    @Override
    @Tool(name = "query_alerts", description = """
-            HertzBeat: Query alerts with comprehensive filtering and pagination options.
+            Query alerts with comprehensive filtering and pagination options.
            
            ALERT TYPES:
            - Pass alertType='single' for individual alert instances
@@ -114,7 +116,7 @@ public class AlertToolsImpl implements AlertTools {

            // Handle different alert types
            if ("single".equalsIgnoreCase(alertType) || "both".equalsIgnoreCase(alertType)) {
-                Page<SingleAlert> singleResult = alertService.getSingleAlerts(status, search, sort, order, pageIndex, pageSize);
+                Page<SingleAlert> singleResult = alertServiceAdapter.getSingleAlerts(status, search, sort, order, pageIndex, pageSize);
                
                response.append("SINGLE ALERTS:\n");
                response.append("Found ").append(singleResult.getContent().size()).append(" single alerts (Total: ").append(singleResult.getTotalElements()).append("):\n\n");
@@ -152,7 +154,7 @@ public class AlertToolsImpl implements AlertTools {
                    response.append("\n");
                }
                
-                Page<GroupAlert> groupResult = alertService.getGroupAlerts(status, search, sort, order, pageIndex, pageSize);
+                Page<GroupAlert> groupResult = alertServiceAdapter.getGroupAlerts(status, search, sort, order, pageIndex, pageSize);
                
                response.append("GROUP ALERTS:\n");
                response.append("Found ").append(groupResult.getContent().size()).append(" group alerts (Total: ").append(groupResult.getTotalElements()).append("):\n\n");
@@ -191,9 +193,10 @@ public class AlertToolsImpl implements AlertTools {
        }
    }

+
    @Override
    @Tool(name = "get_alerts_summary", description = """
-            HertzBeat: Get alerts summary statistics including total counts, status distribution, and recent trends.
+            Get alerts summary statistics including total counts, status distribution, and recent trends.
            Returns comprehensive overview of the current alerting status across all monitors.
            """)
    public String getAlertsSummary() {
@@ -202,7 +205,7 @@ public class AlertToolsImpl implements AlertTools {
            SubjectSum subjectSum = McpContextHolder.getSubject();
            log.debug("Current subject in get_alerts_summary tool: {}", subjectSum);

-            AlertSummary summary = alertService.getAlertsSummary();
+            AlertSummary summary = alertServiceAdapter.getAlertsSummary();

            StringBuilder response = new StringBuilder();
            response.append("ALERTS SUMMARY\n");
@@ -15,12 +15,14 @@
 * limitations under the License.
 */

+
 package org.apache.hertzbeat.ai.tools.impl;

 import com.usthe.sureness.subject.SubjectSum;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.hertzbeat.ai.adapters.MetricsServiceAdapter;
+import org.apache.hertzbeat.ai.adapters.MonitorServiceAdapter;
 import org.apache.hertzbeat.ai.config.McpContextHolder;
-import org.apache.hertzbeat.warehouse.service.MetricsDataService;
 import org.apache.hertzbeat.ai.tools.MetricsTools;
 import org.apache.hertzbeat.common.entity.dto.Field;
 import org.apache.hertzbeat.common.entity.dto.MetricsData;
@@ -42,11 +44,13 @@ import java.util.Map;
@Service
 public class MetricsToolsImpl implements MetricsTools {
    @Autowired
-    private MetricsDataService metricsDataService;
+    private MetricsServiceAdapter metricsServiceAdapter;
+    @Autowired
+    private MonitorServiceAdapter monitorServiceAdapter;

    @Override
    @Tool(name = "query_realtime_metrics", description = """
-            HertzBeat: Get the supported monitor types/names from the list_monitor_types tool, make sure to use right name in the next call
+            Get the supported monitor types/names from the list_monitor_types tool, make sure to use right name in the next call
            Use the query_monitors tool to find monitor IDs in case the user does not tell the id explicitly. You might have to use this multiple times based on the user's query
            Get real-time metrics data for a specific monitor.
            Returns current metrics values including CPU, memory, disk usage, etc.
@@ -74,7 +78,7 @@ public class MetricsToolsImpl implements MetricsTools {
            SubjectSum subjectSum = McpContextHolder.getSubject();
            log.debug("Current subject in get_realtime_metrics tool: {}", subjectSum);

-            MetricsData metricsData = metricsDataService.getMetricsData(monitorId, metrics);
+            MetricsData metricsData = metricsServiceAdapter.getMetricsData(monitorId, metrics);

            if (metricsData == null) {
                return String.format("No real-time metrics data found for monitor ID %d and metrics '%s'", monitorId, metrics);
@@ -143,7 +147,7 @@ public class MetricsToolsImpl implements MetricsTools {

    @Override
    @Tool(name = "get_historical_metrics", description = """
-            HertzBeat: Get historical metrics data for analysis and trending.
+            Get historical metrics data for analysis and trending.
            Returns time-series data for specified metrics over a time range.
            Use the query_monitors tool to find the correct monitor IDs/ name or type for the monitor(s) user asked the metrics for
            Pass that name into the get_apps_metrics_hierarchy tool to get the metrics hierarchy i.e metrics and the field paramater
@@ -151,7 +155,7 @@ public class MetricsToolsImpl implements MetricsTools {
            Ask user to provide the filters for labels, history and interval aggregation
            """)
    public String getHistoricalMetrics(
-            @ToolParam(description = "Instance identifier (e.g., 'ip:port', 'ip', or 'domain')") String instance,
+            @ToolParam(description = "Monitor ID", required = true) Long monitorId,
            @ToolParam(description = "Monitor type (e.g., 'linux', 'mysql', 'http')", required = true) String app,
            @ToolParam(description = "Metrics name (e.g., 'target', 'cpu', 'memory')", required = true) String metrics,
            @ToolParam(description = "Field Parameter (e.g., 'usage', 'used', 'available')", required = false) String fieldParameter,
@@ -160,7 +164,7 @@ public class MetricsToolsImpl implements MetricsTools {
            @ToolParam(description = "Whether to aggregate data with intervals", required = false) Boolean interval) {

        try {
-            log.info("Getting historical metrics for monitor instance {} and metrics {}", instance, metrics);
+            log.info("Getting historical metrics for monitor {} and metrics {}", monitorId, metrics);

            if (history == null || history.trim().isEmpty()) {
                history = "24h";
@@ -169,15 +173,15 @@ public class MetricsToolsImpl implements MetricsTools {
                interval = true;
            }

-            MetricsHistoryData historyData = metricsDataService.getMetricHistoryData(instance,
-                    app, metrics, fieldParameter, history, interval);
+            MetricsHistoryData historyData = metricsServiceAdapter.getMetricHistoryData(
+                    monitorId, app, metrics, fieldParameter, label, history, interval);

            if (historyData == null) {
-                return String.format("No historical metrics data found for monitor %s and metrics '%s'", instance, metrics);
+                return String.format("No historical metrics data found for monitor ID %d and metrics '%s'", monitorId, metrics);
            }

            StringBuilder response = new StringBuilder();
-            response.append("HISTORICAL METRICS: ").append(metrics).append(" (Monitor ID: ").append(instance).append(")\n");
+            response.append("HISTORICAL METRICS: ").append(metrics).append(" (Monitor ID: ").append(monitorId).append(")\n");
            response.append("Time Range: ").append(history).append(" | Interval Aggregation: ").append(interval).append("\n");
            response.append("=".repeat(60)).append("\n\n");

@@ -222,18 +226,17 @@ public class MetricsToolsImpl implements MetricsTools {
        }
    }

+
    @Override
    @Tool(name = "get_warehouse_status", description = """
-            HertzBeat: Check the status of the metrics storage warehouse system.
+            Check the status of the metrics storage warehouse system.
            Returns whether the metrics storage is operational and accessible.
            """)
    public String getWarehouseStatus() {
        try {
            log.info("Checking warehouse storage status");
-            SubjectSum subjectSum = McpContextHolder.getSubject();
-            log.debug("Current security subject for getWarehouseStorageServerStatus: {}", subjectSum);

-            Boolean status = metricsDataService.getWarehouseStorageServerStatus();
+            Boolean status = metricsServiceAdapter.getWarehouseStorageServerStatus();

            StringBuilder response = new StringBuilder();
            response.append("METRICS WAREHOUSE STATUS\n");
@@ -19,10 +19,8 @@ package org.apache.hertzbeat.ai.tools.impl;

 import com.usthe.sureness.subject.SubjectSum;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.hertzbeat.ai.adapters.MonitorServiceAdapter;
 import org.apache.hertzbeat.ai.config.McpContextHolder;
-import org.apache.hertzbeat.manager.pojo.dto.MonitorDto;
-import org.apache.hertzbeat.manager.service.MonitorService;
-import org.apache.hertzbeat.manager.service.AppService;
 import org.apache.hertzbeat.ai.utils.UtilityClass;
 import org.springframework.ai.tool.annotation.Tool;
 import org.springframework.data.domain.Page;
@@ -45,9 +43,8 @@ import java.util.Map;
@Service
 public class MonitorToolsImpl implements MonitorTools {
    @Autowired
-    private MonitorService monitorService;
-    @Autowired
-    private AppService appService;
+    private MonitorServiceAdapter monitorServiceAdapter;
+

    /**
     * Tool to query monitor information with flexible filtering and pagination.
@@ -56,48 +53,48 @@ public class MonitorToolsImpl implements MonitorTools {
     * Returns detailed monitor information including ID, name, type, host, and status.
     */
    @Override
-    @Tool(name = "query_monitors", description = """
-            HertzBeat: Query Existing/configured monitors in HertzBeat.
+    @Tool(name = "query_monitors", description = """ 
+            Query Existing/configured monitors in HertzBeat.
            This tool retrieves monitors based on various filters and parameters.
            Comprehensive monitor querying with flexible filtering, pagination, and specialized views.
-
+            
            MONITOR STATUSES:
            - status=1: Online/Active monitors (healthy, responding normally)
            - status=2: Offline monitors (not responding, connection failed)
            - status=3: Unreachable monitors (network/connectivity issues)
            - status=0: Paused monitors (manually disabled/suspended)
            - status=9 or null: All monitors regardless of status (default)
-
+            
            COMMON USE CASES & PARAMETER COMBINATIONS:
-
+            
            1. BASIC MONITOR LISTING:
               - Default: No parameters (shows all monitors, 8 per page)
               - By type: app='linux' (show only Linux monitors)
               - Search: search='web' (find monitors with 'web' in name/host)
-
+            
            2. STATUS-BASED QUERIES:
               - Healthy monitors: status=1, pageSize=50
               - Problem monitors: status=2 or status=3, pageSize=50
               - Offline monitors only: status=2
               - Unreachable monitors only: status=3
               - Paused monitors: status=0
-
+            
            3. MONITORING HEALTH OVERVIEW:
               - All statuses with statistics: status=9, includeStats=true, pageSize=100
               - Unhealthy monitors: Pass both status=2 AND status=3 (make 2 separate calls)
-
+            
            4. ADVANCED FILTERING:
               - Specific monitor types: app='mysql', status=1 (healthy MySQL monitors)
               - Label-based: labels='env:prod,critical:true'
               - Host search: search='192.168' (find by IP pattern)
               - Monitor IDs: ids=[1,2,3] (specific monitors by ID)
-
+            
            5. SORTING & PAGINATION:
               - Recently updated: sort='gmtUpdate', order='desc'
               - Alphabetical: sort='name', order='asc'
               - By creation: sort='gmtCreate', order='desc' (newest first)
               - Large datasets: pageSize=50-100 for bulk operations
-
+            
            RESPONSE FORMAT:
            - includeStats=true: Adds status distribution summary at top
            - Default: Simple list with ID, name, type, host, status
@@ -125,32 +122,28 @@ public class MonitorToolsImpl implements MonitorTools {
            if (includeStats == null) {
                includeStats = false;
            }
-
-            SubjectSum subjectSum = McpContextHolder.getSubject();
-            log.debug("Current security subject: {}", subjectSum);
-
-            Page<Monitor> result = monitorService.getMonitors(
-                    ids, app, search, status, sort, order, pageIndex, pageSize, labels);
-            log.debug("MonitorService.getMonitors result: {}", result);
-
+            
+            Page<Monitor> result = monitorServiceAdapter.getMonitors(ids, app, search, status, sort, order, pageIndex, pageSize, labels);
+            log.debug("MonitorServiceAdapter.getMonitors result: {}", result);
+            
            StringBuilder response = new StringBuilder();
            response.append("MONITOR QUERY RESULTS\n");
            response.append("====================\n\n");
-
+            
            // Include statistics if requested
            if (includeStats) {
                // Get status distribution by calling with different status values
-                long onlineCount = monitorService.getMonitors(null, app, search, (byte) 1, null, null, 0, 1000, labels).getTotalElements();
-                long offlineCount = monitorService.getMonitors(null, app, search, (byte) 2, null, null, 0, 1000, labels).getTotalElements();
-                long unreachableCount = monitorService.getMonitors(null, app, search, (byte) 3, null, null, 0, 1000, labels).getTotalElements();
-                long pausedCount = monitorService.getMonitors(null, app, search, (byte) 0, null, null, 0, 1000, labels).getTotalElements();
-
+                long onlineCount = monitorServiceAdapter.getMonitors(null, app, search, (byte) 1, null, null, 0, 1000, labels).getTotalElements();
+                long offlineCount = monitorServiceAdapter.getMonitors(null, app, search, (byte) 2, null, null, 0, 1000, labels).getTotalElements();
+                long unreachableCount = monitorServiceAdapter.getMonitors(null, app, search, (byte) 3, null, null, 0, 1000, labels).getTotalElements();
+                long pausedCount = monitorServiceAdapter.getMonitors(null, app, search, (byte) 0, null, null, 0, 1000, labels).getTotalElements();
+                
                response.append("STATUS OVERVIEW:\n");
                response.append("- Online: ").append(onlineCount).append("\n");
-                response.append("- Offline: ").append(offlineCount).append("\n");
+                response.append("- Offline: ").append(offlineCount).append("\n"); 
                response.append("- Unreachable: ").append(unreachableCount).append("\n");
                response.append("- Paused: ").append(pausedCount).append("\n");
-
+                
                long total = onlineCount + offlineCount + unreachableCount + pausedCount;
                if (total > 0) {
                    double healthPercentage = (onlineCount * 100.0) / total;
@@ -158,47 +151,48 @@ public class MonitorToolsImpl implements MonitorTools {
                }
                response.append("\n");
            }
-
+            
            response.append("Query Results: ").append(result.getContent().size())
                   .append(" monitors (Total: ").append(result.getTotalElements()).append(")\n");
-
+            
            if (result.getTotalPages() > 1) {
                response.append("Page ").append(pageIndex + 1).append(" of ").append(result.getTotalPages()).append("\n");
            }
            response.append("\n");
-
+            
            for (Monitor monitor : result.getContent()) {
                response.append("ID: ").append(monitor.getId())
                       .append(" | Name: ").append(monitor.getName())
                       .append(" | Type: ").append(monitor.getApp())
-                       .append(" | Instance: ").append(monitor.getInstance())
+                       .append(" | Host: ").append(monitor.getHost())
                       .append(" | Status: ").append(UtilityClass.getStatusText(monitor.getStatus()));
-
+                       
                // Add creation date for better context
                if (monitor.getGmtCreate() != null) {
                    response.append(" | Created: ").append(monitor.getGmtCreate().toString(), 0, 10);
                }
                response.append("\n");
            }
-
+            
            if (result.getContent().isEmpty()) {
                response.append("No monitors found matching the specified criteria.\n");
                response.append("Try adjusting your filters or search terms.");
            }
-
+            
            return response.toString();
        } catch (Exception e) {
            return "Error retrieving monitors: " + e.getMessage();
        }
    }

+
    @Override
    @Tool(name = "add_monitor", description = """
-            HertzBeat: Add a new monitoring target to HertzBeat with comprehensive configuration.
+            Add a new monitoring target to HertzBeat with comprehensive configuration.
            This tool dynamically handles different parameter requirements for each monitor type.
-
+            
            This tool creates monitors with proper app-specific parameters.
-
+            
            *********
            VERY IMPORTANT:
            ALWAYS use get_monitor_additional_params to check the additional required parameters for the chosen type before adding a monitor or even mentioning it.
@@ -206,36 +200,41 @@ public class MonitorToolsImpl implements MonitorTools {
            Use the information obtained from this to query user for parameters.
            If the User has not given any parameters, ask them to provide the necessary parameters, until all the necessary parameters are provided.
            **********
-
+            
            Examples of natural language requests this tool handles:
            - "Monitor website example.com with HTTPS on port 443"
            - "Add MySQL monitoring for database server at 192.168.1.10 with user admin"
            - "Monitor Linux server health on host server.company.com via SSH"
            - "Set up Redis monitoring on localhost port 6379 with password"
-
-            PARAMETER MAPPING: Use the 'params' parameter to pass all monitor-specific configuration.
-            The params should be a JSON string containing key-value pairs for the monitor type.
-            Use get_monitor_additional_params tool to see what parameters are required for each monitor type.
-
-            PARAMS EXAMPLES:
-            - Website: {"host":"example.com", "port":"443", "uri":"/api/health", "ssl":"true", "method":"GET"}
-            - Linux: {"host":"192.168.1.10", "port":"22", "username":"root", "password":"xxx"}
-            - MySQL: {"host":"db.server.com", "port":"3306", "username":"admin", "password":"xxx", "database":"mydb"}
-            - Redis: {"host":"redis.server.com", "port":"6379", "password":"xxx"}
+            
+            PARAMETER MAPPING: The tool intelligently maps common parameters:
+            - host: Target server/domain
+            - port: Service port (auto-detected if not specified)
+            - username: Authentication username
+            - password: Authentication password
+            - database: Database name (for DB monitors)
+            - additionalParams: JSON string for app-specific parameters (to be obtained from get_monitor_param_defines)
+            
+            ADDITIONAL PARAMETERS EXAMPLES:
+            - Website: {"uri":"/api/health", "ssl":"true", "method":"POST"}
+            - Linux: {"privateKey":"ssh-key-content", "script":"custom-script"}
+            - Database: {"url":"jdbc:mysql://custom", "timeout":"10000"}
            """)
    public String addMonitor(
            @ToolParam(description = "Monitor name (required)", required = true) String name,
            @ToolParam(description = "Monitor type: website, mysql, postgresql, redis, linux, windows, etc.", required = true) String app,
+            @ToolParam(description = "Target host: IP address or domain name", required = true) String host,
+            @ToolParam(description = "Target port (optional, auto-detected if not specified)", required = false) Integer port,
            @ToolParam(description = "Collection interval in seconds (default: 600)", required = false) Integer intervals,
-            @ToolParam(description = "Monitor-specific parameters as JSON string. "
-                    + "Use get_monitor_additional_params to see required fields. "
-                    + "Example: {\"host\":\"192.168.1.1\", \"port\":\"22\", \"username\":\"root\"}",
-                    required = true) String params,
+            @ToolParam(description = "Username for authentication (optional)", required = false) String username,
+            @ToolParam(description = "Password for authentication (optional)", required = false) String password,
+            @ToolParam(description = "Database name (for database monitors)", required = false) String database,
+            @ToolParam(description = "Additional app-specific parameters as JSON: {\"uri\":\"/api\", \"ssl\":\"true\", \"method\":\"POST\"}", required = false) String additionalParams,
            @ToolParam(description = "Monitor description (optional)", required = false) String description) {
-
+        
        try {
-            log.info("Adding monitor: name={}, app={}", name, app);
-
+            log.info("Adding monitor: name={}, app={}, host={}", name, app, host);
+            
            // Validate required parameters
            if (name == null || name.trim().isEmpty()) {
                return "Error: Monitor name is required";
@@ -243,179 +242,147 @@ public class MonitorToolsImpl implements MonitorTools {
            if (app == null || app.trim().isEmpty()) {
                return "Error: Monitor type/application is required";
            }
-            if (params == null || params.trim().isEmpty()) {
-                return "Error: Monitor params is required. Use get_monitor_additional_params to see required fields for this monitor type.";
+            if (host == null || host.trim().isEmpty()) {
+                return "Error: Host is required";
            }
-
+            
            // Set defaults
            if (intervals == null || intervals < 10) {
                intervals = 600;
            }
-
-            // Parse params to extract host and port for instance
-            List<Param> paramList = parseParams(params);
-            String host = paramList.stream()
-                    .filter(p -> "host".equals(p.getField()))
-                    .map(Param::getParamValue)
-                    .findFirst()
-                    .orElse("");
-            String port = paramList.stream()
-                    .filter(p -> "port".equals(p.getField()))
-                    .map(Param::getParamValue)
-                    .findFirst()
-                    .orElse(null);
-
-            String instance = (port != null && !port.isEmpty()) ? host.trim() + ":" + port : host.trim();
-
+            
            // Create Monitor entity
            Monitor monitor = Monitor.builder()
                    .name(name.trim())
                    .app(app.toLowerCase().trim())
-                    .instance(instance)
+                    .host(host.trim())
                    .intervals(intervals)
                    .status((byte) 1)
                    .type((byte) 0)
                    .description(description != null ? description.trim() : "")
                    .build();
-
+            
+            List<Param> params = createBasicParams(host, port, username, password, database, additionalParams);
+            
            // Validate that all required parameters for this monitor type are provided
            try {
-                MonitorDto monitorDto = MonitorDto.builder().monitor(monitor).params(paramList).build();
-                monitorService.validate(monitorDto, false);
-            } catch (IllegalArgumentException argumentException) {
-                if (argumentException.getMessage().contains("required")) {
-                    return String.format("Error: %s. "
-                            + "Or use get_monitor_additional_params tool to see all required parameters.",
-                        argumentException.getMessage());
-                } else {
-                    return String.format("Error: %s. ", argumentException.getMessage());
+                List<ParamDefine> requiredParams = monitorServiceAdapter.getMonitorParamDefines(app);
+                log.info("Checking required parameters for monitor type '{}': {}", app, requiredParams);
+                List<String> missingParams = new ArrayList<>();
+                
+                for (ParamDefine paramDefine : requiredParams) {
+                    if (paramDefine.isRequired()) {
+                        String fieldName = paramDefine.getField();
+                        boolean hasParam = params.stream()
+                                .anyMatch(param -> fieldName.equals(param.getField()));
+                        if (!hasParam) {
+                            missingParams.add(fieldName);
+                        }
+                    }
                }
+                
+                if (!missingParams.isEmpty()) {
+                    return String.format("Error: Missing required parameters for monitor type '%s': %s. "
+                            + "Use get_monitor_additional_params tool to see all required parameters.", 
+                            app, String.join(", ", missingParams));
+                }
+            } catch (Exception e) {
+                log.warn("Could not validate required parameters for monitor type '{}': {}", app, e.getMessage());
            }
-            monitorService.addMonitor(monitor, paramList, null, null);
-            log.info("Successfully added monitor '{}' with ID: {}", monitor.getName(), monitor.getId());
-            return String.format("Successfully added %s monitor '%s' with ID: %d (Instance: %s, Interval: %d seconds)",
-                    app.toUpperCase(), monitor.getName(), monitor.getId(), monitor.getInstance(), monitor.getIntervals());
-
+            
+            // Call adapter - it handles all the complexity (validation, defaults, app-specific logic)
+            Long monitorId = monitorServiceAdapter.addMonitor(monitor, params, null);
+            
+            log.info("Successfully added monitor '{}' with ID: {}", name, monitorId);
+            return String.format("Successfully added %s monitor '%s' with ID: %d (Host: %s, Interval: %d seconds)", 
+                    app.toUpperCase(), name, monitorId, host, intervals);
+            
        } catch (Exception e) {
            log.error("Failed to add monitor '{}': {}", name, e.getMessage(), e);
            return "Error adding monitor '" + name + "': " + e.getMessage();
        }
    }
-
+    
    /**
-     * Parse params JSON string to list of Param objects
+     * Create basic parameter list from user inputs
     */
-    private List<Param> parseParams(String params) {
-        List<Param> paramList = new ArrayList<>();
-
-        if (params == null || params.trim().isEmpty()) {
-            return paramList;
+    private List<Param> createBasicParams(String host, Integer port, String username, 
+                                         String password, String database, String additionalParams) {
+        List<Param> params = new ArrayList<>();
+        
+        // Add host (always required)
+        params.add(Param.builder().field("host").paramValue(host.trim()).type((byte) 1).build());
+        
+        // Add optional common parameters
+        if (port != null) {
+            params.add(Param.builder().field("port").paramValue(port.toString()).type((byte) 0).build());
        }
-
-        try {
-            String cleaned = params.trim();
-            // Remove outer braces if present
-            if (cleaned.startsWith("{") && cleaned.endsWith("}")) {
-                cleaned = cleaned.substring(1, cleaned.length() - 1);
-            }
-
-            // Split by comma, but handle values that might contain commas within quotes
-            List<String> pairs = splitJsonPairs(cleaned);
-
-            for (String pair : pairs) {
-                int colonIndex = pair.indexOf(':');
-                if (colonIndex > 0) {
-                    String key = pair.substring(0, colonIndex).trim().replaceAll("\"", "");
-                    String value = pair.substring(colonIndex + 1).trim().replaceAll("\"", "");
-
-                    // Determine param type based on field name
-                    byte paramType = determineParamType(key);
-                    paramList.add(Param.builder().field(key).paramValue(value).type(paramType).build());
+        if (username != null && !username.trim().isEmpty()) {
+            params.add(Param.builder().field("username").paramValue(username.trim()).type((byte) 1).build());
+        }
+        if (password != null && !password.trim().isEmpty()) {
+            params.add(Param.builder().field("password").paramValue(password.trim()).type((byte) 2).build());
+        }
+        if (database != null && !database.trim().isEmpty()) {
+            params.add(Param.builder().field("database").paramValue(database.trim()).type((byte) 1).build());
+        }
+        
+        // Parse additional parameters if provided
+        if (additionalParams != null && !additionalParams.trim().isEmpty()) {
+            try {
+                String cleaned = additionalParams.trim().replaceAll("[{}]", "");
+                String[] pairs = cleaned.split(",");
+                for (String pair : pairs) {
+                    String[] keyValue = pair.split(":");
+                    if (keyValue.length == 2) {
+                        String key = keyValue[0].trim().replaceAll("\"", "");
+                        String value = keyValue[1].trim().replaceAll("\"", "");
+                        params.add(Param.builder().field(key).paramValue(value).type((byte) 1).build());
+                    }
                }
-            }
-        } catch (Exception e) {
-            log.warn("Failed to parse params: {}", e.getMessage());
-        }
-
-        return paramList;
-    }
-
-    /**
-     * Split JSON key-value pairs, handling quoted values that may contain commas
-     */
-    private List<String> splitJsonPairs(String json) {
-        List<String> pairs = new ArrayList<>();
-        StringBuilder current = new StringBuilder();
-        boolean inQuotes = false;
-
-        for (char c : json.toCharArray()) {
-            if (c == '"') {
-                inQuotes = !inQuotes;
-                current.append(c);
-            } else if (c == ',' && !inQuotes) {
-                if (current.length() > 0) {
-                    pairs.add(current.toString().trim());
-                    current = new StringBuilder();
-                }
-            } else {
-                current.append(c);
+            } catch (Exception e) {
+                log.warn("Failed to parse additionalParams: {}", e.getMessage());
            }
        }
-
-        if (current.length() > 0) {
-            pairs.add(current.toString().trim());
-        }
-
-        return pairs;
+        
+        return params;
    }
-
-    /**
-     * Determine param type based on field name
-     */
-    private byte determineParamType(String fieldName) {
-        if ("password".equalsIgnoreCase(fieldName) || "privateKey".equalsIgnoreCase(fieldName)) {
-            return (byte) 2; // Password type
-        } else if ("port".equalsIgnoreCase(fieldName) || "timeout".equalsIgnoreCase(fieldName)) {
-            return (byte) 0; // Number type
-        }
-        return (byte) 1; // Default string type
-    }
-
+    
    @Override
    @Tool(name = "list_monitor_types", description = """
-            HertzBeat: List all available monitor types that can be added to HertzBeat.
+            List all available monitor types that can be added to HertzBeat.
            This tool shows all supported monitor types with their display names.
            Use this to see what types of monitors you can create with the add_monitor tool.
            """)
    public String listMonitorTypes(
            @ToolParam(description = "Language code for localized names (en-US, zh-CN, etc.). Default: en-US", required = false) String language) {
-
+        
        try {
            log.info("Listing available monitor types for language: {}", language);
            SubjectSum subjectSum = McpContextHolder.getSubject();
            log.debug("Current subject in list_monitor_types tool: {}", subjectSum);
-
+            
            // Set default language if not provided
            if (language == null || language.trim().isEmpty()) {
                language = "en-US";
            }
-
-            // Get available monitor types from app service
-            Map<String, String> monitorTypes = appService.getI18nApps(language);
-
+            
+            // Get available monitor types from adapter
+            Map<String, String> monitorTypes = monitorServiceAdapter.getAvailableMonitorTypes(language);
+            
            if (monitorTypes == null || monitorTypes.isEmpty()) {
                return "No monitor types are currently available.";
            }
-
+            
            // Format the response as a nice list
            StringBuilder response = new StringBuilder();
            response.append("Available Monitor Types (Total: ").append(monitorTypes.size()).append("):\n\n");
-
+            
            // Sort monitor types alphabetically by key
            List<Map.Entry<String, String>> sortedTypes = monitorTypes.entrySet().stream()
                    .sorted(Map.Entry.comparingByKey())
                    .toList();
-
+            
            for (Map.Entry<String, String> entry : sortedTypes) {
                String typeKey = entry.getKey();
                String displayName = entry.getValue();
@@ -423,100 +390,102 @@ public class MonitorToolsImpl implements MonitorTools {
                       .append(" - ").append(displayName)
                       .append("\n");
            }
-
+            
            response.append("\nTo add a monitor, use the add_monitor tool with one of these types as the 'app' parameter.");

            log.info("Successfully listed {} monitor types", monitorTypes);
            return response.toString();
-
+            
        } catch (Exception e) {
            log.error("Failed to list monitor types: {}", e.getMessage(), e);
            return "Error retrieving monitor types: " + e.getMessage();
        }
    }
-
+    
    @Override
-    @Tool(name = "get_monitor_params", description = """
-            HertzBeat: Get the parameter definitions required for a specific monitor type.
+    @Tool(name = "get_monitor_additional_params", description = """
+            Get the parameter definitions required for a specific monitor type.
            This tool shows what parameters are needed when adding a monitor of the specified type,
            ALWAYS use this before adding a monitor to understand what parameters the user needs to provide.
            Use the app parameter to specify the monitor type/application name (e.g., 'linux', 'mysql', 'redis') this can be obtained from the list_monitor_types tool.
            """)
-    public String getMonitorParams(
+    public String getMonitorAdditionalParams(
            @ToolParam(description = "Monitor type/application name (e.g., 'linux', 'mysql', 'redis')", required = true) String app) {
-
+        
        try {
            log.info("Getting parameter definitions for monitor type: {}", app);
            SubjectSum subjectSum = McpContextHolder.getSubject();
            log.debug("Current subject in get_monitor_param_defines tool: {}", subjectSum);
-
+            
            // Validate required parameter
            if (app == null || app.trim().isEmpty()) {
                return "Error: Monitor type/application parameter is required";
            }
-
-            // Get parameter definitions from app service
-            List<ParamDefine> paramDefines = appService.getAppParamDefines(app.toLowerCase().trim());
-
+            
+            // Get parameter definitions from adapter
+            List<ParamDefine> paramDefines = monitorServiceAdapter.getMonitorParamDefines(app);
+            
            if (paramDefines == null || paramDefines.isEmpty()) {
                return String.format("No parameter definitions found for monitor type '%s'. "
                   + "This monitor type may not exist or may not require additional parameters.", app);
            }
-
+            
            // Format the response
            StringBuilder response = new StringBuilder();
-            response.append(String.format("Parameter Definitions for Monitor Type '%s' (Total: %d):\n\n",
+            response.append(String.format("Parameter Definitions for Monitor Type '%s' (Total: %d):\n\n", 
                app, paramDefines.size()));
-
+            
            for (ParamDefine paramDefine : paramDefines) {
                response.append("• Field: ").append(paramDefine.getField()).append("\n");
-
+                
                // Add display name if available
                if (paramDefine.getName() != null && !paramDefine.getName().toString().trim().isEmpty()) {
                    response.append("  Name: ").append(paramDefine.getName()).append("\n");
                }
-
+                
                // Add type
                if (paramDefine.getType() != null && !paramDefine.getType().trim().isEmpty()) {
                    response.append("  Type: ").append(paramDefine.getType()).append("\n");
                }
-
+                
                // Add required status
                response.append("  Required: ").append(paramDefine.isRequired() ? "Yes" : "No").append("\n");
-
+                
                // Add default value if present
                if (paramDefine.getDefaultValue() != null && !paramDefine.getDefaultValue().trim().isEmpty()) {
                    response.append("  Default: ").append(paramDefine.getDefaultValue()).append("\n");
                }
-
+                
                // Add validation range if present
                if (paramDefine.getRange() != null && !paramDefine.getRange().trim().isEmpty()) {
                    response.append("  Range: ").append(paramDefine.getRange()).append("\n");
                }
-
+                
                // Add limit if present
                if (paramDefine.getLimit() != null) {
                    response.append("  Limit: ").append(paramDefine.getLimit()).append("\n");
                }
-
+                
                // Add placeholder text if present
                if (paramDefine.getPlaceholder() != null && !paramDefine.getPlaceholder().trim().isEmpty()) {
                    response.append("  Placeholder: ").append(paramDefine.getPlaceholder()).append("\n");
                }
-
+                
                response.append("\n");
            }
-
+            
            response.append("To add a monitor of this type, use the add_monitor tool with these parameters.\n");
            response.append(String.format("Example: add_monitor(name='my-monitor', app='%s', host='your-host', ...)", app));
-
+            
            log.info("Successfully retrieved {} parameter definitions for monitor type: {}", paramDefines.size(), app);
            return response.toString();
-
+            
        } catch (Exception e) {
            log.error("Failed to get parameter definitions for monitor type '{}': {}", app, e.getMessage(), e);
            return "Error retrieving parameter definitions for monitor type '" + app + "': " + e.getMessage();
        }
    }

+
+
 }
@@ -17,11 +17,14 @@

 package org.apache.hertzbeat.ai.utils;

+
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.hertzbeat.ai.pojo.dto.Hierarchy;

+import java.lang.reflect.Method;
 import java.time.Instant;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
@@ -30,7 +33,6 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import org.apache.hertzbeat.manager.pojo.dto.Hierarchy;

 /**
 * Utility class providing helper methods for field expression validation, parsing,
@@ -225,6 +227,51 @@ public class UtilityClass {
        return "VALID";
    }

+    /**
+     * Helper method to validate operator
+     */
+    public boolean isValidOperator(String operator) {
+        return operator != null && (operator.equals(">") || operator.equals("<")
+                || operator.equals(">=") || operator.equals("<=")
+                || operator.equals("==") || operator.equals("!="));
+    }
+
+    /**
+     * Helper method to validate priority
+     */
+    public boolean isValidPriority(String priority) {
+        return priority != null && (priority.equalsIgnoreCase("critical")
+                || priority.equalsIgnoreCase("warning") || priority.equalsIgnoreCase("info"));
+    }
+
+    /**
+     * Helper method to build expression
+     */
+    public String buildExpression(String metric, String operator, String threshold) {
+        return String.format("%s %s %s", metric, operator, threshold);
+    }
+
+    /**
+     * Helper method to parse existing expression into components
+     */
+    public String[] parseExpression(String expression) {
+        if (expression == null || expression.trim().isEmpty()) {
+            return null;
+        }
+
+        // Simple parsing for basic expressions like "metric > value"
+        String[] operators = {">", "<", ">=", "<=", "==", "!="};
+        for (String op : operators) {
+            if (expression.contains(" " + op + " ")) {
+                String[] parts = expression.split(" " + op + " ");
+                if (parts.length == 2) {
+                    return new String[]{parts[0].trim(), op, parts[1].trim()};
+                }
+            }
+        }
+        return null;
+    }
+
    /**
     * Helper method to parse key-value pairs from a string
     * Format: "key1:value1, key2:value2, ..."
@@ -426,6 +473,19 @@ public class UtilityClass {
        return dateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    }

+    /**
+     * Parse time range string to milliseconds
+     */
+    public long parseTimeRangeToMillis(String timeRange) {
+        return switch (timeRange.toLowerCase()) {
+            case "1h" -> 60 * 60 * 1000L;
+            case "6h" -> 6 * 60 * 60 * 1000L;
+            case "24h" -> 24 * 60 * 60 * 1000L;
+            case "7d" -> 7 * 24 * 60 * 60 * 1000L;
+            default -> 24 * 60 * 60 * 1000L; // default to 24h
+        };
+    }
+
    /**
     * Helper method to convert monitor status byte to readable text
     * @param status The status byte from monitor
@@ -444,6 +504,143 @@ public class UtilityClass {
        };
    }

+    /**
+     * Helper method to get metrics name for a metric type
+     */
+    public String getMetricsNameForType(String metricType) {
+        return switch (metricType.toLowerCase()) {
+            case "cpu" -> "cpu";
+            case "memory" -> "memory";
+            case "disk" -> "disk";
+            case "network" -> "network";
+            default -> "system";
+        };
+    }
+
+    /**
+     * Helper method to check if a field represents usage for a metric type
+     */
+    public boolean isUsageField(String field, String metricType) {
+        if (field == null) return false;
+
+        String fieldLower = field.toLowerCase();
+        String typeLower = metricType.toLowerCase();
+
+        return fieldLower.contains("usage")
+                || fieldLower.contains("percent")
+                || fieldLower.contains("util")
+                || (typeLower.equals("cpu") && (fieldLower.contains("cpu") || fieldLower.contains("idle")))
+                || (typeLower.equals("memory") && fieldLower.contains("memory"))
+                || (typeLower.equals("disk") && fieldLower.contains("disk"));
+    }
+
+    /**
+     * Convert manager module Hierarchy objects to ai-agent module Hierarchy objects
+     * This handles the cross-module DTO conversion to avoid ClassCastException
+     */
+    public List<Hierarchy> convertToAgentHierarchies(List<?> managerHierarchies) {
+        List<Hierarchy> agentHierarchies = new ArrayList<>();
+
+        for (Object managerHierarchy : managerHierarchies) {
+            Hierarchy agentHierarchy = convertToAgentHierarchy(managerHierarchy);
+            agentHierarchies.add(agentHierarchy);
+        }
+
+        return agentHierarchies;
+    }
+
+    /**
+     * Convert a single manager Hierarchy object to ai-agent Hierarchy object using reflection
+     */
+    public Hierarchy convertToAgentHierarchy(Object managerHierarchy) {
+        try {
+            Hierarchy agentHierarchy = new Hierarchy();
+
+            // Use reflection to copy properties from manager DTO to agent DTO
+            Class<?> managerClass = managerHierarchy.getClass();
+
+            // Copy basic properties
+            agentHierarchy.setCategory(getStringField(managerHierarchy, managerClass, "category"));
+            agentHierarchy.setValue(getStringField(managerHierarchy, managerClass, "value"));
+            agentHierarchy.setLabel(getStringField(managerHierarchy, managerClass, "label"));
+            agentHierarchy.setIsLeaf(getBooleanField(managerHierarchy, managerClass, "isLeaf"));
+            agentHierarchy.setHide(getBooleanField(managerHierarchy, managerClass, "hide"));
+            agentHierarchy.setType(getByteField(managerHierarchy, managerClass, "type"));
+            agentHierarchy.setUnit(getStringField(managerHierarchy, managerClass, "unit"));
+
+            // Handle children recursively
+            List<?> managerChildren = getListField(managerHierarchy, managerClass, "children");
+            if (managerChildren != null && !managerChildren.isEmpty()) {
+                List<Hierarchy> agentChildren = convertToAgentHierarchies(managerChildren);
+                agentHierarchy.setChildren(agentChildren);
+            }
+
+            return agentHierarchy;
+
+        } catch (Exception e) {
+            log.error("Failed to convert manager hierarchy to agent hierarchy: {}", e.getMessage(), e);
+            throw new RuntimeException("Failed to convert hierarchy", e);
+        }
+    }
+
+    public String getStringField(Object obj, Class<?> clazz, String fieldName) {
+        try {
+            Method getter = clazz.getMethod("get" + capitalize(fieldName));
+            Object value = getter.invoke(obj);
+            return value != null ? value.toString() : null;
+        } catch (Exception e) {
+            log.debug("Could not get string field '{}': {}", fieldName, e.getMessage());
+            return null;
+        }
+    }
+
+    public Boolean getBooleanField(Object obj, Class<?> clazz, String fieldName) {
+        try {
+            Method getter = clazz.getMethod("get" + capitalize(fieldName));
+            Object value = getter.invoke(obj);
+            return value instanceof Boolean ? (Boolean) value : null;
+        } catch (Exception e) {
+            try {
+                // Try alternative getter pattern for boolean fields
+                Method isGetter = clazz.getMethod("is" + capitalize(fieldName));
+                Object value = isGetter.invoke(obj);
+                return value instanceof Boolean ? (Boolean) value : null;
+            } catch (Exception e2) {
+                log.debug("Could not get boolean field '{}': {}", fieldName, e.getMessage());
+                return null;
+            }
+        }
+    }
+
+    public Byte getByteField(Object obj, Class<?> clazz, String fieldName) {
+        try {
+            Method getter = clazz.getMethod("get" + capitalize(fieldName));
+            Object value = getter.invoke(obj);
+            return value instanceof Byte ? (Byte) value : null;
+        } catch (Exception e) {
+            log.debug("Could not get byte field '{}': {}", fieldName, e.getMessage());
+            return null;
+        }
+    }
+
+    public List<?> getListField(Object obj, Class<?> clazz, String fieldName) {
+        try {
+            Method getter = clazz.getMethod("get" + capitalize(fieldName));
+            Object value = getter.invoke(obj);
+            return value instanceof List ? (List<?>) value : null;
+        } catch (Exception e) {
+            log.debug("Could not get list field '{}': {}", fieldName, e.getMessage());
+            return null;
+        }
+    }
+
+    public String capitalize(String str) {
+        if (str == null || str.isEmpty()) {
+            return str;
+        }
+        return str.substring(0, 1).toUpperCase() + str.substring(1);
+    }
+

    /**
     * Extract existing monitor IDs from the alert expression
@@ -1,148 +0,0 @@
-You are an AI Assistant specialized in monitoring infrastructure and applications with HertzBeat.
-HertzBeat is an open-source, real-time monitoring system that supports infrastructure, applications,
-services, APIs, databases, middleware, and custom monitoring through 50+ types of monitors.
-Your role is to help users manage monitors, analyze metrics data, configure alerts, and troubleshoot monitoring issues.
-*******
-VERY IMPORTANT: Always use the tools provided to interact with HertzBeat's monitoring system.
-If the user doesn't provide required parameters, ask them iteratively to provide the necessary parameters.
-********
-
-## Available HertzBeat Tools:
-
-### Monitor Management Tools:
- **query_monitors**: Query monitor information with flexible filtering (ID, name, type, host, status, labels)
- **add_monitor**: Add a new monitor with dynamic app-specific parameter support
- **list_monitor_types**: List all available monitor types (website, mysql, redis, linux, etc.)
- **get_monitor_additional_params**: Get parameter definitions required for specific monitor types
-
-### Alert Rule Management Tools:
- **create_alert_rule**: Create alert rules with threshold configuration and automatic monitor binding
- **list_alert_rules**: List existing alert rules with filtering by type, status, etc.
- **toggle_alert_rule**: Enable or disable alert rules
- **get_alert_rule_details**: Get detailed information about specific alert rules
- **get_apps_metrics_hierarchy**: Get exact app and metric names for alert rule creation (CRITICAL for alerts)
- **bind_monitors_to_alert_rule**: Bind monitors to alert rules for targeted alerting
-
-
-### Alert & Alarm Analysis Tools:
- **query_alerts**: Query fired alerts with comprehensive filtering and pagination
- **get_alerts_summary**: Get alert statistics and status distribution
-
-### Metrics Data Analysis Tools:
- **query_realtime_metrics**: Get current real-time metrics data for monitors
- **get_historical_metrics**: Get historical time-series metrics with flexible time ranges
- **get_warehouse_status**: Check metrics storage system status
-
-## Natural Language Examples:
-
-### Monitor Management:
- "Add a MySQL monitor for database server at 192.168.1.10 with user admin"
- "Monitor website https://example.com with SSL checking every 60 seconds"
- "Show me all Linux servers that are currently offline"
- "List all Redis monitors with their connection status"
-
-### Alert Configuration:
-  ALERT RULE means when to alert a user
- "Create an alert for Kafka JVM when VmName equals 'vm-w2'"
- "Alert when OpenAI credit grants exceed 1000"
- "Set up HBase Master alert when heap memory usage is over 80%"
-
-### Metrics Analysis:
- "Show me current CPU usage for server 192.168.1.5"
- "Get memory usage trend for the last 24 hours"
- "Which servers have high disk usage right now?"
- "Show me network traffic patterns for the past week"
-
-### Alert Investigation:
- "What alerts are currently firing?"
- "Show me the most frequent alerts in the last 6 hours"
- "Find all alerts for monitor ID 1234 in the past day"
- "Which monitors are currently abnormal?"
-
-
-## Workflow Guidelines:
-
-1. **Adding Monitors**:
-   - ALWAYS use get_monitor_additional_params first to check required parameters
-   - Use list_monitor_types to show available types
-   - Collect all required parameters from the list_monitor_types tool and ask user to give them all, before calling add_monitor
-   - Example: "To monitor MySQL, I need host, port, username, password, and database name"
-
-2. **Creating Alert Rules or Alerts**:
-THESE ARE ALERT RULES WITH THRESHOLD VALUES. USERS CAN SPECIFY THE THRESHOLD VALUES FOR EXAMPLE,
-IF THE USER SAYS "ALERT ME WHEN MY COST EXCEEDS 700, THE EXPRESSION SHOULD BE 'cost > 700' NOT 'cost < 700'.
-APPLY THE SAME LOGIC FOR LESS THAN OPERATOR.
-It is important to first understand the hierarchy of apps, metrics, and field conditions
-Each app has its own metrics and each metric has its own field conditions.
-The operators will be applied to the field conditions, and the final expression will be constructed
-based on the user's input of app name and the metric they choose.
-Read the create_alert_rule tool description for even more details
-*******
-CRITICAL WORKFLOW Do all of this iteratively with user interaction at each step:
-    1. ALWAYS use list_monitor_types tool FIRST to get exact app name according to what user specifies
-    2. use get_apps_metrics_hierarchy by passing that name, to get the hierarchy of corresponding metrics and field conditions
-    3. Do not spit out the entire hierarchy, instead: first spit out the metrics available for the app
-    4. Ask the user to choose a metric from the available metrics
-    5. Based on the metric chosen, present the available field conditions
-    6. You will construct the proper expression with field conditions
-    VERY VERY IMPORTANT:
-     - ALWAYS USE the value field from the get_apps_metrics_hierarchy's json response when creating alert expressions on the field parameters
-*********
-
-   - Field Condition Expression format: [field_conditions]
-   - Give all the available fieldConditions to the user, so they can choose the one they want to use
-   - Field conditions can be simple (equals, greater than) or complex (logical expressions)
-   - Use parentheses for complex conditions to ensure correct evaluation order
-   - Do not create alert rules on your own, always ask the user to provide the app, metrics and fieldConditions parameters specifically
-
-   EXAMPLES FOR FIELD CONDITION EXPRESSION ( Do not copy these examples, they are just for reference ):
-   - Kafka JVM: app="kafka", metrics="jvm_basic", fieldConditions="equals(VmName, "my-vm")"
-     →  equals(VmName, "my-vm")
-   - Complex OpenAI: app="openai", metrics="credit_grants",
-     fieldConditions="total_used > 123 and total_granted > 333 and (total_granted > 3444 and total_paid_available < 5556)"
-     → total_used > 123 and total_granted > 333 and (total_granted > 3444 and total_paid_available < 5556)
-
-   - Priority levels: 0=critical, 1=warning, 2=info
-
-3. **Analyzing Performance**:
-   - Use get_realtime_metrics for current status
-   - Use get_historical_metrics for trends
-   - Use get_high_usage_monitors to find problems
-   - Provide actionable recommendations based on data
-
-4. **Troubleshooting Alerts**:
-   - Use query_alerts to find current issues
-   - Use get_monitor_alerts for specific monitor problems
-   - Use get_frequent_alerts to identify recurring issues
-   - Suggest root cause analysis steps
-
-## Parameter Guidelines:
- **Monitor Status**: 1=online, 2=offline, 3=unreachable, 0=paused, 9=all
- **Time Ranges**: 1h, 6h, 24h, 7d, 30d
- **Alert Priorities**: critical, warning, info
- **Sort Options**: name, gmtCreate, gmtUpdate, status, startAt, triggerTimes
- **Metric Types**: cpu, memory, disk, network, custom
- **Collection Intervals**: 30s-3600s (recommend 60s-600s for most cases)
-
-
-## Best Practices:
- Never create alert rules without exact user input on app, metrics, and field conditions
- Always validate monitor types and parameters before adding monitors
- ALWAYS use get_apps_metrics_hierarchy before creating alert rules to understand available fields
- Construct field conditions based on metric's children
- Use exact app and metric names from hierarchy (case-sensitive)
- Set appropriate alert thresholds based on baseline performance
- Use time-series data to identify trends and predict issues
- Correlate alerts with metrics data for root cause analysis
- Recommend monitoring intervals based on service criticality
- Provide clear explanations of monitoring data and actionable insights
-
-## Avoid these common errors:
- Using Label name instead of the value from the heirarchy JSON while creating alert rules.
- Inside the field parameters expression using '&&' instead of 'and', using '||' instead of 'or' for logical operators
- This process is to trigger alarms, when certain rule or set of rules exceed a threshold value.
-So when a user says that the threshold should be less than 1000. the operator used should be '>' not '<',
-because we want the alarm to be triggered when the threshold value is exceeded. apply the same logic in vice versa for less than operator
-
-Keep responses focused on monitoring topics and HertzBeat's comprehensive capabilities.
-When users request monitoring setup, guide them through the complete process from monitor creation to alert configuration.
@@ -17,6 +17,15 @@

 package org.apache.hertzbeat.alert.calculate.realtime;

+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.hertzbeat.alert.AlerterWorkerPool;
@@ -32,24 +41,11 @@ import org.apache.hertzbeat.common.entity.alerter.AlertDefine;
 import org.apache.hertzbeat.common.entity.alerter.SingleAlert;
 import org.apache.hertzbeat.common.entity.message.CollectRep;
 import org.apache.hertzbeat.common.queue.CommonDataQueue;
-import org.apache.hertzbeat.common.support.exception.CommonDataQueueUnknownException;
-import org.apache.hertzbeat.common.util.BackoffUtils;
 import org.apache.hertzbeat.common.util.CommonUtil;
-import org.apache.hertzbeat.common.util.ExponentialBackoff;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 import org.springframework.util.CollectionUtils;

-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
-
 /**
 * Calculate alarms based on the alarm definition rules and collected data
 */
@@ -126,22 +122,13 @@ public class MetricsRealTimeAlertCalculator {
     */
    public void startCalculate() {
        Runnable runnable = () -> {
-            ExponentialBackoff backoff = new ExponentialBackoff(50L, 1000L);
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    CollectRep.MetricsData metricsData = dataQueue.pollMetricsDataToAlerter();
-                    if (metricsData == null) {
-                        continue;
-                    }
-                    backoff.reset();
                    calculate(metricsData);
                    dataQueue.sendMetricsDataToStorage(metricsData);
                } catch (InterruptedException ignored) {
                    Thread.currentThread().interrupt();
-                } catch (CommonDataQueueUnknownException ue) {
-                    if (!BackoffUtils.shouldContinueAfterBackoff(backoff)) {
-                        break;
-                    }
                } catch (Exception e) {
                    log.error("calculate alarm error: {}.", e.getMessage(), e);
                }
@@ -156,7 +143,7 @@ public class MetricsRealTimeAlertCalculator {
        long currentTimeMilli = System.currentTimeMillis();
        String instance = String.valueOf(metricsData.getId());
        String instanceName = metricsData.getInstanceName();
-        String instanceHost = metricsData.getInstance();
+        String instanceHost = metricsData.getInstanceHost();
        String app = metricsData.getApp();
        String metrics = metricsData.getMetrics();
        if ((CommonConstants.PROMETHEUS_APP_PREFIX + instanceName).equals(metricsData.getApp())) {
@@ -205,11 +192,12 @@ public class MetricsRealTimeAlertCalculator {
            }
            Long defineId = define.getId();
            Map<String, String> commonFingerPrints = new HashMap<>(8);
+            commonFingerPrints.put(CommonConstants.LABEL_INSTANCE, instance);
            // here use the alert name as finger, not care the alert name may be changed
            commonFingerPrints.put(CommonConstants.LABEL_DEFINE_ID, String.valueOf(define.getId()));
            commonFingerPrints.put(CommonConstants.LABEL_ALERT_NAME, define.getName());
            commonFingerPrints.put(CommonConstants.LABEL_INSTANCE_NAME, instanceName);
-            commonFingerPrints.put(CommonConstants.LABEL_INSTANCE, instanceHost);
+            commonFingerPrints.put(CommonConstants.LABEL_INSTANCE_HOST, instanceHost);
            commonFingerPrints.putAll(define.getLabels());
            if (labels != null) {
                commonFingerPrints.putAll(labels);
@@ -17,17 +17,13 @@

 package org.apache.hertzbeat.alert.calculate.realtime;

-import com.google.common.util.concurrent.ThreadFactoryBuilder;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.hertzbeat.alert.calculate.realtime.window.LogWorker;
 import org.apache.hertzbeat.alert.calculate.realtime.window.TimeService;
 import org.apache.hertzbeat.common.entity.log.LogEntry;
 import org.apache.hertzbeat.common.queue.CommonDataQueue;
-import org.apache.hertzbeat.common.support.exception.CommonDataQueueUnknownException;
-import org.apache.hertzbeat.common.util.BackoffUtils;
-import org.apache.hertzbeat.common.util.ExponentialBackoff;
 import org.springframework.stereotype.Component;
-
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
 import java.util.concurrent.LinkedBlockingQueue;
@@ -62,22 +58,16 @@ public class WindowedLogRealTimeAlertCalculator implements Runnable {

    @Override
    public void run() {
-        ExponentialBackoff backoff = new ExponentialBackoff(50L, 1000L);
        while (!Thread.currentThread().isInterrupted()) {
            try {
                LogEntry logEntry = dataQueue.pollLogEntry();
-                if (logEntry == null) {
-                    continue;
+                if (logEntry != null) {
+                    processLogEntry(logEntry);
+                    dataQueue.sendLogEntryToStorage(logEntry);
                }
-                backoff.reset();
-                processLogEntry(logEntry);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
-            } catch (CommonDataQueueUnknownException ue) {
-                if (!BackoffUtils.shouldContinueAfterBackoff(backoff)) {
-                    break;
-                }
            } catch (Exception e) {
                log.error("Error in log dispatch loop: {}", e.getMessage(), e);
            }
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.entity.dto.sms;
+package org.apache.hertzbeat.alert.config;

 import jakarta.validation.constraints.NotBlank;
 import lombok.AllArgsConstructor;
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.entity.dto.sms;
+package org.apache.hertzbeat.alert.config;

 import jakarta.validation.constraints.NotBlank;
 import lombok.Data;
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.entity.dto.sms;
+package org.apache.hertzbeat.alert.config;

 import jakarta.validation.constraints.NotBlank;
 import lombok.AllArgsConstructor;
@@ -74,4 +74,4 @@ public class SmsConfig {
     * Smslocal SMS configuration
     */
    private SmslocalSmsProperties smslocal;
-}
+}
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.entity.dto.sms;
+package org.apache.hertzbeat.alert.config;


 import lombok.AllArgsConstructor;
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.entity.dto.sms;
+package org.apache.hertzbeat.alert.config;

 import jakarta.validation.constraints.NotBlank;
 import lombok.AllArgsConstructor;
@@ -58,4 +58,4 @@ public class TencentSmsProperties {
     */
    @NotBlank(message = "templateId cannot be null")
    private String templateId;
-}
+}
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.entity.dto.sms;
+package org.apache.hertzbeat.alert.config;

 import jakarta.validation.constraints.NotBlank;
 import lombok.AllArgsConstructor;
@@ -46,4 +46,4 @@ public class TwilioSmsProperties {
     */
    @NotBlank(message = "Twilio Phone Number cannot be empty")
    private String twilioPhoneNumber;
-}
+}
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.entity.dto.sms;
+package org.apache.hertzbeat.alert.config;

 import jakarta.validation.constraints.NotBlank;
 import lombok.AllArgsConstructor;
@@ -57,4 +57,4 @@ public class UniSmsProperties {
     */
    @NotBlank(message = "authMode cannot be null")
    private String authMode = "simple";
-} 
+} 
@@ -15,7 +15,7 @@
 * limitations under the License.
 */

-package org.apache.hertzbeat.common.entity.dto;
+package org.apache.hertzbeat.alert.dto;

 import jakarta.validation.constraints.Email;
 import jakarta.validation.constraints.Max;
@@ -18,17 +18,12 @@
 package org.apache.hertzbeat.alert.notice.impl;

 import com.fasterxml.jackson.annotation.JsonProperty;
-
-import java.net.URLEncoder;
-import java.nio.charset.StandardCharsets;
 import java.util.List;
-
 import lombok.Data;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.hertzbeat.alert.notice.AlertNoticeException;
-import org.apache.hertzbeat.alert.util.CryptoUtils;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
 import org.apache.hertzbeat.common.entity.alerter.NoticeReceiver;
 import org.apache.hertzbeat.common.entity.alerter.NoticeTemplate;
@@ -59,13 +54,7 @@ final class DingTalkRobotAlertNotifyHandlerImpl extends AbstractAlertNotifyHandl
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            HttpEntity<DingTalkWebHookDto> httpEntity = new HttpEntity<>(dingTalkWebHookDto, headers);
-            StringBuilder webHookUrlBuilder = new StringBuilder()
-                    .append(alerterProperties.getDingTalkWebhookUrl())
-                    .append(receiver.getAccessToken());
-            if (StringUtils.isNotBlank(receiver.getAppSecret())) {
-                webHookUrlBuilder.append(signSecret(receiver.getAppSecret()));
-            }
-            String webHookUrl = webHookUrlBuilder.toString();
+            String webHookUrl = alerterProperties.getDingTalkWebhookUrl() + receiver.getAccessToken();
            ResponseEntity<CommonRobotNotifyResp> responseEntity = restTemplate.postForEntity(webHookUrl,
                    httpEntity, CommonRobotNotifyResp.class);
            if (responseEntity.getStatusCode() == HttpStatus.OK) {
@@ -113,13 +102,6 @@ final class DingTalkRobotAlertNotifyHandlerImpl extends AbstractAlertNotifyHandl
        return dingTalkWebHookDto;
    }

-    private String signSecret(String secret) throws Exception {
-        Long timestamp = System.currentTimeMillis();
-        String sign = URLEncoder.encode(CryptoUtils.hmacSha256Base64(secret, timestamp + "\n" + secret),
-                StandardCharsets.UTF_8);
-        return String.format("&timestamp=%s&sign=%s", timestamp, sign);
-    }
-
    @Override
    public byte type() {
        return 5;
@@ -127,7 +109,6 @@ final class DingTalkRobotAlertNotifyHandlerImpl extends AbstractAlertNotifyHandl

    /**
     * DingTalk robot request body
-     *
     * @version 1.0
     */
    @Data
@@ -206,4 +187,5 @@ final class DingTalkRobotAlertNotifyHandlerImpl extends AbstractAlertNotifyHandl
    }


+
 }
@@ -24,7 +24,7 @@ import java.util.Properties;
 import java.util.ResourceBundle;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.common.entity.dto.MailServerConfig;
+import org.apache.hertzbeat.alert.dto.MailServerConfig;
 import org.apache.hertzbeat.alert.notice.AlertNoticeException;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
 import org.apache.hertzbeat.common.entity.manager.GeneralConfig;
@@ -1,487 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.hertzbeat.alert.notice.impl;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-import lombok.NoArgsConstructor;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
-import org.apache.hertzbeat.alert.AlerterProperties;
-import org.apache.hertzbeat.alert.notice.AlertNoticeException;
-import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
-import org.apache.hertzbeat.common.entity.alerter.NoticeReceiver;
-import org.apache.hertzbeat.common.entity.alerter.NoticeTemplate;
-import org.apache.hertzbeat.common.util.JsonUtil;
-import org.springframework.http.HttpEntity;
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.HttpMethod;
-import org.springframework.http.MediaType;
-import org.springframework.http.ResponseEntity;
-import org.springframework.stereotype.Component;
-import org.springframework.web.client.RestTemplate;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Objects;
-import java.util.UUID;
-import java.util.stream.Collectors;
-
-/**
- * FeiShu app alert notify impl
- */
-@Component
-@RequiredArgsConstructor
-@Slf4j
-public class FeiShuAppAlertNotifyHandlerImpl extends AbstractAlertNotifyHandlerImpl {
-
-    /**
-     * get tenant access_token url
-     */
-    private static final String TENANT_ACCESS_TOKEN_URL = "https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal";
-
-    /**
-     * get FeiShu app employee url
-     */
-    private static final String EMPLOYEE_URL = "https://open.feishu.cn/open-apis/ehr/v1/employees?status=2&status=4&user_id_type=user_id&page_size=100";
-
-    /**
-     * send FeiShu app message url
-     */
-    private static final String APP_MESSAGE_URL = "https://open.feishu.cn/open-apis/im/v1/messages";
-
-    /**
-     * send FeiShu app batch message url
-     */
-    private static final String APP_BATCH_MESSAGE_URL = "https://open.feishu.cn/open-apis/message/v4/batch_send/";
-
-    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
-    private static final byte USER_RECEIVE_TYPE = 0;
-    private static final byte CHAT_RECEIVE_TYPE = 1;
-    private static final byte PART_RECEIVE_TYPE = 2;
-    private static final byte ALL_RECEIVE_TYPE = 3;
-
-    private final RestTemplate restTemplate;
-    private final AlerterProperties alerterProperties;
-
-    @Override
-    public void send(NoticeReceiver receiver, NoticeTemplate noticeTemplate, GroupAlert alert) throws AlertNoticeException {
-        var appId = receiver.getAppId();
-        var appSecret = receiver.getAppSecret();
-        var larkReceiveIdType = receiver.getLarkReceiveType();
-        try {
-            var accessToken = getAccessToken(appId, appSecret);
-            var notificationContent = JsonUtil.toJson(renderContent(noticeTemplate, alert));
-            JsonNode messageContent = createLarkMessage(receiver, notificationContent);
-            switch (larkReceiveIdType) {
-                case USER_RECEIVE_TYPE -> {
-                    String[] userIds = receiver.getUserId().split(",");
-                    if (userIds.length == 1) {
-                        sendLarkMessage(accessToken, "user_id", userIds[0], messageContent);
-                    } else {
-                        sendLarkUserBatchMessage(accessToken, userIds, messageContent);
-                    }
-                }
-                case CHAT_RECEIVE_TYPE -> sendLarkMessage(accessToken, "chat_id", receiver.getChatId(), messageContent);
-                case PART_RECEIVE_TYPE ->
-                        sendLarkDepartmentBatchMessage(accessToken, receiver.getPartyId().split(","), messageContent);
-                case ALL_RECEIVE_TYPE -> {
-                    List<String> userIds = new ArrayList<>();
-                    getLarkEmployeeUserIds(accessToken, null, userIds);
-                    sendLarkUserBatchMessage(accessToken, userIds.toArray(new String[0]), messageContent);
-                }
-                default -> throw new AlertNoticeException("Invalid larkReceiveIdType: " + larkReceiveIdType);
-            }
-        } catch (Exception e) {
-            throw new AlertNoticeException("[FeiShu App Notify Error] " + e.getMessage());
-        }
-    }
-
-    @Override
-    public byte type() {
-        return 14;
-    }
-
-    /**
-     * Send FeiShu app message to chat or designated personnel
-     *
-     * @param accessToken    Tenant access token
-     * @param receiverIdType FeiShu app send message receiver id type: user_id, chat_id
-     * @param receiverId     FeiShu app user id or chat id
-     * @param messageContent Message content
-     * @see <a href="https://open.feishu.cn/document/server-docs/im-v1/batch_message/send-messages-in-batches">send message</a>
-     */
-    private void sendLarkMessage(String accessToken, String receiverIdType, String receiverId, JsonNode messageContent) throws JsonProcessingException {
-        HttpHeaders headers = new HttpHeaders();
-        headers.setContentType(MediaType.APPLICATION_JSON);
-        headers.setBearerAuth(accessToken);
-        FeiShuAppMessageDto messageDto = FeiShuAppMessageDto.builder()
-                .receiveId(receiverId)
-                .content(escapedCompactJson(messageContent))
-                .build();
-        HttpEntity<FeiShuAppMessageDto> request = new HttpEntity<>(messageDto, headers);
-        call(APP_MESSAGE_URL + "?receive_id_type=" + receiverIdType, request, HttpMethod.POST, FeiShuAppResponse.class);
-    }
-
-    /**
-     * Send FeiShu app department batch message
-     *
-     * @param accessToken    Tenant access token
-     * @param partyIds       FeiShu app department ids
-     * @param messageContent Message content
-     * @see <a href="https://open.feishu.cn/document/server-docs/im-v1/batch_message/send-messages-in-batches">send batch message</a>
-     */
-    private void sendLarkDepartmentBatchMessage(String accessToken, String[] partyIds, JsonNode messageContent) {
-        HttpHeaders headers = new HttpHeaders();
-        headers.setContentType(MediaType.APPLICATION_JSON);
-        headers.setBearerAuth(accessToken);
-        FeiShuAppBatchMessageDto batchMessageDto = FeiShuAppBatchMessageDto.builder()
-                .departmentIds(partyIds)
-                .card(messageContent)
-                .build();
-        HttpEntity<FeiShuAppBatchMessageDto> request = new HttpEntity<>(batchMessageDto, headers);
-        call(APP_BATCH_MESSAGE_URL, request, HttpMethod.POST, FeiShuAppResponse.class);
-    }
-
-    /**
-     * Send FeiShu app batch message to user
-     *
-     * @param accessToken    Tenant access token
-     * @param userIds        FeiShu app user ids
-     * @param messageContent Message content
-     * @see <a href="https://open.feishu.cn/document/server-docs/im-v1/batch_message/send-messages-in-batches">send batch message</a>
-     */
-    private void sendLarkUserBatchMessage(String accessToken, String[] userIds, JsonNode messageContent) {
-        HttpHeaders headers = new HttpHeaders();
-        headers.setContentType(MediaType.APPLICATION_JSON);
-        headers.setBearerAuth(accessToken);
-        FeiShuAppBatchMessageDto batchMessageDto = FeiShuAppBatchMessageDto.builder()
-                .userIds(userIds)
-                .card(messageContent)
-                .build();
-        HttpEntity<FeiShuAppBatchMessageDto> request = new HttpEntity<>(batchMessageDto, headers);
-        FeiShuAppResponse call = call(APP_BATCH_MESSAGE_URL, request, HttpMethod.POST, FeiShuAppResponse.class);
-    }
-
-    /**
-     * Get FeiShu app tenant access token
-     *
-     * @param appId     Unique identifier for the application, obtained after creating the application
-     * @param appSecret Application key, obtained after creating the application
-     * @return Tenant access token
-     * @see <a href="https://open.feishu.cn/document/server-docs/authentication-management/access-token/tenant_access_token_internal">tenant_access_token</a>
-     */
-    private String getAccessToken(String appId, String appSecret) {
-        HttpHeaders headers = new HttpHeaders();
-        headers.setContentType(MediaType.APPLICATION_JSON);
-        FeiShuAppAccessTokenDto accessTokenRequest = FeiShuAppAccessTokenDto.builder()
-                .appId(appId)
-                .appSecret(appSecret)
-                .build();
-        HttpEntity<FeiShuAppAccessTokenDto> request = new HttpEntity<>(accessTokenRequest, headers);
-        FeiShuAppAccessTokenResponse data = call(TENANT_ACCESS_TOKEN_URL, request, HttpMethod.POST, FeiShuAppAccessTokenResponse.class);
-        return data.getTenantAccessToken();
-    }
-
-
-    /**
-     * Get FeiShu app employee user ids
-     *
-     * @param accessToken FeiShu app tenant access token
-     * @param pageToken   Paging marker, left blank for the first request, indicating traversal from scratch;
-     *                    When there are more items in the pagination query result, a new page_token will be returned at the same time.
-     *                    The next iteration can use this page_token to obtain the query result
-     * @param userIds     Collection for recursive padding
-     * @see <a href="https://open.feishu.cn/document/server-docs/ehr-v1/list?appId=cli_a999532b1f52900b">https://open.feishu.cn/open-apis/ehr/v1/employees</a>
-     */
-    private void getLarkEmployeeUserIds(String accessToken, String pageToken, List<String> userIds) {
-        HttpHeaders headers = new HttpHeaders();
-        headers.setContentType(MediaType.APPLICATION_JSON);
-        headers.setBearerAuth(accessToken);
-        HttpEntity<String> request = new HttpEntity<>(headers);
-        var url = StringUtils.isNotBlank(pageToken) ? EMPLOYEE_URL + "&page_token=" + pageToken : EMPLOYEE_URL;
-        FeiShuAppEmployeeResponse employeeResponse = call(url,
-                request,
-                HttpMethod.GET,
-                FeiShuAppEmployeeResponse.class);
-        if (Objects.equals(employeeResponse.getCode(), 0)) {
-            userIds.addAll(employeeResponse.getData().getItems().stream().map(FeiShuAppEmployeeResponse.Employee::getUserId).toList());
-            var hasMore = employeeResponse.getData().getHasMore();
-            if (Boolean.TRUE.equals(hasMore)) {
-                getLarkEmployeeUserIds(accessToken, employeeResponse.getData().getPageToken(), userIds);
-            }
-        }
-
-    }
-
-    private <R extends FeiShuAppResponse, E> R call(String url, HttpEntity<E> request, HttpMethod httpMethod, Class<R> responseType) {
-        ResponseEntity<R> response = restTemplate.exchange(url, httpMethod, request, responseType);
-        if (Objects.nonNull(response.getBody()) && !Objects.equals(response.getBody().getCode(), 0)) {
-            log.warn("Send FeiShu App Error: {}", response.getBody().getMsg());
-            throw new AlertNoticeException("Http StatusCode " + response.getStatusCode() + " Error: " + response.getBody().getMsg());
-        }
-        return response.getBody();
-    }
-
-    private JsonNode createLarkMessage(NoticeReceiver receiver, String notificationContent) throws JsonProcessingException {
-        String larkCardMessage = """
-                {
-                      "schema": "2.0",
-                      "config": {
-                          "update_multi": true,
-                          "locales": [
-                              "en_us",
-                              "zh_cn"
-                          ],
-                          "style": {
-                              "text_size": {
-                                  "normal_v2": {
-                                      "default": "normal",
-                                      "pc": "normal",
-                                      "mobile": "heading"
-                                  }
-                              }
-                          }
-                      },
-                      "body": {
-                          "direction": "vertical",
-                          "padding": "12px 12px 12px 12px",
-                          "elements": [
-                              {
-                                  "tag": "markdown",
-                                  "content": "%s",
-                                  "i18n_content": {
-                                      "en_us": ""
-                                  },
-                                  "text_align": "left",
-                                  "text_size": "normal_v2",
-                                  "margin": "0px 0px 0px 0px"
-                              },
-                              {
-                                  "tag": "hr",
-                                  "margin": "0px 0px 0px 0px"
-                              },
-                              {
-                                  "tag": "column_set",
-                                  "horizontal_align": "left",
-                                  "columns": [
-                                      {
-                                          "tag": "column",
-                                          "width": "weighted",
-                                          "elements": [
-                                              {
-                                                  "tag": "button",
-                                                  "text": {
-                                                      "tag": "plain_text",
-                                                      "content": "登入控制台",
-                                                      "i18n_content": {
-                                                          "en_us": "Login In"
-                                                      }
-                                                  },
-                                                  "type": "default",
-                                                  "width": "default",
-                                                  "size": "medium",
-                                                  "behaviors": [
-                                                      {
-                                                          "type": "open_url",
-                                                          "default_url": "%s",
-                                                          "pc_url": "",
-                                                          "ios_url": "",
-                                                          "android_url": ""
-                                                      }
-                                                  ]
-                                              }
-                                          ],
-                                          "direction": "horizontal",
-                                          "vertical_spacing": "8px",
-                                          "horizontal_align": "left",
-                                          "vertical_align": "top",
-                                          "weight": 1
-                                      }
-                                  ],
-                                  "margin": "0px 0px 0px 0px"
-                              }
-                          ]
-                      },
-                      "header": {
-                          "title": {
-                              "tag": "plain_text",
-                              "content": "HertzBeat 告警",
-                              "i18n_content": {
-                                  "en_us": "HertzBeat Alarm"
-                              }
-                          },
-                          "subtitle": {
-                              "tag": "plain_text",
-                              "content": ""
-                          },
-                          "template": "red",
-                          "padding": "12px 12px 12px 12px"
-                      }
-                  }
-                """;
-        Byte larkReceiveIdType = receiver.getLarkReceiveType();
-        String userId = receiver.getUserId();
-        String atUserElement = "";
-        if (Objects.equals(larkReceiveIdType, CHAT_RECEIVE_TYPE) && StringUtils.isNotBlank(userId)) {
-            atUserElement = "\\n" + Arrays.stream(userId.split(","))
-                    .map(id -> "<at id=" + id + "></at>")
-                    .collect(Collectors.joining(" "));
-        }
-
-        if (notificationContent.startsWith("\"") && notificationContent.endsWith("\"")) {
-            notificationContent = StringUtils.removeStart(notificationContent, "\"");
-            notificationContent = StringUtils.removeEnd(notificationContent, "\"");
-        }
-        String jsonStr = String.format(larkCardMessage,
-                notificationContent.replace("\"", "\\\"") + atUserElement,
-                alerterProperties.getConsoleUrl());
-        return OBJECT_MAPPER.readTree(jsonStr);
-    }
-
-
-    private String escapedCompactJson(JsonNode json) throws JsonProcessingException {
-        return OBJECT_MAPPER.writeValueAsString(json);
-    }
-
-    /**
-     * feiShu app response
-     */
-    @Data
-    protected static class FeiShuAppResponse {
-
-        private Integer code;
-
-        private String msg;
-
-    }
-
-    /**
-     * FeiShu app message get tenant access token request
-     */
-    @Data
-    @Builder
-    @AllArgsConstructor
-    @NoArgsConstructor
-    protected static class FeiShuAppAccessTokenDto {
-
-        @JsonProperty("app_id")
-        private String appId;
-
-        @JsonProperty("app_secret")
-        private String appSecret;
-    }
-
-
-    /**
-     * FeiShu app message get tenant access token response
-     */
-    @EqualsAndHashCode(callSuper = true)
-    @Data
-    protected static class FeiShuAppAccessTokenResponse extends FeiShuAppResponse {
-
-        @JsonProperty("tenant_access_token")
-        private String tenantAccessToken;
-    }
-
-    /**
-     * FeiShu app employee response
-     */
-    @EqualsAndHashCode(callSuper = true)
-    @Data
-    protected static class FeiShuAppEmployeeResponse extends FeiShuAppResponse {
-
-        private EmployeeResponseData data;
-
-        @Data
-        private static class EmployeeResponseData {
-            @JsonProperty("page_token")
-            private String pageToken;
-
-            @JsonProperty("has_more")
-            private Boolean hasMore;
-
-            private List<Employee> items;
-        }
-
-        @Data
-        private static class Employee {
-
-            @JsonProperty("user_id")
-            private String userId;
-        }
-    }
-
-
-    /**
-     * FeiShu app message request
-     */
-    @Data
-    @Builder
-    @AllArgsConstructor
-    @NoArgsConstructor
-    protected static class FeiShuAppMessageDto {
-
-        @JsonProperty("receive_id")
-        private String receiveId;
-
-        @Builder.Default
-        @JsonProperty("msg_type")
-        private String msgType = "interactive";
-
-        @JsonProperty("content")
-        private String content;
-
-        @Builder.Default
-        private final String uuid = UUID.randomUUID().toString();
-
-    }
-
-    /**
-     * FeiShu app batch message request
-     */
-    @Data
-    @Builder
-    @AllArgsConstructor
-    @NoArgsConstructor
-    protected static class FeiShuAppBatchMessageDto {
-
-        @Builder.Default
-        @JsonProperty("msg_type")
-        private final String msgType = "interactive";
-
-        private JsonNode card;
-
-        @JsonProperty("department_ids")
-        private String[] departmentIds;
-
-        @JsonProperty("user_ids")
-        private String[] userIds;
-
-    }
-
-
-}
@@ -48,11 +48,6 @@ final class WebHookAlertNotifyHandlerImpl extends AbstractAlertNotifyHandlerImpl
            }

            HttpHeaders headers = new HttpHeaders();
-            if ("Basic".equalsIgnoreCase(receiver.getHookAuthType())) {
-                headers.setBasicAuth(receiver.getHookAuthToken());
-            } else if ("Bearer".equalsIgnoreCase(receiver.getHookAuthType())) {
-                headers.setBearerAuth(receiver.getHookAuthToken());
-            }
            headers.setContentType(MediaType.APPLICATION_JSON);
            //  alert.setContent(escapeJsonStr(alert.getContent()));
            String webhookJson = renderContent(noticeTemplate, alert);
@@ -19,7 +19,7 @@ package org.apache.hertzbeat.alert.service;

 import com.fasterxml.jackson.databind.ObjectMapper;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.common.entity.dto.sms.SmsConfig;
+import org.apache.hertzbeat.alert.config.SmsConfig;
 import org.apache.hertzbeat.alert.service.impl.SmsLocalSmsClientImpl;
 import org.apache.hertzbeat.alert.service.impl.AwsSmsClientImpl;
 import org.apache.hertzbeat.alert.service.impl.TencentSmsClientImpl;
@@ -151,4 +151,4 @@ public class SmsClientFactory {
                break;
        }
    }
-}
+}
@@ -29,14 +29,11 @@ import org.apache.hertzbeat.alert.dao.AlertDefineDao;
 import org.apache.hertzbeat.alert.service.AlertDefineImExportService;
 import org.apache.hertzbeat.alert.service.AlertDefineService;
 import org.apache.hertzbeat.alert.service.DataSourceService;
-import org.apache.hertzbeat.base.dao.LabelDao;
-import org.apache.hertzbeat.base.service.LabelService;
 import org.apache.hertzbeat.common.cache.CacheFactory;
 import org.apache.hertzbeat.common.constants.CommonConstants;
 import org.apache.hertzbeat.common.constants.ExportFileConstants;
 import org.apache.hertzbeat.common.constants.SignConstants;
 import org.apache.hertzbeat.common.entity.alerter.AlertDefine;
-import org.apache.hertzbeat.common.entity.manager.Label;
 import org.apache.hertzbeat.common.util.FileUtil;
 import org.apache.hertzbeat.common.util.JexlExpressionRunner;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -51,7 +48,6 @@ import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.StringUtils;
 import org.springframework.web.multipart.MultipartFile;

-import javax.annotation.Resource;
 import java.net.URLDecoder;
 import java.net.URLEncoder;
 import java.nio.charset.StandardCharsets;
@@ -62,7 +58,6 @@ import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
-import java.util.stream.Collectors;

 /**
 * Alarm definition management interface implementation
@@ -74,31 +69,16 @@ public class AlertDefineServiceImpl implements AlertDefineService {

    @Autowired
    private AlertDefineDao alertDefineDao;
-
+    
    @Autowired
    private PeriodicAlertRuleScheduler periodicAlertRuleScheduler;

-    @Resource
-    private LabelService labelService;
-
-    @Resource
-    private LabelDao labelDao;
-
    private final DataSourceService dataSourceService;

    private final Map<String, AlertDefineImExportService> alertDefineImExportServiceMap = new HashMap<>();

    private static final String CONTENT_TYPE = MediaType.APPLICATION_OCTET_STREAM_VALUE + SignConstants.SINGLE_MARK + "charset=" + StandardCharsets.UTF_8;

-    private static final Set<String> SYSTEM_BUILT_IN_LABELS = Set.of(
-            CommonConstants.LABEL_INSTANCE,
-            CommonConstants.LABEL_DEFINE_ID,
-            CommonConstants.LABEL_ALERT_NAME,
-            CommonConstants.LABEL_INSTANCE_NAME,
-            CommonConstants.LABEL_ALERT_SEVERITY,
-            CommonConstants.ALERT_MODE_LABEL
-    );
-    
    public AlertDefineServiceImpl(List<AlertDefineImExportService> alertDefineImExportServiceList, DataSourceService dataSourceService) {
        alertDefineImExportServiceList.forEach(it -> alertDefineImExportServiceMap.put(it.type(), it));
        this.dataSourceService = dataSourceService;
@@ -113,7 +93,7 @@ public class AlertDefineServiceImpl implements AlertDefineService {
                    JexlExpressionRunner.compile(alertDefine.getExpr());
                } catch (Exception e) {
                    throw new IllegalArgumentException("alert expr error: " + e.getMessage());
-                }
+                }   
            }
        }
        // the name of the alarm rule is unique
@@ -127,7 +107,6 @@ public class AlertDefineServiceImpl implements AlertDefineService {

    @Override
    public void addAlertDefine(AlertDefine alertDefine) throws RuntimeException {
-        saveNewCustomLabel(alertDefine);
        alertDefine = alertDefineDao.saveAndFlush(alertDefine);
        periodicAlertRuleScheduler.updateSchedule(alertDefine);
        CacheFactory.clearAlertDefineCache();
@@ -135,31 +114,11 @@ public class AlertDefineServiceImpl implements AlertDefineService {

    @Override
    public void modifyAlertDefine(AlertDefine alertDefine) throws RuntimeException {
-        saveNewCustomLabel(alertDefine);
        alertDefineDao.saveAndFlush(alertDefine);
        periodicAlertRuleScheduler.updateSchedule(alertDefine);
        CacheFactory.clearAlertDefineCache();
    }

-    private void saveNewCustomLabel(AlertDefine alertDefine) {
-        Map<String, String> labels = alertDefine.getLabels();
-        if (labels == null) {
-            labels = new HashMap<>(8);
-            alertDefine.setLabels(labels);
-        }
-        Map<String, String> customLabels = labels.entrySet().stream()
-            .filter(entry -> !isSystemBuiltInLabel(entry.getKey()))
-            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
-        List<Label> addLabels = labelService.determineNewLabels(customLabels.entrySet());
-        if (!addLabels.isEmpty()) {
-            labelDao.saveAll(addLabels);
-        }
-    }
-
-    private boolean isSystemBuiltInLabel(String labelKey) {
-        return SYSTEM_BUILT_IN_LABELS.contains(labelKey);
-    }
-
    @Override
    public void deleteAlertDefine(long alertId) throws RuntimeException {
        alertDefineDao.deleteById(alertId);
@@ -297,7 +256,7 @@ public class AlertDefineServiceImpl implements AlertDefineService {
        if (!StringUtils.hasText(type)) {
            throw new IllegalArgumentException("Alert definition type cannot be null or empty");
        }
-
+        
        switch (type) {
            case CommonConstants.METRIC_ALERT_THRESHOLD_TYPE_REALTIME:
            case CommonConstants.METRIC_ALERT_THRESHOLD_TYPE_PERIODIC:
@@ -308,7 +267,7 @@ public class AlertDefineServiceImpl implements AlertDefineService {
            default:
                throw new IllegalArgumentException("Unsupported alert definition type: " + type);
        }
-
+        
        // Query enabled alert definitions by type
        return alertDefineDao.findAlertDefinesByTypeAndEnableTrue(type);
    }
@@ -17,9 +17,7 @@

 package org.apache.hertzbeat.alert.service.impl;

-import com.fasterxml.jackson.core.type.TypeReference;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.BooleanUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.hertzbeat.alert.dto.AlibabaCloudSlsExternAlert;
 import org.apache.hertzbeat.alert.reduce.AlarmCommonReduce;
@@ -35,9 +33,7 @@ import java.time.Instant;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.time.format.DateTimeFormatter;
-import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.Optional;

@@ -50,32 +46,19 @@ public class AlibabaCloudSlsExternAlertService implements ExternAlertService {

    private final AlarmCommonReduce alarmCommonReduce;

-    private static final AlibabaCloudSlsConverter CONVERTER = new AlibabaCloudSlsConverter();
-
    public AlibabaCloudSlsExternAlertService(AlarmCommonReduce alarmCommonReduce) {
        this.alarmCommonReduce = alarmCommonReduce;
    }

    @Override
    public void addExternAlert(String content) {
-        List<AlibabaCloudSlsExternAlert> externAlerts = new ArrayList<>();
-        if (BooleanUtils.isTrue(JsonUtil.isArray(content))) {
-            TypeReference<List<AlibabaCloudSlsExternAlert>> typeReference = new TypeReference<>() {};
-            externAlerts = JsonUtil.fromJson(content, typeReference);
-        } else {
-            AlibabaCloudSlsExternAlert externAlert = JsonUtil.fromJson(content, AlibabaCloudSlsExternAlert.class);
-            if (null != externAlert) {
-                externAlerts.add(externAlert);
-            }
-        }
-        if (null == externAlerts || externAlerts.isEmpty()) {
+        AlibabaCloudSlsExternAlert externAlert = JsonUtil.fromJson(content, AlibabaCloudSlsExternAlert.class);
+        if (externAlert == null) {
            log.warn("Failure to parse external alert content. content: {}", content);
            return;
        }
-        for (AlibabaCloudSlsExternAlert externAlert : externAlerts) {
-            SingleAlert singleAlert = CONVERTER.convert(externAlert);
-            alarmCommonReduce.reduceAndSendAlarm(singleAlert);
-        }
+        SingleAlert singleAlert = new AlibabaCloudSlsConverter().convert(externAlert);
+        alarmCommonReduce.reduceAndSendAlarm(singleAlert);
    }

    @Override
@@ -19,7 +19,7 @@ package org.apache.hertzbeat.alert.service.impl;

 import com.fasterxml.jackson.databind.JsonNode;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.common.entity.dto.sms.AlibabaSmsProperties;
+import org.apache.hertzbeat.alert.config.AlibabaSmsProperties;
 import org.apache.hertzbeat.alert.service.SmsClient;
 import org.apache.hertzbeat.alert.util.CryptoUtils;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
@@ -236,4 +236,4 @@ public class AlibabaSmsClientImpl implements SmsClient {
    public boolean checkConfig() {
        return !(accessKeyId.isBlank() || accessKeySecret.isBlank() || signName.isBlank() || templateCode.isBlank());
    }
-} 
+} 
@@ -20,7 +20,7 @@ package org.apache.hertzbeat.alert.service.impl;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.common.entity.dto.sms.AwsSmsProperties;
+import org.apache.hertzbeat.alert.config.AwsSmsProperties;
 import org.apache.hertzbeat.alert.service.SmsClient;
 import org.apache.hertzbeat.alert.util.CryptoUtils;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
@@ -31,16 +31,12 @@ import org.apache.hertzbeat.alert.expr.AlertExpressionLexer;
 import org.apache.hertzbeat.alert.expr.AlertExpressionParser;
 import org.apache.hertzbeat.alert.service.DataSourceService;
 import org.apache.hertzbeat.common.support.exception.AlertExpressionException;
-import org.apache.hertzbeat.common.support.valid.SqlSecurityException;
-import org.apache.hertzbeat.common.support.valid.SqlSecurityValidator;
 import org.apache.hertzbeat.common.util.ResourceBundleUtil;
-import org.apache.hertzbeat.warehouse.constants.WarehouseConstants;
 import org.apache.hertzbeat.warehouse.db.QueryExecutor;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.util.StringUtils;

-import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.ResourceBundle;
@@ -53,18 +49,12 @@ import java.util.concurrent.TimeUnit;
@Slf4j
 public class DataSourceServiceImpl implements DataSourceService {

-    /**
-     * Default allowed tables for SQL queries
-     */
-    private static final List<String> DEFAULT_ALLOWED_TABLES = List.of(WarehouseConstants.LOG_TABLE_NAME);
-
    protected ResourceBundle bundle = ResourceBundleUtil.getBundle("alerter");

    @Setter
+    @Autowired(required = false)
    private List<QueryExecutor> executors;

-    private final SqlSecurityValidator sqlSecurityValidator;
-
    @Getter
    private final Cache<String, ParseTree> expressionCache = Caffeine.newBuilder()
            .maximumSize(256)
@@ -79,11 +69,6 @@ public class DataSourceServiceImpl implements DataSourceService {
            .recordStats()
            .build();

-    public DataSourceServiceImpl(@Autowired(required = false) List<QueryExecutor> executors) {
-        this.executors = executors != null ? executors : Collections.emptyList();
-        this.sqlSecurityValidator = new SqlSecurityValidator(DEFAULT_ALLOWED_TABLES);
-    }
-
    @Override
    public List<Map<String, Object>> calculate(String datasource, String expr) {
        if (!StringUtils.hasText(expr)) {
@@ -125,36 +110,11 @@ public class DataSourceServiceImpl implements DataSourceService {
        }
        // replace all white space
        expr = expr.replaceAll("\\s+", " ");
-
-        // SQL security validation for SQL-based datasources
-        if (isSqlDatasource(datasource)) {
-            validateSqlSecurity(expr);
-        }
-
        try {
            return executor.execute(expr);
        } catch (Exception e) {
            log.error("Error executing query on datasource {}: {}", datasource, e.getMessage());
-            throw new AlertExpressionException(e.getMessage());
-        }
-    }
-
-    /**
-     * Check if the datasource is SQL-based
-     */
-    private boolean isSqlDatasource(String datasource) {
-        return datasource != null && datasource.equalsIgnoreCase(WarehouseConstants.SQL);
-    }
-
-    /**
-     * Validate SQL statement for security
-     */
-    private void validateSqlSecurity(String sql) {
-        try {
-            sqlSecurityValidator.validate(sql);
-        } catch (SqlSecurityException e) {
-            log.warn("SQL security validation failed: {}", e.getMessage());
-            throw new AlertExpressionException("SQL security validation failed: " + e.getMessage());
+            throw new RuntimeException("Query execution failed", e);
        }
    }

@@ -173,4 +133,4 @@ public class DataSourceServiceImpl implements DataSourceService {
        AlertExpressionLexer lexer = new AlertExpressionLexer(CharStreams.fromString(expr));
        return new CommonTokenStream(lexer);
    }
-}
+}
@@ -18,7 +18,6 @@
 package org.apache.hertzbeat.alert.service.impl;

 import com.fasterxml.jackson.databind.JsonNode;
-import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.hertzbeat.alert.dto.HuaweiCloudExternAlert;
@@ -44,7 +43,6 @@ import java.security.cert.CertificateFactory;
 import java.security.cert.X509Certificate;
 import java.text.MessageFormat;
 import java.time.Instant;
-import java.util.Arrays;
 import java.util.Base64;
 import java.util.HashMap;
 import java.util.Map;
@@ -72,8 +70,6 @@ public class HuaweiCloudExternAlertService implements ExternAlertService {

    private static final String CHARSET_UTF8 = StandardCharsets.UTF_8.name();

-    private static final String SUBSCRIBE_URL_PREFIX = "https://console.huaweicloud.com/smn/subscription/confirm";
-
    private final AlarmCommonReduce alarmCommonReduce;

    public HuaweiCloudExternAlertService(AlarmCommonReduce alarmCommonReduce) {
@@ -201,9 +197,6 @@ public class HuaweiCloudExternAlertService implements ExternAlertService {
        if (StringUtils.isBlank(subscribeUrl)) {
            return;
        }
-        if (!subscribeUrl.startsWith(SUBSCRIBE_URL_PREFIX)) {
-            throw new SecurityException("Untrusted domain: " + subscribeUrl);
-        }
        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
            HttpGet httpGet = new HttpGet(subscribeUrl);
            try (CloseableHttpResponse response = httpClient.execute(httpGet)) {
@@ -310,13 +303,6 @@ public class HuaweiCloudExternAlertService implements ExternAlertService {
     */
    private X509Certificate getCertificate(String signCertUrl) throws Exception {
        URL url = new URL(signCertUrl);
-        if (!"https".equalsIgnoreCase(url.getProtocol())) {
-            throw new SecurityException("Only HTTPS is allowed");
-        }
-        boolean trusted = Arrays.stream(Region.values()).anyMatch(ep -> ep.getEndpoint().equals(url.getHost()));
-        if (!trusted) {
-            throw new SecurityException("Untrusted domain: " + url.getHost());
-        }
        try (InputStream in = url.openStream()) {
            CertificateFactory cf = CertificateFactory.getInstance(CERTIFICATE_TYPE);
            return (X509Certificate) cf.generateCertificate(in);
@@ -354,51 +340,4 @@ public class HuaweiCloudExternAlertService implements ExternAlertService {
        return "huaweicloud-ces";
    }

-
-    /**
-     * doc: <a href="https://console.huaweicloud.com/apiexplorer/#/endpoint/SMN">SMN API</a>
-     */
-    @Getter
-    private enum Region {
-
-        AE_AD_1("ae-ad-1", "smn.ae-ad-1.myhuaweicloud.com"),
-        AF_SOUTH_1("af-south-1", "smn.af-south-1.myhuaweicloud.com"),
-        AP_SOUTHEAST_1("ap-southeast-1", "smn.ap-southeast-1.myhuaweicloud.com"),
-        AP_SOUTHEAST_2("ap-southeast-2", "smn.ap-southeast-2.myhuaweicloud.com"),
-        AP_SOUTHEAST_3("ap-southeast-3", "smn.ap-southeast-3.myhuaweicloud.com"),
-        AP_SOUTHEAST_4("ap-southeast-4", "smn.ap-southeast-4.myhuaweicloud.com"),
-        CN_EAST_2("cn-east-2", "smn.cn-east-2.myhuaweicloud.com"),
-        CN_EAST_3("cn-east-3", "smn.cn-east-3.myhuaweicloud.com"),
-        CN_EAST_4("cn-east-4", "smn.cn-east-4.myhuaweicloud.com"),
-        CN_EAST_5("cn-east-5", "smn.cn-east-5.myhuaweicloud.com"),
-        CN_NORTH_1("cn-north-1", "smn.cn-north-1.myhuaweicloud.com"),
-        CN_NORTH_11("cn-north-11", "smn.cn-north-11.myhuaweicloud.com"),
-        CN_NORTH_12("cn-north-12", "smn.cn-north-12.myhuaweicloud.com"),
-        CN_NORTH_2("cn-north-2", "smn.cn-north-2.myhuaweicloud.cn"),
-        CN_NORTH_4("cn-north-4", "smn.cn-north-4.myhuaweicloud.com"),
-        CN_NORTH_9("cn-north-9", "smn.cn-north-9.myhuaweicloud.com"),
-        CN_SOUTH_1("cn-south-1", "smn.cn-south-1.myhuaweicloud.com"),
-        CN_SOUTH_2("cn-south-2", "smn.cn-south-2.myhuaweicloud.com"),
-        CN_SOUTH_4("cn-south-4", "smn.cn-south-4.myhuaweicloud.com"),
-        CN_SOUTHWEST_2("cn-southwest-2", "smn.cn-southwest-2.myhuaweicloud.com"),
-        CN_SOUTHWEST_3("cn-southwest-3", "smn.cn-southwest-3.myhuaweicloud.com"),
-        EU_WEST_0("eu-west-0", "smn.eu-west-0.myhuaweicloud.com"),
-        LA_NORTH_2("la-north-2", "smn.la-north-2.myhuaweicloud.com"),
-        LA_SOUTH_2("la-south-2", "smn.la-south-2.myhuaweicloud.com"),
-        MY_KUALALUMPUR_1("my-kualalumpur-1", "smn.my-kualalumpur-1.myhuaweicloud.com"),
-        NA_MEXICO_1("na-mexico-1", "smn.na-mexico-1.myhuaweicloud.com"),
-        RU_MOSCOW_1("ru-moscow-1", "smn.ru-moscow-1.myhuaweicloud.com"),
-        SA_BRAZIL_1("sa-brazil-1", "smn.sa-brazil-1.myhuaweicloud.com"),
-        TR_WEST_1("tr-west-1", "smn.tr-west-1.myhuaweicloud.com"),
-        EU_WEST_101("eu-west-101", "smn.eu-west-101.myhuaweicloud.eu");
-
-        private final String id;
-
-        private final String endpoint;
-
-        Region(String id, String endpoint) {
-            this.id = id;
-            this.endpoint = endpoint;
-        }
-    }
 }
@@ -303,8 +303,9 @@ public class NoticeConfigServiceImpl implements NoticeConfigService, CommandLine
    @Override
    public boolean sendTestMsg(NoticeReceiver noticeReceiver) {
        Map<String, String> labels = new HashMap<>(8);
-        labels.put(CommonConstants.LABEL_INSTANCE, "127.0.0.1");
+        labels.put(CommonConstants.LABEL_INSTANCE, "1000000");
        labels.put(CommonConstants.LABEL_ALERT_NAME, "CPU Usage Alert");
+        labels.put(CommonConstants.LABEL_INSTANCE_HOST, "127.0.0.1");
        Map<String, String> annotations = new HashMap<>(8);
        annotations.put("suggest", "Please check the CPU usage of the server");
        SingleAlert singleAlert1 = SingleAlert.builder()
@@ -21,7 +21,7 @@ import com.fasterxml.jackson.databind.JsonNode;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.common.entity.dto.sms.SmslocalSmsProperties;
+import org.apache.hertzbeat.alert.config.SmslocalSmsProperties;
 import org.apache.hertzbeat.alert.service.SmsClient;
 import org.apache.hertzbeat.common.constants.SmsConstants;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
@@ -19,7 +19,7 @@ package org.apache.hertzbeat.alert.service.impl;

 import jakarta.xml.bind.DatatypeConverter;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.common.entity.dto.sms.TencentSmsProperties;
+import org.apache.hertzbeat.alert.config.TencentSmsProperties;
 import org.apache.hertzbeat.alert.service.SmsClient;
 import org.apache.hertzbeat.alert.util.CryptoUtils;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
@@ -19,7 +19,7 @@ package org.apache.hertzbeat.alert.service.impl;

 import com.fasterxml.jackson.databind.JsonNode;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.common.entity.dto.sms.TwilioSmsProperties;
+import org.apache.hertzbeat.alert.config.TwilioSmsProperties;
 import org.apache.hertzbeat.alert.service.SmsClient;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
 import org.apache.hertzbeat.common.entity.alerter.NoticeReceiver;
@@ -168,4 +168,4 @@ public class TwilioSmsClientImpl implements SmsClient {
    public boolean checkConfig() {
        return !(accountSid.isBlank() || authToken.isBlank() || twilioPhoneNumber.isBlank());
    }
-}
+}
@@ -18,7 +18,7 @@
 package org.apache.hertzbeat.alert.service.impl;

 import lombok.extern.slf4j.Slf4j;
-import org.apache.hertzbeat.common.entity.dto.sms.UniSmsProperties;
+import org.apache.hertzbeat.alert.config.UniSmsProperties;
 import org.apache.hertzbeat.alert.service.SmsClient;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
 import org.apache.hertzbeat.common.entity.alerter.NoticeReceiver;
@@ -190,4 +190,4 @@ public class UniSmsClientImpl implements SmsClient {

        return true;
    }
-} 
+} 
@@ -88,7 +88,7 @@ public class CryptoUtils {
     * @return lowercase hexadecimal string
     */
    public static String hmacSha256Hex(String key, String data) {
-        return hmacSha256Hex(key.getBytes(UTF8), data);
+        return hmacSha256Hex(hmac256(key.getBytes(UTF8), data), data);
    }

    /**
@@ -125,7 +125,7 @@ public class MetricsRealTimeAlertCalculatorMatchTest {

        Map<String, String> meta = new HashMap<>();
        meta.put(MetricDataConstants.INSTANCE_NAME, "Cool_Stingray_34Nj_copy");
-        meta.put(MetricDataConstants.INSTANCE, "127.0.0.1");
+        meta.put(MetricDataConstants.INSTANCE_HOST, "127.0.0.1");

        builder.addMetadataAll(meta);
        builder.addAllFields(Lists.newArrayList(destination, mode, metricValue));
@@ -175,7 +175,7 @@ public class MetricsRealTimeAlertCalculatorMatchTest {

        Map<String, String> meta = new HashMap<>();
        meta.put(MetricDataConstants.INSTANCE_NAME, "Cool_Stingray_34Nj");
-        meta.put(MetricDataConstants.INSTANCE, "127.0.0.1");
+        meta.put(MetricDataConstants.INSTANCE_HOST, "127.0.0.1");

        builder.addMetadataAll(meta);
        builder.addAllFields(Lists.newArrayList(destination, mode, metricValue));
@@ -225,7 +225,7 @@ public class MetricsRealTimeAlertCalculatorMatchTest {

        Map<String, String> meta = new HashMap<>();
        meta.put(MetricDataConstants.INSTANCE_NAME, "Vibrant_Gazelle_83vJ");
-        meta.put(MetricDataConstants.INSTANCE, "127.0.0.1");
+        meta.put(MetricDataConstants.INSTANCE_HOST, "127.0.0.1");

        builder.addMetadataAll(meta);
        builder.addAllFields(Lists.newArrayList(responseTime));
@@ -108,6 +108,7 @@ class WindowedLogRealTimeAlertCalculatorTest {
        verify(timeService).isLateData(anyLong());
        verify(timeService).updateMaxTimestamp(anyLong());
        verify(logWorker).reduceAndSendLogTask(validLogEntry);
+        verify(dataQueue).sendLogEntryToStorage(validLogEntry);
    }

    @Test
@@ -133,6 +134,7 @@ class WindowedLogRealTimeAlertCalculatorTest {
        verify(timeService, never()).isLateData(anyLong());
        verify(timeService, never()).updateMaxTimestamp(anyLong());
        verify(logWorker, never()).reduceAndSendLogTask(any());
+        verify(dataQueue).sendLogEntryToStorage(invalidTimestampLogEntry);
    }

    @Test
@@ -160,6 +162,7 @@ class WindowedLogRealTimeAlertCalculatorTest {
        verify(timeService).isLateData(anyLong());
        verify(timeService, never()).updateMaxTimestamp(anyLong());
        verify(logWorker, never()).reduceAndSendLogTask(any());
+        verify(dataQueue).sendLogEntryToStorage(lateDataLogEntry);
    }

    @Test
@@ -88,7 +88,7 @@ class AlertDefineControllerTest {
                                Monitor.builder()
                                        .id(1L)
                                        .app("app")
-                                        .instance("localhost")
+                                        .host("localhost")
                                        .name("monitor")
                                        .build()
                        )
@@ -27,7 +27,7 @@ import static org.mockito.Mockito.when;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import java.util.Properties;
-import org.apache.hertzbeat.common.entity.dto.MailServerConfig;
+import org.apache.hertzbeat.alert.dto.MailServerConfig;
 import org.apache.hertzbeat.base.dao.GeneralConfigDao;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
 import org.apache.hertzbeat.common.entity.alerter.NoticeReceiver;
@@ -1,333 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.hertzbeat.alert.notice.impl;
-
-import org.apache.hertzbeat.alert.AlerterProperties;
-import org.apache.hertzbeat.alert.notice.AlertNoticeException;
-import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
-import org.apache.hertzbeat.common.entity.alerter.NoticeReceiver;
-import org.apache.hertzbeat.common.entity.alerter.NoticeTemplate;
-import org.apache.hertzbeat.common.entity.alerter.SingleAlert;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.client.RestTemplate;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.ResourceBundle;
-
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.lenient;
-import static org.mockito.Mockito.when;
-
-/**
- * Test case for FeiShu App Alert Notify
- */
-@ExtendWith(MockitoExtension.class)
-class FeiShuAppAlertNotifyHandlerImplTest {
-
-    @Mock
-    private RestTemplate restTemplate;
-
-    @Mock
-    private ResourceBundle bundle;
-
-    @Mock
-    private AlerterProperties alerterProperties;
-
-    @InjectMocks
-    private FeiShuAppAlertNotifyHandlerImpl feiShuAppAlertNotifyHandler;
-
-    private NoticeReceiver receiver;
-    private GroupAlert groupAlert;
-    private NoticeTemplate template;
-
-    @BeforeEach
-    public void setUp() {
-        receiver = new NoticeReceiver();
-        receiver.setId(1L);
-        receiver.setName("test-receiver");
-        receiver.setType((byte) 14);
-        receiver.setAppId("cli-test-app-id");
-        receiver.setAppSecret("test-app-secret");
-
-        groupAlert = new GroupAlert();
-        SingleAlert singleAlert = new SingleAlert();
-        singleAlert.setLabels(new HashMap<>());
-        singleAlert.getLabels().put("severity", "critical");
-        singleAlert.getLabels().put("alertname", "Test Alert");
-
-        List<SingleAlert> alerts = new ArrayList<>();
-        alerts.add(singleAlert);
-        groupAlert.setAlerts(alerts);
-
-        template = new NoticeTemplate();
-        template.setId(1L);
-        template.setName("test-template");
-        template.setContent("test content");
-
-        lenient().when(bundle.getString("alerter.notify.title")).thenReturn("Alert Notification");
-        lenient().when(alerterProperties.getConsoleUrl()).thenReturn("https://console.hertzbeat.com");
-    }
-
-    /**
-     * Test successful notification to single user
-     */
-    @Test
-    public void testNotifyAlertSuccessSingleUser() {
-        // Setup receiver for single user
-        receiver.setLarkReceiveType((byte) 0);
-        receiver.setUserId("user-001");
-
-        // Mock access token response
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse accessTokenResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse();
-        accessTokenResp.setCode(0);
-        accessTokenResp.setMsg("success");
-        accessTokenResp.setTenantAccessToken("test-access-token");
-
-        // Mock message send response
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse messageResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse();
-        messageResp.setCode(0);
-        messageResp.setMsg("success");
-
-        // Mock restTemplate calls
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse.class)))
-                .thenReturn(new ResponseEntity<>(accessTokenResp, HttpStatus.OK));
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse.class)))
-                .thenReturn(new ResponseEntity<>(messageResp, HttpStatus.OK));
-        feiShuAppAlertNotifyHandler.send(receiver, template, groupAlert);
-    }
-
-    /**
-     * Test successful notification to multiple users
-     */
-    @Test
-    public void testNotifyAlertSuccessMultipleUsers() {
-        receiver.setLarkReceiveType((byte) 0);
-        receiver.setUserId("user-001,user-002,user-003");
-
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse accessTokenResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse();
-        accessTokenResp.setCode(0);
-        accessTokenResp.setMsg("success");
-        accessTokenResp.setTenantAccessToken("test-access-token");
-
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse messageResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse();
-        messageResp.setCode(0);
-        messageResp.setMsg("success");
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse.class)))
-                .thenReturn(new ResponseEntity<>(accessTokenResp, HttpStatus.OK));
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse.class)))
-                .thenReturn(new ResponseEntity<>(messageResp, HttpStatus.OK));
-
-        feiShuAppAlertNotifyHandler.send(receiver, template, groupAlert);
-    }
-
-    /**
-     * Test successful notification to chat
-     */
-    @Test
-    public void testNotifyAlertSuccessChat() {
-        receiver.setLarkReceiveType((byte) 1);
-        receiver.setChatId("chat-001");
-
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse accessTokenResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse();
-        accessTokenResp.setCode(0);
-        accessTokenResp.setMsg("success");
-        accessTokenResp.setTenantAccessToken("test-access-token");
-
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse messageResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse();
-        messageResp.setCode(0);
-        messageResp.setMsg("success");
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse.class)))
-                .thenReturn(new ResponseEntity<>(accessTokenResp, HttpStatus.OK));
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse.class)))
-                .thenReturn(new ResponseEntity<>(messageResp, HttpStatus.OK));
-
-        feiShuAppAlertNotifyHandler.send(receiver, template, groupAlert);
-    }
-
-    /**
-     * Test successful notification to departments
-     */
-    @Test
-    public void testNotifyAlertSuccessDepartments() {
-        receiver.setLarkReceiveType((byte) 2);
-        receiver.setPartyId("dept-001,dept-002");
-
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse accessTokenResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse();
-        accessTokenResp.setCode(0);
-        accessTokenResp.setMsg("success");
-        accessTokenResp.setTenantAccessToken("test-access-token");
-
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse messageResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse();
-        messageResp.setCode(0);
-        messageResp.setMsg("success");
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse.class)))
-                .thenReturn(new ResponseEntity<>(accessTokenResp, HttpStatus.OK));
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse.class)))
-                .thenReturn(new ResponseEntity<>(messageResp, HttpStatus.OK));
-
-        feiShuAppAlertNotifyHandler.send(receiver, template, groupAlert);
-    }
-
-    /**
-     * Test notification failure due to access token error
-     */
-    @Test
-    public void testNotifyAlertFailureAccessToken() {
-        receiver.setLarkReceiveType((byte) 0);
-        receiver.setUserId("user-001");
-
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse accessTokenResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse();
-        accessTokenResp.setCode(999);
-        accessTokenResp.setMsg("Invalid app credentials");
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse.class)))
-                .thenReturn(new ResponseEntity<>(accessTokenResp, HttpStatus.OK));
-
-        assertThrows(AlertNoticeException.class, () -> {
-            feiShuAppAlertNotifyHandler.send(receiver, template, groupAlert);
-        });
-    }
-
-    /**
-     * Test notification failure due to message send error
-     */
-    @Test
-    public void testNotifyAlertFailureMessageSend() {
-        receiver.setLarkReceiveType((byte) 0);
-        receiver.setUserId("user-001");
-
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse accessTokenResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse();
-        accessTokenResp.setCode(0);
-        accessTokenResp.setMsg("success");
-        accessTokenResp.setTenantAccessToken("test-access-token");
-
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse messageResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse();
-        messageResp.setCode(999);
-        messageResp.setMsg("User not found");
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse.class)))
-                .thenReturn(new ResponseEntity<>(accessTokenResp, HttpStatus.OK));
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppResponse.class)))
-                .thenReturn(new ResponseEntity<>(messageResp, HttpStatus.OK));
-
-        assertThrows(AlertNoticeException.class, () -> {
-            feiShuAppAlertNotifyHandler.send(receiver, template, groupAlert);
-        });
-    }
-
-    /**
-     * Test invalid larkReceiveType
-     */
-    @Test
-    public void testInvalidLarkReceiveType() {
-        receiver.setLarkReceiveType((byte) 99);
-        receiver.setUserId("user-001");
-
-        FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse accessTokenResp =
-                new FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse();
-        accessTokenResp.setCode(0);
-        accessTokenResp.setMsg("success");
-        accessTokenResp.setTenantAccessToken("test-access-token");
-
-        when(restTemplate.exchange(
-                anyString(),
-                eq(org.springframework.http.HttpMethod.POST),
-                any(),
-                eq(FeiShuAppAlertNotifyHandlerImpl.FeiShuAppAccessTokenResponse.class)))
-                .thenReturn(new ResponseEntity<>(accessTokenResp, HttpStatus.OK));
-
-        assertThrows(AlertNoticeException.class, () -> {
-            feiShuAppAlertNotifyHandler.send(receiver, template, groupAlert);
-        });
-    }
-}
@@ -21,8 +21,6 @@ import com.google.common.collect.Lists;
 import org.apache.hertzbeat.alert.calculate.periodic.PeriodicAlertRuleScheduler;
 import org.apache.hertzbeat.alert.dao.AlertDefineDao;
 import org.apache.hertzbeat.alert.service.impl.AlertDefineServiceImpl;
-import org.apache.hertzbeat.base.dao.LabelDao;
-import org.apache.hertzbeat.base.service.LabelService;
 import org.apache.hertzbeat.common.cache.CacheFactory;
 import org.apache.hertzbeat.common.entity.alerter.AlertDefine;
 import org.junit.jupiter.api.BeforeEach;
@@ -71,13 +69,7 @@ class AlertDefineServiceTest {

    @Mock
    private AlertDefineDao alertDefineDao;
-
-    @Mock
-    private LabelService labelService;
-
-    @Mock
-    private LabelDao labelDao;
-
+    
    @Mock
    private PeriodicAlertRuleScheduler periodicAlertRuleScheduler;

@@ -94,8 +86,6 @@ class AlertDefineServiceTest {
    void setUp() {
        ReflectionTestUtils.setField(this.alertDefineService, "alertDefineDao", alertDefineDao);
        ReflectionTestUtils.setField(this.alertDefineService, "periodicAlertRuleScheduler", periodicAlertRuleScheduler);
-        ReflectionTestUtils.setField(this.alertDefineService, "labelService", labelService);
-        ReflectionTestUtils.setField(this.alertDefineService, "labelDao", labelDao);

        this.alertDefine = AlertDefine.builder()
                .id(1L)
@@ -197,40 +187,40 @@ class AlertDefineServiceTest {
                AlertDefine.builder().id(1L).type(METRIC_ALERT_THRESHOLD_TYPE_REALTIME).enable(true).build(),
                AlertDefine.builder().id(2L).type(METRIC_ALERT_THRESHOLD_TYPE_REALTIME).enable(true).build()
        );
-
+        
        try (MockedStatic<CacheFactory> cacheFactoryMock = Mockito.mockStatic(CacheFactory.class)) {
            // Mock cache hit
            cacheFactoryMock.when(CacheFactory::getMetricsAlertDefineCache).thenReturn(cachedAlertDefines);
-
+            
            List<AlertDefine> result = alertDefineService.getMetricsRealTimeAlertDefines();
-
+            
            assertNotNull(result);
            assertEquals(2, result.size());
            assertEquals(1L, result.get(0).getId());
            assertEquals(2L, result.get(1).getId());
-
+            
            // Verify no database query was called
            verify(alertDefineDao, times(0)).findAlertDefinesByTypeAndEnableTrue(any());
            cacheFactoryMock.verify(() -> CacheFactory.setMetricsAlertDefineCache(any()), times(0));
        }
-
+        
        // Test cache miss scenario
        List<AlertDefine> dbAlertDefines = Lists.newArrayList(
                AlertDefine.builder().id(3L).type(METRIC_ALERT_THRESHOLD_TYPE_REALTIME).enable(true).build()
        );
-
+        
        try (MockedStatic<CacheFactory> cacheFactoryMock = Mockito.mockStatic(CacheFactory.class)) {
            // Mock cache miss
            cacheFactoryMock.when(CacheFactory::getMetricsAlertDefineCache).thenReturn(null);
            when(alertDefineDao.findAlertDefinesByTypeAndEnableTrue(METRIC_ALERT_THRESHOLD_TYPE_REALTIME))
                    .thenReturn(dbAlertDefines);
-
+            
            List<AlertDefine> result = alertDefineService.getMetricsRealTimeAlertDefines();
-
+            
            assertNotNull(result);
            assertEquals(1, result.size());
            assertEquals(3L, result.get(0).getId());
-
+            
            // Verify database query and cache setting were called
            verify(alertDefineDao, times(1)).findAlertDefinesByTypeAndEnableTrue(METRIC_ALERT_THRESHOLD_TYPE_REALTIME);
            cacheFactoryMock.verify(() -> CacheFactory.setMetricsAlertDefineCache(dbAlertDefines), times(1));
@@ -244,40 +234,40 @@ class AlertDefineServiceTest {
                AlertDefine.builder().id(4L).type(LOG_ALERT_THRESHOLD_TYPE_REALTIME).enable(true).build(),
                AlertDefine.builder().id(5L).type(LOG_ALERT_THRESHOLD_TYPE_REALTIME).enable(true).build()
        );
-
+        
        try (MockedStatic<CacheFactory> cacheFactoryMock = Mockito.mockStatic(CacheFactory.class)) {
            // Mock cache hit
            cacheFactoryMock.when(CacheFactory::getLogAlertDefineCache).thenReturn(cachedAlertDefines);
-
+            
            List<AlertDefine> result = alertDefineService.getLogRealTimeAlertDefines();
-
+            
            assertNotNull(result);
            assertEquals(2, result.size());
            assertEquals(4L, result.get(0).getId());
            assertEquals(5L, result.get(1).getId());
-
+            
            // Verify no database query was called
            verify(alertDefineDao, times(0)).findAlertDefinesByTypeAndEnableTrue(any());
            cacheFactoryMock.verify(() -> CacheFactory.setLogAlertDefineCache(any()), times(0));
        }
-
+        
        // Test cache miss scenario
        List<AlertDefine> dbAlertDefines = Lists.newArrayList(
                AlertDefine.builder().id(6L).type(LOG_ALERT_THRESHOLD_TYPE_REALTIME).enable(true).build()
        );
-
+        
        try (MockedStatic<CacheFactory> cacheFactoryMock = Mockito.mockStatic(CacheFactory.class)) {
            // Mock cache miss
            cacheFactoryMock.when(CacheFactory::getLogAlertDefineCache).thenReturn(null);
            when(alertDefineDao.findAlertDefinesByTypeAndEnableTrue(LOG_ALERT_THRESHOLD_TYPE_REALTIME))
                    .thenReturn(dbAlertDefines);
-
+            
            List<AlertDefine> result = alertDefineService.getLogRealTimeAlertDefines();
-
+            
            assertNotNull(result);
            assertEquals(1, result.size());
            assertEquals(6L, result.get(0).getId());
-
+            
            // Verify database query and cache setting were called
            verify(alertDefineDao, times(1)).findAlertDefinesByTypeAndEnableTrue(LOG_ALERT_THRESHOLD_TYPE_REALTIME);
            cacheFactoryMock.verify(() -> CacheFactory.setLogAlertDefineCache(dbAlertDefines), times(1));
@@ -290,58 +280,58 @@ class AlertDefineServiceTest {
                AlertDefine.builder().id(7L).type(METRIC_ALERT_THRESHOLD_TYPE_REALTIME).enable(true).build(),
                AlertDefine.builder().id(8L).type(METRIC_ALERT_THRESHOLD_TYPE_REALTIME).enable(true).build()
        );
-
+        
        // Test valid metric realtime alert type
        when(alertDefineDao.findAlertDefinesByTypeAndEnableTrue(METRIC_ALERT_THRESHOLD_TYPE_REALTIME))
                .thenReturn(mockAlertDefines);
-
+        
        List<AlertDefine> result = alertDefineService.getAlertDefinesByType(METRIC_ALERT_THRESHOLD_TYPE_REALTIME);
-
+        
        assertNotNull(result);
        assertEquals(2, result.size());
        assertEquals(7L, result.get(0).getId());
        assertEquals(8L, result.get(1).getId());
        verify(alertDefineDao, times(1)).findAlertDefinesByTypeAndEnableTrue(METRIC_ALERT_THRESHOLD_TYPE_REALTIME);
-
+        
        // Test valid metric periodic alert type
        reset(alertDefineDao);
        when(alertDefineDao.findAlertDefinesByTypeAndEnableTrue(METRIC_ALERT_THRESHOLD_TYPE_PERIODIC))
                .thenReturn(Lists.newArrayList());
-
+        
        result = alertDefineService.getAlertDefinesByType(METRIC_ALERT_THRESHOLD_TYPE_PERIODIC);
-
+        
        assertNotNull(result);
        assertEquals(0, result.size());
        verify(alertDefineDao, times(1)).findAlertDefinesByTypeAndEnableTrue(METRIC_ALERT_THRESHOLD_TYPE_PERIODIC);
-
+        
        // Test valid log realtime alert type
        reset(alertDefineDao);
        when(alertDefineDao.findAlertDefinesByTypeAndEnableTrue(LOG_ALERT_THRESHOLD_TYPE_REALTIME))
                .thenReturn(mockAlertDefines);
-
+        
        result = alertDefineService.getAlertDefinesByType(LOG_ALERT_THRESHOLD_TYPE_REALTIME);
-
+        
        assertNotNull(result);
        assertEquals(2, result.size());
        verify(alertDefineDao, times(1)).findAlertDefinesByTypeAndEnableTrue(LOG_ALERT_THRESHOLD_TYPE_REALTIME);
-
+        
        // Test valid log periodic alert type
        reset(alertDefineDao);
        when(alertDefineDao.findAlertDefinesByTypeAndEnableTrue(LOG_ALERT_THRESHOLD_TYPE_PERIODIC))
                .thenReturn(Lists.newArrayList());
-
+        
        result = alertDefineService.getAlertDefinesByType(LOG_ALERT_THRESHOLD_TYPE_PERIODIC);
-
+        
        assertNotNull(result);
        assertEquals(0, result.size());
        verify(alertDefineDao, times(1)).findAlertDefinesByTypeAndEnableTrue(LOG_ALERT_THRESHOLD_TYPE_PERIODIC);
-
+        
        // Test empty string type
        assertThrows(IllegalArgumentException.class, () -> alertDefineService.getAlertDefinesByType(""));
-
+        
        // Test null type
        assertThrows(IllegalArgumentException.class, () -> alertDefineService.getAlertDefinesByType(null));
-
+        
        // Test invalid type
        assertThrows(IllegalArgumentException.class, () -> alertDefineService.getAlertDefinesByType("invalid_type"));
    }
@@ -28,12 +28,9 @@ import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.beans.BeanUtils;

 import java.time.Instant;
-import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;

 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -150,36 +147,4 @@ public class AlibabaCloudSlsExternAlertServiceTest {
        verify(alarmCommonReduce, times(1)).reduceAndSendAlarm(any(SingleAlert.class));
    }

-    @Test
-    void testAddMergeExternAlert() {
-        String source = externAlertService.supportSource();
-        assertEquals("alibabacloud-sls", source);
-
-        AlibabaCloudSlsExternAlert externAlert = new AlibabaCloudSlsExternAlert();
-        externAlert.setAlertName("Test SLS alert");
-        externAlert.setFireTime((int) Instant.now().getEpochSecond());
-        externAlert.setAlertTime((int) Instant.now().getEpochSecond());
-        externAlert.setRegion("cn-hangzhou");
-        externAlert.setProject("project");
-        externAlert.setStatus("firing");
-        externAlert.setSeverity(AlibabaCloudSlsExternAlert.Severity.HIGH.getStatus());
-
-        Map<String, String> labels = new HashMap<>();
-        labels.put("labels-k", "labels-v");
-        externAlert.setLabels(labels);
-
-        Map<String, String> annotations = new HashMap<>();
-        annotations.put("annotations-k", "annotations-v");
-        externAlert.setAnnotations(annotations);
-
-        AlibabaCloudSlsExternAlert externAlert1 = new AlibabaCloudSlsExternAlert();
-        BeanUtils.copyProperties(externAlert, externAlert1);
-
-        List<AlibabaCloudSlsExternAlert> externAlerts = new ArrayList<>();
-        externAlerts.add(externAlert);
-        externAlerts.add(externAlert1);
-        externAlertService.addExternAlert(JsonUtil.toJson(externAlerts));
-        verify(alarmCommonReduce, times(2)).reduceAndSendAlarm(any(SingleAlert.class));
-    }
-
 }
@@ -17,7 +17,7 @@

 package org.apache.hertzbeat.alert.service;

-import org.apache.hertzbeat.common.entity.dto.sms.AwsSmsProperties;
+import org.apache.hertzbeat.alert.config.AwsSmsProperties;
 import org.apache.hertzbeat.alert.service.impl.AwsSmsClientImpl;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -36,10 +36,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;

 /**
@@ -51,7 +48,7 @@ class DataSourceServiceTest {

    @BeforeEach
    void setUp() {
-        dataSourceService = new DataSourceServiceImpl(null);
+        dataSourceService = new DataSourceServiceImpl();
    }

    @Test
@@ -642,156 +639,4 @@ class DataSourceServiceTest {

        assertThrows(AlertExpressionException.class, () -> dataSourceService.calculate("promql", "http_server_requests_seconds_count{!@~!!#$%^&}"));
    }
-
-    @Test
-    void query1() {
-        List<Map<String, Object>> sqlData = List.of(
-                new HashMap<>(Map.of("count", 10, "severity_text", "ERROR"))
-        );
-        QueryExecutor mockExecutor = Mockito.mock(QueryExecutor.class);
-        when(mockExecutor.support("sql")).thenReturn(true);
-        when(mockExecutor.execute(anyString())).thenReturn(sqlData);
-        dataSourceService.setExecutors(List.of(mockExecutor));
-
-        String validSql = "SELECT count(*) FROM hertzbeat_logs WHERE severity_text = 'ERROR'";
-        List<Map<String, Object>> result = dataSourceService.query("sql", validSql);
-
-        assertNotNull(result);
-        assertEquals(1, result.size());
-        verify(mockExecutor).execute(anyString());
-    }
-
-    @Test
-    void query2() {
-        QueryExecutor mockExecutor = Mockito.mock(QueryExecutor.class);
-        when(mockExecutor.support("sql")).thenReturn(true);
-        dataSourceService.setExecutors(List.of(mockExecutor));
-
-        assertThrows(AlertExpressionException.class,
-                () -> dataSourceService.query("sql", "INSERT INTO hertzbeat_logs (body) VALUES ('test')"));
-        verify(mockExecutor, never()).execute(anyString());
-    }
-
-    @Test
-    void query3() {
-        QueryExecutor mockExecutor = Mockito.mock(QueryExecutor.class);
-        when(mockExecutor.support("sql")).thenReturn(true);
-        dataSourceService.setExecutors(List.of(mockExecutor));
-
-        assertThrows(AlertExpressionException.class,
-                () -> dataSourceService.query("sql", "DELETE FROM hertzbeat_logs WHERE id = 1"));
-        verify(mockExecutor, never()).execute(anyString());
-    }
-
-    @Test
-    void query4() {
-        QueryExecutor mockExecutor = Mockito.mock(QueryExecutor.class);
-        when(mockExecutor.support("sql")).thenReturn(true);
-        dataSourceService.setExecutors(List.of(mockExecutor));
-
-        assertThrows(AlertExpressionException.class,
-                () -> dataSourceService.query("sql", "UPDATE hertzbeat_logs SET body = 'hacked' WHERE id = 1"));
-        verify(mockExecutor, never()).execute(anyString());
-    }
-
-    @Test
-    void query5() {
-        QueryExecutor mockExecutor = Mockito.mock(QueryExecutor.class);
-        when(mockExecutor.support("sql")).thenReturn(true);
-        dataSourceService.setExecutors(List.of(mockExecutor));
-
-        assertThrows(AlertExpressionException.class,
-                () -> dataSourceService.query("sql", "DROP TABLE hertzbeat_logs"));
-        verify(mockExecutor, never()).execute(anyString());
-    }
-
-    @Test
-    void query6() {
-        QueryExecutor mockExecutor = Mockito.mock(QueryExecutor.class);
-        when(mockExecutor.support("sql")).thenReturn(true);
-        dataSourceService.setExecutors(List.of(mockExecutor));
-
-        assertThrows(AlertExpressionException.class,
-                () -> dataSourceService.query("sql", "SELECT * FROM hertzbeat_logs UNION SELECT * FROM users"));
-        verify(mockExecutor, never()).execute(anyString());
-    }
-
-    @Test
-    void query7() {
-        QueryExecutor mockExecutor = Mockito.mock(QueryExecutor.class);
-        when(mockExecutor.support("sql")).thenReturn(true);
-        dataSourceService.setExecutors(List.of(mockExecutor));
-
-        assertThrows(AlertExpressionException.class,
-                () -> dataSourceService.query("sql", "SELECT * FROM hertzbeat_logs WHERE id IN (SELECT id FROM other_table)"));
-        verify(mockExecutor, never()).execute(anyString());
-    }
-
-    @Test
-    void query8() {
-        QueryExecutor mockExecutor = Mockito.mock(QueryExecutor.class);
-        when(mockExecutor.support("sql")).thenReturn(true);
-        dataSourceService.setExecutors(List.of(mockExecutor));
-
-        assertThrows(AlertExpressionException.class,
-                () -> dataSourceService.query("sql", "SELECT * FROM users"));
-        verify(mockExecutor, never()).execute(anyString());
-    }
-
-    @Test
-    void query9() {
-        QueryExecutor mockExecutor = Mockito.mock(QueryExecutor.class);
-        when(mockExecutor.support("sql")).thenReturn(true);
-        dataSourceService.setExecutors(List.of(mockExecutor));
-
-        assertThrows(AlertExpressionException.class,
-                () -> dataSourceService.query("sql", "WITH cte AS (SELECT * FROM hertzbeat_logs) SELECT * FROM cte"));
-        verify(mockExecutor, never()).execute(anyString());
-    }
-
-    @Test
-    void query10() {
-        List<Map<String, Object>> sqlData = List.of(
-                new HashMap<>(Map.of("errorCount", 5))
-        );
-        QueryExecutor mockExecutor = Mockito.mock(QueryExecutor.class);
-        when(mockExecutor.support("sql")).thenReturn(true);
-        when(mockExecutor.execute(anyString())).thenReturn(sqlData);
-        dataSourceService.setExecutors(List.of(mockExecutor));
-
-        String complexSql = "SELECT count(*) AS errorCount FROM hertzbeat_logs "
-                + "WHERE time_unix_nano >= NOW() AND severity_text = 'ERROR' "
-                + "GROUP BY severity_text HAVING count(*) > 2 ORDER BY errorCount LIMIT 10";
-
-        List<Map<String, Object>> result = dataSourceService.query("sql", complexSql);
-        assertNotNull(result);
-        verify(mockExecutor).execute(anyString());
-    }
-
-    @Test
-    void query11() {
-        List<Map<String, Object>> prometheusData = List.of(
-                new HashMap<>(Map.of("__value__", 100.0))
-        );
-        QueryExecutor mockExecutor = Mockito.mock(QueryExecutor.class);
-        when(mockExecutor.support("promql")).thenReturn(true);
-        when(mockExecutor.execute(anyString())).thenReturn(prometheusData);
-        dataSourceService.setExecutors(List.of(mockExecutor));
-
-        List<Map<String, Object>> result = dataSourceService.query("promql", "node_cpu_seconds_total > 50");
-
-        assertNotNull(result);
-        verify(mockExecutor).execute(anyString());
-    }
-
-    @Test
-    void query12() {
-        QueryExecutor mockExecutor = Mockito.mock(QueryExecutor.class);
-        when(mockExecutor.support("sql")).thenReturn(true);
-        dataSourceService.setExecutors(List.of(mockExecutor));
-
-        assertThrows(AlertExpressionException.class,
-                () -> dataSourceService.query("sql", "SELEC * FORM hertzbeat_logs"));
-        verify(mockExecutor, never()).execute(anyString());
-    }
 }
@@ -146,42 +146,7 @@ public class HuaweiCloudExternAlertServiceTest {
        verify(alarmCommonReduce, never()).reduceAndSendAlarm(any(SingleAlert.class));
    }

-    @Test
-    void testSubscriptionUrlFail() {
-        HuaweiCloudExternAlert externAlert = new HuaweiCloudExternAlert();
-        externAlert.setSubscribeUrl("https://console.huaweicloud.com/smn/subscription/confirm?token=477a784601d744e4ab9ab83986502d31c4b938"
-                + "0ec0b64392b134e517c3aa17eb7b3a12dc9f3b4ab495e61c4dee654b435d7223ea934345bf8ae8901cef912b1d&topic_urn=urn:smn:cn-north-4"
-                + ":477a784601d744e4ab9ab83986502d31:CES_notification_group_bngJ2aMpX&region=cn-north-4");
-        externAlert.setSignature("ottf37C/2RdDgqimRQMIBU6i7XjUfPPMU760jJn71wwP3825YPoIT22uw2A9399rkm9Jrt1qUEFrDLuA5yHFLd5n/XoM4FghIgyFn7VIfgpuVM31a+co78s"
-                + "YBiZ1egOCE/AwFm2oygRhfIceUj9Kw9vmc06el9TXY6RtE5tAEF6qEmICtTh45KwtCO/WRs3DY72dQi5hm0w7/tktS4WFZ1iP4LHt5eCwFvnH0u29Y96cJNI0fLUQxI5MkhgjK"
-                + "77JkFK7UT6ZYJZhzgSp/B7OQGStOQx+3Duvx4T4CzccZQM3sca81Z0B0GFGWeVXuEHyCPLsayY/Iz+5Tco51elT8w==");
-        externAlert.setTopicUrn("urn:smn:cn-north-4:477a784601d744e4ab9ab83986502d31:CES_notification_group_bngJ2aMpX");
-        externAlert.setMessageId("242fac183d3a4936b5ead6c725a32ed0");
-        externAlert.setType("SubscriptionConfirmation");
-        externAlert.setMessage("You are invited to subscribe to topic: urn:smn:cn-north-4:477a784601d744e4ab9ab83986502d31:"
-                + "CES_notification_group_bngJ2aMpX. To confirm this subscription, please visit the subscribe_url included in this message. The subscribe_url is valid only within 48 hours.");
-        externAlert.setSigningCertUrl("https://xxxx.myhuaweicloud.com/smn/SMN_cn-north-4_b98100ca131b4116ab8ee7ccedbaae99.pem");
-        externAlert.setTimestamp("2025-06-07T15:07:14Z");
-        externAlertService.addExternAlert(JsonUtil.toJson(externAlert));
-        verify(alarmCommonReduce, never()).reduceAndSendAlarm(any(SingleAlert.class));
-    }

-    @Test
-    void testCertUrlFailed() {
-        HuaweiCloudExternAlert externAlert = new HuaweiCloudExternAlert();
-        externAlert.setSignature("TImrLoeb0tV1JZJSPyA0rpC9mNqH3MmhwQ4tgpuHHa+JztfGVZFvkU//OthKKhzpDAoYiXOYG9DbzXCLb"
-                + "vaGePIRITakoynYyYr9zZIpdx9jXhQNlgF8np1+t0JxNeoIq0DYWgH52tsodwqOm+OnmkcHwCRo/1rFv85KrKAaX2gy3sNwX"
-                + "w1hKnAwAw0mJlxHHSf/N3+7j6GoxCNV7fN9K4CpJiLMGNvUa7zVmG0U9mPvt/7Lac155kPPQ9lYyeL7vVI0e4sfRbuQruz3E"
-                + "0ZP40TKx0afoeR0/Bx/IoZzRP1La7pKlbEISvkcM7TqW/IOGQTkhVsQ32RFRxZWO2snw==");
-        externAlert.setSubject("DCS Redis “dcs-h4tv” ");
-        externAlert.setTopicUrn("urn:smn:cn-north-4:477a784601d744e4ab9ab83986502d31:CES_notification_group_bngJ2aMpX");
-        externAlert.setMessageId("d3672d737bb742cf8c2aa3f0fd72d4d1");
-        externAlert.setType("Notification");
-        externAlert.setMessage("{}");
-        externAlert.setSigningCertUrl("https://xxx.myhuaweicloud.com/failedUrl");
-        externAlert.setTimestamp("2025-06-07T15:12:09Z");
-        externAlertService.addExternAlert(JsonUtil.toJson(externAlert));
-        verify(alarmCommonReduce, never()).reduceAndSendAlarm(any(SingleAlert.class));
-    }
+

 }
@@ -19,8 +19,8 @@ package org.apache.hertzbeat.alert.service;

 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import org.apache.hertzbeat.common.entity.dto.sms.SmsConfig;
-import org.apache.hertzbeat.common.entity.dto.sms.SmslocalSmsProperties;
+import org.apache.hertzbeat.alert.config.SmsConfig;
+import org.apache.hertzbeat.alert.config.SmslocalSmsProperties;
 import org.apache.hertzbeat.base.dao.GeneralConfigDao;
 import org.apache.hertzbeat.common.constants.GeneralConfigTypeEnum;
 import org.apache.hertzbeat.common.entity.manager.GeneralConfig;
@@ -89,4 +89,4 @@ public class SmsClientFactoryTest {
        assertNull(smsClientFactory.getSmsClient());
    }

-}
+}
@@ -17,7 +17,7 @@

 package org.apache.hertzbeat.alert.service;

-import org.apache.hertzbeat.common.entity.dto.sms.TwilioSmsProperties;
+import org.apache.hertzbeat.alert.config.TwilioSmsProperties;
 import org.apache.hertzbeat.alert.service.impl.TwilioSmsClientImpl;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -61,4 +61,4 @@ class TwilioSmsClientImplTest {

        assertEquals(expected, twilioSmsClient.checkConfig());
    }
-}
+}
@@ -18,7 +18,7 @@
 package org.apache.hertzbeat.alert.service.impl;

 import com.google.common.collect.Lists;
-import org.apache.hertzbeat.common.entity.dto.sms.SmslocalSmsProperties;
+import org.apache.hertzbeat.alert.config.SmslocalSmsProperties;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
 import org.apache.hertzbeat.common.entity.alerter.NoticeReceiver;
 import org.apache.hertzbeat.common.entity.alerter.SingleAlert;
@@ -70,4 +70,4 @@ public class SmsLocalSmsClientImplTest {
                () -> smsLocalSmsClient.sendMessage(noticeReceiver, null, groupAlert));
    }

-}
+}
@@ -17,7 +17,7 @@

 package org.apache.hertzbeat.alert.service.impl;

-import org.apache.hertzbeat.common.entity.dto.sms.UniSmsProperties;
+import org.apache.hertzbeat.alert.config.UniSmsProperties;
 import org.apache.hertzbeat.common.entity.alerter.GroupAlert;
 import org.apache.hertzbeat.common.entity.alerter.NoticeReceiver;
 import org.apache.hertzbeat.common.support.exception.SendMessageException;
@@ -82,4 +82,4 @@ public class UniSmsClientImplTest {
    }


-}
+}
@@ -42,7 +42,7 @@ public class CryptoUtilsTest {
    @Test
    void testHmacSha256Hex() {
        String signature = CryptoUtils.hmacSha256Hex("your-real-key", "your-real-data");;
-        assertEquals("f09adf5f4bf94eddecf0f7c8f39a3a8dc7f95ccdc2faf2e5330bc5a78e4bba95", signature);
+        assertEquals("41878ccd7ecd795a2dd7ec39be7f33fed4be3ec75f5307689e39dd6f41fdbaac", signature);
    }

 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
tomsun28	b889785c10	fix Signed-off-by: tomsun28 <tomsun28@outlook.com>	2025-10-28 22:21:46 +08:00
tomsun28	69e60bc636	fix Signed-off-by: tomsun28 <tomsun28@outlook.com>	2025-10-28 21:20:05 +08:00
Tomsun28	9a2e85b089	Merge branch 'master' into new-startup	2025-10-27 23:50:19 +08:00
tomsun28	a71f5102dd	fix Signed-off-by: tomsun28 <tomsun28@outlook.com>	2025-10-27 23:36:25 +08:00
tomsun28	293d446505	fix Signed-off-by: tomsun28 <tomsun28@outlook.com>	2025-10-27 21:26:44 +08:00
tomsun28	c415b9373a	fix Signed-off-by: tomsun28 <tomsun28@outlook.com>	2025-10-26 23:25:20 +08:00
tomsun28	e3075bab8a	fix Signed-off-by: tomsun28 <tomsun28@outlook.com>	2025-10-26 00:30:57 +08:00
tomsun28	b51a7fbcdb	fix build Signed-off-by: tomsun28 <tomsun28@outlook.com>	2025-10-25 16:55:07 +08:00
tomsun28	6ecfbc60a0	move log mcp server to mcp-servers Signed-off-by: tomsun28 <tomsun28@outlook.com>	2025-10-25 16:27:17 +08:00
tomsun28	82334a31a1	refactor ai-agent name to ai Signed-off-by: tomsun28 <tomsun28@outlook.com>	2025-10-25 16:16:34 +08:00
tomsun28	93a8e8fa74	move some to startup Signed-off-by: tomsun28 <tomsun28@outlook.com>	2025-10-25 16:07:23 +08:00