diff --git a/data-agent-frontend/src/components/run/ToolCallingView.vue b/data-agent-frontend/src/components/run/ToolCallingView.vue
new file mode 100644
index 000000000..428564909
--- /dev/null
+++ b/data-agent-frontend/src/components/run/ToolCallingView.vue
@@ -0,0 +1,300 @@
+<!--
+ * Copyright 2025 the original author or authors.
+ *
+ * Licensed 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
+ *
+ *      https://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.
+-->
+
+<script setup lang="ts">
+  import { ref, computed } from 'vue';
+  import { Tools } from '@element-plus/icons-vue';
+  import MarkdownAgentContainer from './markdown/MarkdownAgentContainer.vue';
+
+  interface ToolCall {
+    toolName: string;
+    input: any;
+    output: any;
+  }
+
+  interface ResultData {
+    toolCalls?: ToolCall[];
+    [key: string]: any;
+  }
+
+  const props = defineProps<{
+    resultData: ResultData;
+  }>();
+
+  const activeNames = ref<string[]>([]);
+
+  const toolCalls = computed(() => {
+    const data = props.resultData;
+    if (!data) return [];
+
+    if (Array.isArray(data.toolCalls)) {
+      return data.toolCalls;
+    }
+
+    if (Array.isArray(data)) {
+      return data;
+    }
+
+    if (data.toolName && data.input !== undefined && data.output !== undefined) {
+      return [data];
+    }
+
+    return [];
+  });
+
+  const isSequentialThinking = (toolName: string): boolean => {
+    return toolName === 'sequential_thinking';
+  };
+
+  const formatJson = (data: any): string => {
+    if (typeof data === 'string') {
+      try {
+        return JSON.stringify(JSON.parse(data), null, 2);
+      } catch {
+        return data;
+      }
+    }
+    return JSON.stringify(data, null, 2);
+  };
+
+  const getThoughtContent = (input: any): string => {
+    if (typeof input === 'string') {
+      try {
+        const parsed = JSON.parse(input);
+        return parsed.thought || '';
+      } catch {
+        return '';
+      }
+    }
+    return input?.thought || '';
+  };
+
+  const getThoughtMetadata = (input: any): any => {
+    if (typeof input === 'string') {
+      try {
+        const parsed = JSON.parse(input);
+        return {
+          thought_number: parsed.thought_number,
+          total_thoughts: parsed.total_thoughts,
+          next_thought_needed: parsed.next_thought_needed,
+          needs_more_thoughts: parsed.needs_more_thoughts,
+        };
+      } catch {
+        return null;
+      }
+    }
+    return {
+      thought_number: input?.thought_number,
+      total_thoughts: input?.total_thoughts,
+      next_thought_needed: input?.next_thought_needed,
+      needs_more_thoughts: input?.needs_more_thoughts,
+    };
+  };
+
+  const processOutputContent = (content: any): string => {
+    if (typeof content === 'string') {
+      // 检查是否是双引号包裹的字符串
+      if (content.startsWith('"') && content.endsWith('"')) {
+        try {
+          // 尝试使用 JSON.parse 解析
+          return JSON.parse(content);
+        } catch {
+          // 如果解析失败，去掉首尾的双引号
+          return content.substring(1, content.length - 1);
+        }
+      }
+    }
+    return content || '';
+  };
+</script>
+
+<template>
+  <div v-if="toolCalls.length > 0" class="tool-calling-container">
+    <el-collapse v-model="activeNames" class="tool-collapse">
+      <el-collapse-item
+        v-for="(toolCall, index) in toolCalls"
+        :key="index"
+        :name="String(index)"
+        class="tool-collapse-item"
+      >
+        <template #title>
+          <div class="tool-title">
+            <el-icon class="tool-icon"><Tools /></el-icon>
+            <span class="tool-name">调用工具 {{ toolCall.toolName }}</span>
+          </div>
+        </template>
+
+        <div class="tool-content">
+          <div class="content-section">
+            <div class="section-title">输入参数 (Input)</div>
+            <div v-if="isSequentialThinking(toolCall.toolName)" class="sequential-thinking-content">
+              <div v-if="getThoughtMetadata(toolCall.input)" class="thought-metadata">
+                <span class="metadata-item">
+                  思考步骤: {{ getThoughtMetadata(toolCall.input)?.thought_number }} /
+                  {{ getThoughtMetadata(toolCall.input)?.total_thoughts }}
+                </span>
+                <span
+                  class="metadata-item"
+                  :class="{
+                    'status-true': getThoughtMetadata(toolCall.input)?.next_thought_needed,
+                    'status-false': !getThoughtMetadata(toolCall.input)?.next_thought_needed,
+                  }"
+                >
+                  {{
+                    getThoughtMetadata(toolCall.input)?.next_thought_needed
+                      ? '需要继续思考'
+                      : '思考完成'
+                  }}
+                </span>
+              </div>
+              <div class="thought-content">
+                <MarkdownAgentContainer :content="getThoughtContent(toolCall.input)" />
+              </div>
+            </div>
+            <pre v-else class="json-display">{{ formatJson(toolCall.input) }}</pre>
+          </div>
+
+          <div class="content-section">
+            <div class="section-title">输出参数 (Output)</div>
+            <div class="markdown-content">
+              <MarkdownAgentContainer :content="processOutputContent(toolCall.output)" />
+            </div>
+          </div>
+        </div>
+      </el-collapse-item>
+    </el-collapse>
+  </div>
+</template>
+
+<style scoped>
+  .tool-calling-container {
+    width: 100%;
+    margin: 0px 0;
+  }
+
+  .tool-collapse {
+    border-radius: 4px;
+    overflow: hidden;
+  }
+
+  .tool-collapse-item {
+  }
+
+  .tool-collapse-item:last-child {
+  }
+
+  .tool-title {
+    display: flex;
+    align-items: center;
+    width: 100%;
+  }
+
+  .tool-icon {
+    margin-left: 8px;
+    margin-right: 8px;
+    color: #409eff;
+  }
+
+  .tool-name {
+    font-weight: 500;
+    color: #303133;
+    font-size: 14px;
+  }
+
+  .tool-content {
+    padding: 16px;
+  }
+
+  .content-section {
+    margin-bottom: 16px;
+  }
+
+  .content-section:last-child {
+    margin-bottom: 0;
+  }
+
+  .section-title {
+    font-size: 13px;
+    font-weight: 600;
+    color: #606266;
+    margin-bottom: 8px;
+    padding-bottom: 4px;
+  }
+
+  .json-display {
+    background-color: #f5f7fa;
+    border: 1px solid #e4e7ed;
+    border-radius: 4px;
+    padding: 12px;
+    margin: 0;
+    font-size: 12px;
+    line-height: 1.5;
+    color: #303133;
+    overflow-x: auto;
+    overflow-y: auto;
+    white-space: pre-wrap;
+    word-wrap: break-word;
+    max-height: 100px;
+  }
+
+  .sequential-thinking-content {
+    background-color: #f5f7fa;
+    border: 1px solid #e4e7ed;
+    border-radius: 4px;
+    padding: 12px;
+  }
+
+  .thought-metadata {
+    display: flex;
+    gap: 12px;
+    margin-bottom: 12px;
+    padding-bottom: 8px;
+    border-bottom: 1px solid #e4e7ed;
+  }
+
+  .metadata-item {
+    font-size: 12px;
+    color: #606266;
+    padding: 2px 8px;
+    background-color: #e4e7ed;
+    border-radius: 3px;
+  }
+
+  .status-true {
+    background-color: #ecf5ff;
+    color: #409eff;
+  }
+
+  .status-false {
+    background-color: #f0f9ff;
+    color: #67c23a;
+  }
+
+  .thought-content {
+    padding: 8px;
+    background-color: #ffffff;
+    border-radius: 4px;
+    min-height: 40px;
+  }
+
+  .markdown-content {
+    background-color: #f5f7fa;
+    border: 1px solid #e4e7ed;
+    border-radius: 4px;
+    padding: 12px;
+    min-height: 40px;
+  }
+</style>
diff --git a/data-agent-frontend/src/services/graph.ts b/data-agent-frontend/src/services/graph.ts
index ef50143c2..80154019c 100644
--- a/data-agent-frontend/src/services/graph.ts
+++ b/data-agent-frontend/src/services/graph.ts
@@ -22,6 +22,7 @@ export interface GraphRequest {
   humanFeedbackContent?: string;
   rejectedPlan: boolean;
   nl2sqlOnly: boolean;
+  reactAgent: boolean;
 }
 
 export interface GraphNodeResponse {
@@ -42,6 +43,7 @@ export enum TextType {
   MARK_DOWN = 'MARK_DOWN',
   RESULT_SET = 'RESULT_SET',
   TEXT = 'TEXT',
+  TOOL_CALL_NODE = 'TOOL_CALL_NODE',
 }
 
 const API_BASE_URL = '/api';
@@ -71,6 +73,7 @@ class GraphService {
     params.append('humanFeedback', request.humanFeedback.toString());
     params.append('rejectedPlan', request.rejectedPlan.toString());
     params.append('nl2sqlOnly', request.nl2sqlOnly.toString());
+    params.append('reactAgent', request.reactAgent.toString());
 
     if (request.humanFeedbackContent) {
       params.append('humanFeedbackContent', request.humanFeedbackContent);
diff --git a/data-agent-frontend/src/views/AgentRun.vue b/data-agent-frontend/src/views/AgentRun.vue
index 1381af373..e33e97ae3 100644
--- a/data-agent-frontend/src/views/AgentRun.vue
+++ b/data-agent-frontend/src/views/AgentRun.vue
@@ -64,6 +64,14 @@
                   :pageSize="resultSetDisplayConfig.pageSize"
                 />
               </div>
+              <!-- ToolCallNode消息 -->
+              <div
+                v-else-if="message.messageType === 'tool-call-node'"
+                class="agent-response-block"
+              >
+                <ToolCallingView v-if="message.content" :resultData="JSON.parse(message.content)" />
+              </div>
+              <!-- Markdown报告消息 -->
               <div
                 v-else-if="message.messageType === 'markdown-report'"
                 class="markdown-report-message"
@@ -176,6 +184,21 @@
                       />
                     </div>
                   </div>
+                  <!-- 如果是工具调用节点 -->
+                  <div
+                    v-else-if="nodeBlock.length > 0 && nodeBlock[0].nodeName === 'ToolCallNode'"
+                    class="agent-response-block"
+                  >
+                    <div class="agent-response-title">
+                      {{ nodeBlock[0].nodeName }}
+                    </div>
+                    <div class="agent-response-content">
+                      <ToolCallingView
+                        v-if="nodeBlock[0].text"
+                        :resultData="JSON.parse(nodeBlock[0].text)"
+                      />
+                    </div>
+                  </div>
                   <!-- 其他节点使用原来的 HTML 渲染方式 -->
                   <div v-else v-html="generateNodeHtml(nodeBlock)"></div>
                 </template>
@@ -228,15 +251,29 @@
                   >
                     <el-switch
                       v-model="requestOptions.humanFeedback"
-                      :disabled="requestOptions.nl2sqlOnly || isStreaming || showHumanFeedback"
+                      :disabled="
+                        requestOptions.nl2sqlOnly ||
+                        requestOptions.reactAgent ||
+                        isStreaming ||
+                        showHumanFeedback
+                      "
                     />
                   </el-tooltip>
                 </div>
+                <div class="switch-item">
+                  <span class="switch-label">智能推理</span>
+                  <el-switch
+                    v-model="requestOptions.reactAgent"
+                    :disabled="isStreaming || showHumanFeedback"
+                    @change="handleReactAgentChange"
+                  />
+                </div>
+
                 <div class="switch-item">
                   <span class="switch-label">仅NL2SQL</span>
                   <el-switch
                     v-model="requestOptions.nl2sqlOnly"
-                    :disabled="isStreaming || showHumanFeedback"
+                    :disabled="requestOptions.reactAgent || isStreaming || showHumanFeedback"
                     @change="handleNl2sqlOnlyChange"
                   />
                 </div>
@@ -354,18 +391,18 @@
 </template>
 
 <script lang="ts">
-  import { ref, defineComponent, onMounted, nextTick, computed } from 'vue';
+  import { computed, defineComponent, nextTick, onMounted, ref } from 'vue';
   import { useRoute } from 'vue-router';
   import { ElMessage } from 'element-plus';
   import {
-    Loading,
-    Promotion,
+    ArrowDown,
+    CircleClose,
+    Close,
     Document,
     Download,
-    CircleClose,
     FullScreen,
-    Close,
-    ArrowDown,
+    Loading,
+    Promotion,
   } from '@element-plus/icons-vue';
   import hljs from 'highlight.js';
   import { marked } from 'marked';
@@ -375,20 +412,14 @@
   import sql from 'highlight.js/lib/languages/sql';
   import python from 'highlight.js/lib/languages/python';
   import json from 'highlight.js/lib/languages/json';
-
-  // 注册语言
-  hljs.registerLanguage('sql', sql);
-  hljs.registerLanguage('python', python);
-  hljs.registerLanguage('json', json);
   import BaseLayout from '@/layouts/BaseLayout.vue';
-  import AgentService from '@/services/agent';
-  import ChatService, { type ChatSession, type ChatMessage } from '@/services/chat';
+  import AgentService, { type Agent } from '@/services/agent';
+  import ChatService, { type ChatMessage, type ChatSession } from '@/services/chat';
   import GraphService, {
-    type GraphRequest,
     type GraphNodeResponse,
+    type GraphRequest,
     TextType,
   } from '@/services/graph';
-  import { type Agent } from '@/services/agent';
   import {
     type ResultData,
     type ResultSetData,
@@ -401,6 +432,12 @@
   import MarkdownAgentContainer from '@/components/run/markdown';
   import ReportHtmlView from '@/components/run/ReportHtmlView.vue';
   import ResultSetDisplay from '@/components/run/ResultSetDisplay.vue';
+  import ToolCallingView from '@/components/run/ToolCallingView.vue';
+
+  // 注册语言
+  hljs.registerLanguage('sql', sql);
+  hljs.registerLanguage('python', python);
+  hljs.registerLanguage('json', json);
 
   // 扩展Window接口以包含自定义方法
   declare global {
@@ -428,6 +465,7 @@
       MarkdownAgentContainer,
       ReportHtmlView,
       ResultSetDisplay,
+      ToolCallingView,
     },
     created() {
       window.copyTextToClipboard = btn => {
@@ -514,12 +552,23 @@
       const requestOptions = ref({
         humanFeedback: false,
         nl2sqlOnly: false,
+        reactAgent: false,
         reportFormat: 'markdown' as 'markdown' | 'html', // 'markdown' | 'html'，控制报告展示方式
       });
       const showReportFullscreen = ref(false);
       const fullscreenReportContent = ref('');
       const inputControlsCollapsed = ref(false);
 
+      // 监听智能推理开关变化
+      const handleReactAgentChange = (value: boolean) => {
+        if (value) {
+          // 当智能推理开启时，禁用人工反馈，并设为false
+          requestOptions.value.humanFeedback = false;
+          // 禁用NL2SQL开关
+          requestOptions.value.nl2sqlOnly = false;
+        }
+      };
+
       // 监听NL2SQL开关变化
       const handleNl2sqlOnlyChange = (value: boolean) => {
         if (value) {
@@ -609,11 +658,17 @@
             query: userInput.value,
             humanFeedback: requestOptions.value.humanFeedback,
             nl2sqlOnly: requestOptions.value.nl2sqlOnly,
+            reactAgent: requestOptions.value.reactAgent,
             rejectedPlan: false,
             humanFeedbackContent: null,
             threadId: sessionState.lastRequest?.threadId || null,
           };
 
+          if (request.reactAgent) {
+            // threadId 不能为空，如果为空则默认一个uuid
+            request.threadId = request.threadId || crypto.randomUUID();
+          }
+
           userInput.value = '';
 
           await sendGraphRequest(request, true);
@@ -663,6 +718,22 @@
                 console.error('解析结果集JSON失败:', error);
               }
             }
+            // 特殊处理ToolCallNode
+            if (node.length > 0 && node[0].textType === TextType.TOOL_CALL_NODE) {
+              try {
+                const aiMessage: ChatMessage = {
+                  sessionId,
+                  role: 'assistant',
+                  content: node[0].text, // 保存原始JSON数据
+                  messageType: 'tool-call-node', // 使用特殊的messageType
+                };
+                return ChatService.saveMessage(sessionId, aiMessage).catch(error => {
+                  console.error('保存AI消息失败:', error);
+                });
+              } catch (error) {
+                console.error('解析结果集JSON失败:', error);
+              }
+            }
 
             // 使用generateNodeHtml方法生成HTML代码，确保显示与保存一致
             const nodeHtml = generateNodeHtml(node);
@@ -769,6 +840,41 @@
                 };
                 sessionState.nodeBlocks.push([newBlock]);
                 currentBlockIndex = sessionState.nodeBlocks.length - 1;
+              } else if (response.nodeName === 'ToolCallNode') {
+                const isNewNode: boolean =
+                  currentNodeName === null || response.nodeName !== currentNodeName;
+                if (isNewNode) {
+                  // 保存上一个节点的消息（如果有）
+                  if (currentBlockIndex >= 0 && sessionState.nodeBlocks[currentBlockIndex]) {
+                    const savePromise = saveNodeMessage(sessionState.nodeBlocks[currentBlockIndex]);
+                    pendingSavePromises.push(savePromise);
+                  }
+                  // 创建新的节点块
+                  const newBlock: GraphNodeResponse = {
+                    ...response,
+                    text: response.text,
+                    textType: TextType.TOOL_CALL_NODE,
+                  };
+                  sessionState.nodeBlocks.push([newBlock]);
+                  currentBlockIndex = sessionState.nodeBlocks.length - 1;
+                  currentNodeName = response.nodeName;
+                } else {
+                  // 保存当前节点的消息（在添加新元素之前保存）
+                  if (currentBlockIndex >= 0 && sessionState.nodeBlocks[currentBlockIndex]) {
+                    const currentNodeCopy = [...sessionState.nodeBlocks[currentBlockIndex]];
+                    const savePromise = saveNodeMessage(currentNodeCopy);
+                    pendingSavePromises.push(savePromise);
+                  }
+                  // 创建新的节点块
+                  const newBlock: GraphNodeResponse = {
+                    ...response,
+                    text: response.text,
+                    textType: TextType.TOOL_CALL_NODE,
+                  };
+                  sessionState.nodeBlocks.push([newBlock]);
+                  currentBlockIndex = sessionState.nodeBlocks.length - 1;
+                  currentNodeName = response.nodeName;
+                }
               } else {
                 // 处理其他节点（同步处理逻辑）
                 const isNewNode: boolean =
@@ -1368,6 +1474,7 @@
         formatMessageContent,
         formatNodeContent,
         generateNodeHtml,
+        handleReactAgentChange,
         handleNl2sqlOnlyChange,
         openReportFullscreen,
         closeReportFullscreen,
diff --git a/data-agent-management/pom.xml b/data-agent-management/pom.xml
index 2371dd4ea..bf74f4f52 100644
--- a/data-agent-management/pom.xml
+++ b/data-agent-management/pom.xml
@@ -169,6 +169,12 @@
             <artifactId>commons-collections</artifactId>
         </dependency>
 
+        <!-- ReactAgent依赖 -->
+        <dependency>
+            <groupId>com.alibaba.cloud.ai</groupId>
+            <artifactId>spring-ai-alibaba-agent-framework</artifactId>
+        </dependency>
+
         <dependency>
             <groupId>com.alibaba.cloud.ai</groupId>
             <artifactId>spring-ai-alibaba-graph-core</artifactId>
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/controller/GraphController.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/controller/GraphController.java
index 53230cfe1..3aa62a6ab 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/controller/GraphController.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/controller/GraphController.java
@@ -17,6 +17,7 @@
 
 import com.alibaba.cloud.ai.dataagent.dto.GraphRequest;
 import com.alibaba.cloud.ai.dataagent.service.graph.GraphService;
+import com.alibaba.cloud.ai.dataagent.service.react.ReactAgentService;
 import com.alibaba.cloud.ai.dataagent.vo.GraphNodeResponse;
 import jakarta.servlet.http.HttpServletResponse;
 import lombok.AllArgsConstructor;
@@ -43,13 +44,16 @@ public class GraphController {
 
 	private final GraphService graphService;
 
+	private final ReactAgentService reactAgentService;
+
 	@GetMapping(value = "/stream/search", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
 	public Flux<ServerSentEvent<GraphNodeResponse>> streamSearch(@RequestParam("agentId") String agentId,
 			@RequestParam(value = "threadId", required = false) String threadId, @RequestParam("query") String query,
 			@RequestParam(value = "humanFeedback", required = false) boolean humanFeedback,
 			@RequestParam(value = "humanFeedbackContent", required = false) String humanFeedbackContent,
 			@RequestParam(value = "rejectedPlan", required = false) boolean rejectedPlan,
-			@RequestParam(value = "nl2sqlOnly", required = false) boolean nl2sqlOnly, HttpServletResponse response) {
+			@RequestParam(value = "nl2sqlOnly", required = false) boolean nl2sqlOnly,
+			@RequestParam(value = "reactAgent", required = false) boolean reactAgent, HttpServletResponse response) {
 		// Set SSE-related HTTP headers
 		response.setCharacterEncoding("UTF-8");
 		response.setContentType("text/event-stream");
@@ -69,7 +73,13 @@ public Flux<ServerSentEvent<GraphNodeResponse>> streamSearch(@RequestParam("agen
 			.rejectedPlan(rejectedPlan)
 			.nl2sqlOnly(nl2sqlOnly)
 			.build();
-		graphService.graphStreamProcess(sink, request);
+		if (reactAgent) {
+			//
+			reactAgentService.reactStreamProcess(sink, request);
+		}
+		else {
+			graphService.graphStreamProcess(sink, request);
+		}
 
 		return sink.asFlux().filter(sse -> {
 			// 1. 如果 event 是 "complete" 或 "error"，直接放行（不管 text 是否为空）
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/dto/tool/ToolCallDTO.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/dto/tool/ToolCallDTO.java
new file mode 100644
index 000000000..fcd7a8e37
--- /dev/null
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/dto/tool/ToolCallDTO.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Licensed 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
+ *
+ *     https://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 com.alibaba.cloud.ai.dataagent.dto.tool;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class ToolCallDTO {
+
+	private String toolName;
+
+	private String input;
+
+	private String output;
+
+}
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/interceptor/ToolsInterceptor.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/interceptor/ToolsInterceptor.java
new file mode 100644
index 000000000..0afbf0eb2
--- /dev/null
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/interceptor/ToolsInterceptor.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Licensed 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
+ *
+ *     https://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 com.alibaba.cloud.ai.dataagent.interceptor;
+
+import com.alibaba.cloud.ai.graph.agent.interceptor.ToolCallHandler;
+import com.alibaba.cloud.ai.graph.agent.interceptor.ToolCallRequest;
+import com.alibaba.cloud.ai.graph.agent.interceptor.ToolCallResponse;
+import com.alibaba.cloud.ai.graph.agent.interceptor.ToolInterceptor;
+import java.util.ArrayList;
+import java.util.List;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+@Slf4j
+@Component
+public class ToolsInterceptor extends ToolInterceptor {
+
+	public interface ToolCallCallback {
+
+		void onToolCall(String threadId, String toolName, String input, String output);
+
+	}
+
+	private final List<ToolCallCallback> callbacks = new ArrayList<>();
+
+	@Override
+	public ToolCallResponse interceptToolCall(ToolCallRequest request, ToolCallHandler handler) {
+		log.debug("ToolInterceptor: Tool {} is called!", request.getToolName());
+		String threadId = request.getContext().get("thread_id").toString();
+		String inputs = request.getArguments();
+		// 调用所有回调
+		log.debug(" the tool callback start, size: {}", callbacks.size());
+		ToolCallResponse response = handler.call(request);
+		String output = response.getResult();
+		// 调用所有回调
+		for (ToolCallCallback callback : callbacks) {
+			try {
+				callback.onToolCall(threadId, request.getToolName(), inputs, output);
+			}
+			catch (Exception e) {
+				log.error("Error in tool call callback: {}", e.getMessage(), e);
+			}
+		}
+		return response;
+	}
+
+	@Override
+	public String getName() {
+		return "LogToolInterceptor";
+	}
+
+	public void addToolCallCallback(ToolCallCallback callback) {
+		log.debug("add tool call callback: {}", callback);
+		callbacks.add(callback);
+	}
+
+	public void removeToolCallCallback(ToolCallCallback callback) {
+		callbacks.remove(callback);
+	}
+
+}
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/prompt/PromptConstant.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/prompt/PromptConstant.java
index 8c9030375..f3fd37412 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/prompt/PromptConstant.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/prompt/PromptConstant.java
@@ -96,4 +96,9 @@ public static PromptTemplate getDataViewAnalyzePromptTemplate() {
 		return new PromptTemplate(PromptLoader.loadPrompt("data-view-analyze"));
 	}
 
+	// default-data-analysis.txt
+	public static PromptTemplate getDefaultDataAnalysisPromptTemplate() {
+		return new PromptTemplate(PromptLoader.loadPrompt("default-data-analysis"));
+	}
+
 }
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/prompt/PromptHelper.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/prompt/PromptHelper.java
index 29d3a4984..a9913f101 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/prompt/PromptHelper.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/prompt/PromptHelper.java
@@ -305,6 +305,12 @@ public static String buildEvidenceQueryRewritePrompt(String multiTurn, String la
 		return PromptConstant.getEvidenceQueryRewritePromptTemplate().render(params);
 	}
 
+	public static String buildDefaultDataAnalysisPrompt() {
+		Map<String, Object> params = new HashMap<>();
+		params.put("current_time", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+		return PromptConstant.getDefaultDataAnalysisPromptTemplate().render(params);
+	}
+
 	/**
 	 * 渲染优化提示词模板
 	 * @param optimizationPrompt 优化提示词模板
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ReactAgentRegistry.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ReactAgentRegistry.java
new file mode 100644
index 000000000..a966ee756
--- /dev/null
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ReactAgentRegistry.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Licensed 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
+ *
+ *     https://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 com.alibaba.cloud.ai.dataagent.service.aimodelconfig;
+
+import com.alibaba.cloud.ai.dataagent.dto.ModelConfigDTO;
+import com.alibaba.cloud.ai.dataagent.enums.ModelType;
+import com.alibaba.cloud.ai.dataagent.interceptor.ToolsInterceptor;
+import com.alibaba.cloud.ai.dataagent.prompt.PromptHelper;
+import com.alibaba.cloud.ai.graph.agent.ReactAgent;
+import com.alibaba.cloud.ai.graph.checkpoint.savers.MemorySaver;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.ai.chat.model.ChatModel;
+import org.springframework.stereotype.Component;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class ReactAgentRegistry {
+
+	private final DynamicModelFactory modelFactory;
+
+	private final ModelConfigDataService modelConfigDataService;
+
+	private final ToolFactory toolFactory;
+
+	private final ToolsInterceptor toolsInterceptor;
+
+	private volatile ReactAgent reactAgent;
+
+	// =========================================================
+	// 5. 构造ReactAgent
+	// =========================================================
+	public ReactAgent getReactAgent() {
+		if (reactAgent == null) {
+			synchronized (this) {
+				if (reactAgent == null) {
+					log.info("Initializing global ReactAgent...");
+					try {
+						ModelConfigDTO config = modelConfigDataService.getActiveConfigByType(ModelType.CHAT);
+						if (config != null) {
+							ChatModel chatModel = modelFactory.createChatModel(config);
+							// 核心：基于新 Model 创建新 Agent，彻底消除旧参数缓存
+							reactAgent = ReactAgent.builder()
+								.name("sql-agent")
+								.description(PromptHelper.buildDefaultDataAnalysisPrompt())
+								.model(chatModel)
+								.saver(new MemorySaver())
+								.tools(toolFactory.getTools())
+								.interceptors(toolsInterceptor)
+								.build();
+						}
+					}
+					catch (Exception e) {
+						log.error("Failed to initialize ReactAgent: {}", e.getMessage(), e);
+					}
+					// 兜底：如果还没初始化成功，抛出运行时异常，提示用户配置
+					if (reactAgent == null) {
+						throw new RuntimeException(
+								"No active CHAT model configured. Please configure it in the dashboard.");
+					}
+				}
+			}
+		}
+		return reactAgent;
+	}
+
+}
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ToolFactory.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ToolFactory.java
new file mode 100644
index 000000000..f978389be
--- /dev/null
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ToolFactory.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Licensed 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
+ *
+ *     https://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 com.alibaba.cloud.ai.dataagent.service.aimodelconfig;
+
+import com.alibaba.cloud.ai.dataagent.tools.ListTableSchemaTool;
+import com.alibaba.cloud.ai.dataagent.tools.SequentialThinkingTool;
+import com.alibaba.cloud.ai.dataagent.tools.SqlExecuteTool;
+import com.alibaba.cloud.ai.dataagent.tools.TodoWriteTool;
+import java.util.ArrayList;
+import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.ai.tool.ToolCallback;
+import org.springframework.stereotype.Component;
+
+@Slf4j
+@AllArgsConstructor
+@Component
+public class ToolFactory {
+
+	private final SequentialThinkingTool sequentialThinkingTool;
+
+	private final TodoWriteTool todoWriteTool;
+
+	private final ListTableSchemaTool listTablesTool;
+
+	private final SqlExecuteTool sqlExecuteTool;
+
+	private List<ToolCallback> tools = new ArrayList<>();
+
+	public List<ToolCallback> getTools() {
+		if (tools == null || tools.isEmpty()) {
+			// TODO 这里应该根据UI上的配置来觉得用哪些工具
+			tools.add(todoWriteTool.toolCallback());
+			tools.add(sequentialThinkingTool.toolCallback());
+			tools.add(listTablesTool.toolCallback());
+			tools.add(sqlExecuteTool.toolCallback());
+		}
+		return tools;
+	}
+
+}
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/graph/Context/StreamContext.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/graph/Context/StreamContext.java
index d31bb85c9..ae17519da 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/graph/Context/StreamContext.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/graph/Context/StreamContext.java
@@ -39,6 +39,8 @@ public class StreamContext {
 
 	private TextType textType;
 
+	private String agentId;
+
 	/**
 	 * 标记是否已经清理，用于防止重复清理
 	 */
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentService.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentService.java
new file mode 100644
index 000000000..b90f74a33
--- /dev/null
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentService.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Licensed 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
+ *
+ *     https://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 com.alibaba.cloud.ai.dataagent.service.react;
+
+import com.alibaba.cloud.ai.dataagent.dto.GraphRequest;
+import com.alibaba.cloud.ai.dataagent.vo.GraphNodeResponse;
+import org.springframework.http.codec.ServerSentEvent;
+import reactor.core.publisher.Sinks;
+
+public interface ReactAgentService {
+
+	void reactStreamProcess(Sinks.Many<ServerSentEvent<GraphNodeResponse>> sink, GraphRequest request);
+
+	void stopStreamProcessing(String threadId);
+
+}
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentServiceImpl.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentServiceImpl.java
new file mode 100644
index 000000000..702e91105
--- /dev/null
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentServiceImpl.java
@@ -0,0 +1,307 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Licensed 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
+ *
+ *     https://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 com.alibaba.cloud.ai.dataagent.service.react;
+
+import static com.alibaba.cloud.ai.dataagent.constant.Constant.STREAM_EVENT_COMPLETE;
+import static com.alibaba.cloud.ai.dataagent.constant.Constant.STREAM_EVENT_ERROR;
+
+import com.alibaba.cloud.ai.dataagent.dto.GraphRequest;
+import com.alibaba.cloud.ai.dataagent.dto.tool.ToolCallDTO;
+import com.alibaba.cloud.ai.dataagent.enums.TextType;
+import com.alibaba.cloud.ai.dataagent.interceptor.ToolsInterceptor;
+import com.alibaba.cloud.ai.dataagent.interceptor.ToolsInterceptor.ToolCallCallback;
+import com.alibaba.cloud.ai.dataagent.service.aimodelconfig.ReactAgentRegistry;
+import com.alibaba.cloud.ai.dataagent.service.graph.Context.MultiTurnContextManager;
+import com.alibaba.cloud.ai.dataagent.service.graph.Context.StreamContext;
+import com.alibaba.cloud.ai.dataagent.util.JsonUtil;
+import com.alibaba.cloud.ai.dataagent.vo.GraphNodeResponse;
+import com.alibaba.cloud.ai.dataagent.workflow.node.PlannerNode;
+import com.alibaba.cloud.ai.graph.RunnableConfig;
+import com.alibaba.cloud.ai.graph.agent.ReactAgent;
+import com.alibaba.cloud.ai.graph.exception.GraphRunnerException;
+import com.alibaba.cloud.ai.graph.exception.GraphStateException;
+import com.alibaba.cloud.ai.graph.streaming.StreamingOutput;
+import java.util.Date;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.codec.ServerSentEvent;
+import org.springframework.stereotype.Service;
+import reactor.core.Disposable;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Sinks;
+
+@Slf4j
+@Service
+public class ReactAgentServiceImpl implements ReactAgentService {
+
+	private final ReactAgentRegistry reactAgentRegistry;
+
+	private final Map<String, StreamContext> streamContextMap = new ConcurrentHashMap<>();
+
+	private final ExecutorService executor;
+
+	private final MultiTurnContextManager multiTurnContextManager;
+
+	private final ToolsInterceptor toolsInterceptor;
+
+	public ReactAgentServiceImpl(ExecutorService executor, ReactAgentRegistry reactAgentRegistry,
+			MultiTurnContextManager multiTurnContextManager, ToolsInterceptor toolsInterceptor)
+			throws GraphStateException {
+		this.executor = executor;
+		this.reactAgentRegistry = reactAgentRegistry;
+		this.multiTurnContextManager = multiTurnContextManager;
+		this.toolsInterceptor = toolsInterceptor;
+
+		// 添加工具调用回调
+		this.toolsInterceptor.addToolCallCallback(new ToolCallCallback() {
+			@Override
+			public void onToolCall(String threadId, String toolName, String input, String output) {
+				ReactAgentServiceImpl.this.handleToolCall(threadId, toolName, input, output);
+			}
+
+		});
+	}
+
+	@Override
+	public void reactStreamProcess(Sinks.Many<ServerSentEvent<GraphNodeResponse>> sink, GraphRequest request) {
+		String threadId = request.getThreadId();
+		String agentId = request.getAgentId();
+		String query = request.getQuery();
+
+		ReactAgent reactAgent = reactAgentRegistry.getReactAgent();
+		RunnableConfig config = RunnableConfig.builder()
+			.threadId(threadId)
+			.addMetadata("thread_id", threadId)
+			.addMetadata("agent_id", agentId)
+			.addMetadata("current_time", new Date().toString())
+			.build();
+		// 创建并存储 StreamContext
+		StreamContext context = streamContextMap.computeIfAbsent(threadId, k -> new StreamContext());
+		context.setSink(sink);
+		// 过滤掉开始和结束事件
+		Flux<?> nodeOutputFlux = null;
+		try {
+			nodeOutputFlux = reactAgent.stream(query, config)
+				.filter(nodeOutput -> !nodeOutput.isSTART() && !nodeOutput.isEND());
+		}
+		catch (GraphRunnerException e) {
+			log.error("Error streaming node outputs for threadId: {}", threadId, e);
+			throw new RuntimeException(e);
+		}
+		subscribeToFlux(context, nodeOutputFlux, agentId, threadId);
+	}
+
+	@Override
+	public void stopStreamProcessing(String threadId) {
+		log.info("Stopping stream processing for threadId: {}", threadId);
+		StreamContext context = streamContextMap.remove(threadId);
+		if (context != null) {
+			context.cleanup();
+		}
+	}
+
+	/**
+	 * 订阅 Flux 并原子性地设置 Disposable 线程安全：使用 synchronized 确保 Disposable 设置的原子性
+	 * @param context 流式处理上下文
+	 * @param nodeOutputFlux 节点输出流
+	 * @param agentId 代理ID
+	 * @param threadId 线程ID
+	 */
+	private void subscribeToFlux(StreamContext context, Flux<?> nodeOutputFlux, String agentId, String threadId) {
+		CompletableFuture.runAsync(() -> {
+			// 在订阅之前检查上下文是否仍然有效
+			if (context.isCleaned()) {
+				log.debug("StreamContext cleaned before subscription for threadId: {}", threadId);
+				return;
+			}
+			Disposable disposable = nodeOutputFlux.subscribe(output -> handleNodeOutput(output, agentId, threadId),
+					error -> handleStreamError(agentId, threadId, error),
+					() -> handleStreamComplete(agentId, threadId));
+			// 原子性地设置 Disposable，如果已经清理则立即释放
+			synchronized (context) {
+				if (context.isCleaned()) {
+					// 如果已经清理，立即释放刚创建的 Disposable
+					if (disposable != null && !disposable.isDisposed()) {
+						disposable.dispose();
+					}
+				}
+				else {
+					// 只有在未清理的情况下才设置 Disposable
+					context.setDisposable(disposable);
+				}
+			}
+		}, executor);
+	}
+
+	/**
+	 * 处理节点输出
+	 */
+	private void handleNodeOutput(Object nodeOutput, String agentId, String threadId) {
+		StreamContext context = streamContextMap.get(threadId);
+		// 检查是否已经停止处理
+		if (context == null || context.getSink() == null) {
+			log.debug("Stream processing already stopped for threadId: {}, skipping output", threadId);
+			return;
+		}
+		if (nodeOutput instanceof StreamingOutput streamingOutput) {
+			handleStreamNodeOutput(threadId, agentId, streamingOutput);
+		}
+	}
+
+	/**
+	 * 处理流式错误 线程安全：使用 remove 操作确保只有一个线程能获取到 context
+	 */
+	private void handleStreamError(String agentId, String threadId, Throwable error) {
+		log.error("Error in stream processing for threadId: {}: ", threadId, error);
+		StreamContext context = streamContextMap.remove(threadId);
+		if (context != null && !context.isCleaned() && context.getSink() != null) {
+			// 检查 sink 是否还有订阅者
+			if (context.getSink().currentSubscriberCount() > 0) {
+				context.getSink()
+					.tryEmitNext(ServerSentEvent
+						.builder(GraphNodeResponse.error(agentId, threadId,
+								"Error in stream processing: " + error.getMessage()))
+						.event(STREAM_EVENT_ERROR)
+						.build());
+				context.getSink().tryEmitComplete();
+			}
+			// 清理资源（cleanup 内部已经保证只执行一次）
+			context.cleanup();
+		}
+	}
+
+	/**
+	 * 处理流式完成 线程安全：使用 remove 操作确保只有一个线程能获取到 context
+	 */
+	private void handleStreamComplete(String agentId, String threadId) {
+		log.info("Stream processing completed successfully for threadId: {}", threadId);
+		StreamContext context = streamContextMap.remove(threadId);
+		if (context != null && !context.isCleaned() && context.getSink() != null) {
+			if (context.getSink().currentSubscriberCount() > 0) {
+				context.getSink()
+					.tryEmitNext(ServerSentEvent.builder(GraphNodeResponse.complete(agentId, threadId))
+						.event(STREAM_EVENT_COMPLETE)
+						.build());
+				context.getSink().tryEmitComplete();
+			}
+			context.cleanup();
+		}
+	}
+
+	private void handleStreamNodeOutput(String threadId, String agentId, StreamingOutput output) {
+		StreamContext context = streamContextMap.get(threadId);
+		// 检查是否已经停止处理
+		if (context == null || context.getSink() == null) {
+			log.debug("Stream processing already stopped for threadId: {}, skipping output", threadId);
+			return;
+		}
+		String node = output.node();
+		String chunk = output.chunk();
+
+		if (RunnableConfig.AGENT_MODEL_NAME.equals(node)) {
+			// 最终的结果使用reportnode进行展示即可
+			node = "ReportGeneratorNode";
+		}
+		log.debug("Received Stream output: node={}, chunk={}", node, chunk);
+
+		if (chunk == null || chunk.isEmpty()) {
+			return;
+		}
+
+		// 如果是文本标记符号，则更新文本类型
+		TextType originType = context.getTextType();
+		TextType textType;
+		boolean isTypeSign = false;
+		if (originType == null) {
+			textType = TextType.getTypeByStratSign(chunk);
+			if (textType != TextType.TEXT) {
+				isTypeSign = true;
+			}
+			context.setTextType(textType);
+		}
+		else {
+			textType = TextType.getType(originType, chunk);
+			if (textType != originType) {
+				isTypeSign = true;
+			}
+			context.setTextType(textType);
+		}
+		// 文本标记符号不返回给前端
+		if (!isTypeSign) {
+			if (PlannerNode.class.getSimpleName().equals(node)) {
+				multiTurnContextManager.appendPlannerChunk(threadId, chunk);
+			}
+			GraphNodeResponse response = GraphNodeResponse.builder()
+				.agentId(agentId)
+				.threadId(threadId)
+				.nodeName(node)
+				.text(chunk)
+				.textType(TextType.MARK_DOWN)
+				.build();
+			// 检查发送是否成功，如果失败说明客户端已断开
+			Sinks.EmitResult result = context.getSink().tryEmitNext(ServerSentEvent.builder(response).build());
+			if (result.isFailure()) {
+				log.warn("Failed to emit data to sink for threadId: {}, result: {}. Stopping stream processing.",
+						threadId, result);
+				// 如果发送失败，停止处理
+				stopStreamProcessing(threadId);
+			}
+		}
+	}
+
+	/**
+	 * 处理工具调用，将工具调用的输入和输出写出到流中
+	 */
+	private void handleToolCall(String threadId, String toolName, String input, String output) {
+		log.debug("handleToolCall: threadId={}, toolName={}, input={}, output={}", threadId, toolName, input, output);
+		StreamContext context = streamContextMap.get(threadId);
+		// 检查是否已经停止处理
+		if (context == null || context.getSink() == null) {
+			log.debug("Stream processing already stopped for threadId: {}, skipping tool call output", threadId);
+			return;
+		}
+
+		try {
+			ToolCallDTO toolCallDTO = new ToolCallDTO(toolName, input, output);
+			// 创建 GraphNodeResponse
+			GraphNodeResponse response = GraphNodeResponse.builder()
+				.agentId(context.getAgentId())
+				.threadId(threadId)
+				.nodeName("ToolCallNode")
+				.text(JsonUtil.getObjectMapper().writeValueAsString(toolCallDTO))
+				.textType(TextType.JSON)
+				.build();
+
+			// 写出到流中
+			Sinks.EmitResult result = context.getSink().tryEmitNext(ServerSentEvent.builder(response).build());
+
+			if (result.isFailure()) {
+				log.warn(
+						"Failed to emit tool call data to sink for threadId: {}, result: {}. Stopping stream processing.",
+						threadId, result);
+				// 如果发送失败，停止处理
+				stopStreamProcessing(threadId);
+			}
+		}
+		catch (Exception e) {
+			log.error("Error processing tool call: {}", e.getMessage(), e);
+		}
+	}
+
+}
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/ListTableSchemaTool.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/ListTableSchemaTool.java
new file mode 100644
index 000000000..ba9368cea
--- /dev/null
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/ListTableSchemaTool.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Licensed 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
+ *
+ *     https://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 com.alibaba.cloud.ai.dataagent.tools;
+
+import com.alibaba.cloud.ai.dataagent.constant.DocumentMetadataConstant;
+import com.alibaba.cloud.ai.dataagent.mapper.AgentDatasourceMapper;
+import com.alibaba.cloud.ai.dataagent.service.schema.SchemaService;
+import com.fasterxml.jackson.annotation.JsonClassDescription;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonPropertyDescription;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.BiFunction;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.ai.chat.model.ToolContext;
+import org.springframework.ai.document.Document;
+import org.springframework.ai.tool.ToolCallback;
+import org.springframework.ai.tool.function.FunctionToolCallback;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+
+@AllArgsConstructor
+@Slf4j
+@Component
+public class ListTableSchemaTool implements BiFunction<ListTableSchemaTool.Request, ToolContext, String> {
+
+	private final SchemaService schemaService;
+
+	private final AgentDatasourceMapper agentDatasourceMapper;
+
+	@Override
+	public String apply(Request request, ToolContext toolContext) {
+		log.info("========== List Table schema Tool Start ==========");
+
+		Long agentId = null;
+		if (toolContext.getContext().get("agent_id") != null) {
+			agentId = Long.parseLong((String) toolContext.getContext().get("agent_id"));
+		}
+
+		if (agentId == null) {
+			log.error("agent_id is null, please check the context");
+			return "Error listing table schemas: agent_id is null, please check the context.";
+		}
+		try {
+			// 查询 Agent 的激活数据源
+			Integer datasourceId = agentDatasourceMapper.selectActiveDatasourceIdByAgentId(agentId);
+
+			List<Document> tableDocuments = new ArrayList<>(
+					schemaService.getTableDocumentsByDatasource(datasourceId, request.query()));
+			// extract table names
+			List<String> recalledTableNames = extractTableName(tableDocuments);
+			List<Document> columnDocuments = schemaService.getColumnDocumentsByTableName(datasourceId,
+					recalledTableNames);
+			if (recalledTableNames.isEmpty()) {
+				log.info("No tables found in the database");
+				return "No tables found in the database.";
+			}
+			StringBuilder sb = new StringBuilder();
+			int index = 1;
+			for (String tableName : recalledTableNames) {
+				sb.append("## result").append(index).append(": \n");
+				sb.append(tableName).append("\n");
+				List<Document> columns = columnDocuments.stream()
+					.filter(p -> p.getMetadata().get(DocumentMetadataConstant.TABLE_NAME) != null
+							&& p.getMetadata().get(DocumentMetadataConstant.TABLE_NAME).equals(tableName))
+					.toList();
+				if (!columns.isEmpty()) {
+					sb.append("  ---- Columns ----\n");
+				}
+				for (Document column : columns) {
+					String columnName = (String) column.getMetadata().get("name");
+					String columnComment = (String) column.getMetadata().get("description");
+					sb.append("      ").append(columnName);
+					if (StringUtils.hasText(columnComment)) {
+						sb.append("  comment: ").append(columnComment);
+					}
+					sb.append("\n");
+				}
+				index++;
+			}
+			log.info("Found {} tables: {}", recalledTableNames.size(), sb);
+			log.info("========== List Table schema Tool End ==========");
+			return sb.toString();
+		}
+		catch (Exception e) {
+			log.error("Error listing tables", e);
+			return "Error listing tables: " + e.getMessage();
+		}
+	}
+
+	public ToolCallback toolCallback() {
+		return FunctionToolCallback.builder("list_table_schema", this)
+			.description(
+					"""
+							# Semantic/vector search tool for retrieving relevant database table Schema from knowledge base based on business intent
+							This tool uses embeddings to understand the user's business-related query and find semantically relevant database table structure information, including table details and column specifications, to provide a foundation for subsequent SQL statement generation.
+							## Purpose
+							Designed for retrieving database table Schema information aligned with user business needs, specifically to:
+							- Obtain table names and their Chinese names associated with the target business scenario
+							- Retrieve detailed column information including column names, data types, and Chinese names
+							- Provide accurate structural references to guide correct SQL statement drafting
+							- Identify all relevant tables and columns required to fulfill the user's data retrieval or analysis needs via SQL
+							The tool searches by business intent and data relevance rather than exact keyword matching, ensuring it captures all tables/columns related to the user's data request context.
+							## What the Tool Does NOT Do
+							- Does NOT perform literal keyword-only matching without considering business contextual relevance
+							- Does NOT return actual business data records (only table and column structure metadata)
+							- Should NOT be used for conceptual explanations unrelated to database Schema
+							- Should NOT process queries that do not involve data retrieval or SQL generation requirements
+							- Does NOT generate SQL statements directly (only provides Schema information to support subsequent SQL creation)
+							## Required Input Behavior
+							"query" must contain **well-formed semantic questions or intent statements** that clearly express the business data need and corresponding Schema retrieval requirement.
+							Each query should represent a **business data scenario, data analysis requirement, or specific data element need** that points to the database table structure needed, such as:
+							- Business process-related data scenarios (e.g., order creation, user payment)
+							- Specific data element tracking needs (e.g., user membership points, product inventory levels)
+							- Data analysis scope requirements (e.g., tables for monthly sales performance analysis)
+							- Contextual data association needs (e.g., tables linked to user delivery information)
+							Avoid:
+							- Isolated keyword lists without business context
+							- Raw unprocessed user messages that don't clarify Schema retrieval intent
+							- Full paragraphs of business logic description without explicit Schema focus
+							- Queries centered on business logic explanations rather than table structure needs
+							## Examples of valid query shapes (not content):
+							- "Which tables store user order related data and their column structures?"
+							- "Retrieve Schema information of tables associated with user payment records"
+							- "What tables contain user delivery address fields, including column details?"
+							- "Get table structures for product inventory management scenarios"
+							- "Which tables are needed to analyze sales performance, along with their column specs?"
+							## Parameters
+							- query (required): questions or intent statements.
+							  These should reflect the business data context and the specific Schema information you aim to retrieve.
+							## Output
+							Returns chunks ranked by semantic relevance to the business intent, reranked when applicable.
+							Results contain structured database Schema information including:
+							- Table name
+							- Table Chinese name
+							- Column name
+							- Column data type
+							- Column Chinese name
+							The results are intended to provide clear, context-aligned structural references for subsequent SQL statement generation.
+							""")
+			.inputType(Request.class)
+			.build();
+	}
+
+	@JsonClassDescription("Request to list matched database tables and schema")
+	public record Request(@JsonProperty(value = "query",
+			required = true) @JsonPropertyDescription("The search query to find relevant documentation. "
+					+ "Be specific and include key terms related to your question.") String query) {
+
+	}
+
+	private static List<String> extractTableName(List<Document> tableDocuments) {
+		List<String> tableNames = new ArrayList<>();
+		// metadata中的name字段
+		for (Document document : tableDocuments) {
+			String name = (String) document.getMetadata().get("name");
+			if (name != null && !name.isEmpty()) {
+				tableNames.add(name);
+			}
+		}
+		log.info("At this SchemaRecallNode, Recall tables are: {}", tableNames);
+		return tableNames;
+	}
+
+}
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SequentialThinkingTool.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SequentialThinkingTool.java
new file mode 100644
index 000000000..f44ebe0ed
--- /dev/null
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SequentialThinkingTool.java
@@ -0,0 +1,216 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Licensed 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
+ *
+ *     https://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 com.alibaba.cloud.ai.dataagent.tools;
+
+import com.fasterxml.jackson.annotation.JsonClassDescription;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonPropertyDescription;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiFunction;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.ai.chat.model.ToolContext;
+import org.springframework.ai.tool.ToolCallback;
+import org.springframework.ai.tool.function.FunctionToolCallback;
+import org.springframework.stereotype.Component;
+
+@Slf4j
+@AllArgsConstructor
+@Component
+public class SequentialThinkingTool implements BiFunction<SequentialThinkingTool.Request, ToolContext, String> {
+
+	private final List<Request> thoughtHistory = new ArrayList<>();
+
+	private final Map<String, List<Request>> branches = new HashMap<>();
+
+	@Override
+	public String apply(Request request, ToolContext toolContext) {
+		log.info("========== Sequential Thinking Tool Start ==========");
+
+		try {
+			// Validate input
+			if (!validate(request)) {
+				return "Validation failed: Invalid input parameters";
+			}
+
+			// Adjust totalThoughts if thoughtNumber exceeds it
+			if (request.thoughtNumber() > request.totalThoughts()) {
+				request = new Request(request.thought(), request.nextThoughtNeeded(), request.thoughtNumber(),
+						request.thoughtNumber(), // Update totalThoughts
+						request.isRevision(), request.revisesThought(), request.branchFromThought(), request.branchId(),
+						request.needsMoreThoughts());
+			}
+
+			// Add to thought history
+			thoughtHistory.add(request);
+
+			// Handle branching
+			if (request.branchFromThought() != null && request.branchId() != null && !request.branchId().isEmpty()) {
+				branches.computeIfAbsent(request.branchId(), k -> new ArrayList<>()).add(request);
+			}
+
+			log.info("thinking Thought: {}", request.thought());
+
+			// Prepare response data
+			List<String> branchKeys = new ArrayList<>(branches.keySet());
+			boolean incomplete = request.nextThoughtNeeded()
+					|| (request.needsMoreThoughts() != null && request.needsMoreThoughts())
+					|| request.thoughtNumber() < request.totalThoughts();
+
+			Map<String, Object> responseData = new HashMap<>();
+			responseData.put("thought_number", request.thoughtNumber());
+			responseData.put("total_thoughts", request.totalThoughts());
+			responseData.put("next_thought_needed", request.nextThoughtNeeded());
+			responseData.put("branches", branchKeys);
+			responseData.put("thought_history_length", thoughtHistory.size());
+			responseData.put("display_type", "thinking");
+			responseData.put("thought", request.thought());
+			responseData.put("incomplete_steps", incomplete);
+
+			log.info("thinking Execute completed - Thought {}/{}", request.thoughtNumber(), request.totalThoughts());
+
+			String outputMsg = "Thought process recorded";
+			if (incomplete) {
+				outputMsg = "Thought process recorded - unfinished steps remain, continue exploring and calling tools";
+			}
+
+			log.info("========== Sequential Thinking Tool End ==========");
+			return outputMsg;
+		}
+		catch (Exception e) {
+			log.error("Error in sequential thinking tool", e);
+			return "Error in sequential thinking tool: " + e.getMessage();
+		}
+	}
+
+	public ToolCallback toolCallback() {
+		return FunctionToolCallback.builder("sequential_thinking", this)
+			.description(
+					"""
+							A detailed tool for dynamic and reflective problem-solving through thoughts.
+							This tool helps analyze problems through a flexible thinking process that can adapt and evolve.
+							Each thought can build on, question, or revise previous insights as understanding deepens.
+							## When to Use This Tool
+							- Breaking down complex problems into steps
+							- Planning and design with room for revision
+							- Analysis that might need course correction
+							- Problems where the full scope might not be clear initially
+							- Problems that require a multi-step solution
+							- Tasks that need to maintain context over multiple steps
+							- Situations where irrelevant information needs to be filtered out
+							## Typical Application Scenarios
+							This tool is particularly useful for data analysis workflows involving:
+							- Understanding user business intent from natural language queries
+							- Identifying relevant database tables and columns for the business scenario
+							- Planning SQL query structure based on data requirements
+							- Analyzing query results and extracting meaningful insights
+							- Iterating on SQL statements when results don't meet expectations
+							- Combining multiple data sources to answer complex questions
+							- Validating data quality and completeness before drawing conclusions
+							- Explaining analytical findings in business-friendly language
+							## Key Features
+							- You can adjust total_thoughts up or down as you progress
+							- You can question or revise previous thoughts
+							- You can add more thoughts even after reaching what seemed like the end
+							- You can express uncertainty and explore alternative approaches
+							- Not every thought needs to build linearly - you can branch or backtrack
+							- Generates a solution hypothesis
+							- Verifies the hypothesis based on the Chain of Thought steps
+							- Repeats the process until satisfied
+							- Provides a correct answer
+							## Parameters Explained
+							- **thought**: Your current thinking step, which can include:
+							  * Regular analytical steps
+							  * Revisions of previous thoughts
+							  * Questions about previous decisions
+							  * Realizations about needing more analysis
+							  * Changes in approach
+							  * Hypothesis generation
+							  * Hypothesis verification
+
+							  **CRITICAL - User-Friendly Thinking**: Write your thoughts in natural, user-friendly language. NEVER mention tool names (like "grep_chunks", "knowledge_search", "web_search", etc.) in your thinking process. Instead, describe your actions in plain language:
+							  - ❌ BAD: "I'll use list_table_schema to search for keywords, then sql_execute for semantic understanding"
+							  - ✅ GOOD: "I'll start by searching for key terms in the knowledge, then explore related concepts"
+							  - ❌ BAD: "After list_table_schema returns results, I'll use sql_execute"
+							  - ✅ GOOD: "After finding relevant documents, I'll search for semantically related content"
+
+							  Write thinking as if explaining your reasoning to a user, not documenting technical steps. Focus on WHAT you're trying to find and WHY, not HOW (which tools you'll use).
+							- **next_thought_needed**: True if you need more thinking, even if at what seemed like the end
+							- **thought_number**: Current number in sequence (can go beyond initial total if needed)
+							- **total_thoughts**: Current estimate of thoughts needed (can be adjusted up/down)
+							- **is_revision**: A boolean indicating if this thought revises previous thinking
+							- **revises_thought**: If is_revision is true, which thought number is being reconsidered
+							- **branch_from_thought**: If branching, which thought number is the branching point
+							- **branch_id**: Identifier for the current branch (if any)
+							- **needs_more_thoughts**: If reaching end but realizing more thoughts needed
+							""")
+			.inputType(Request.class)
+			.build();
+	}
+
+	@JsonClassDescription("Request for sequential thinking tool")
+	public record Request(@JsonProperty(value = "thought",
+			required = true) @JsonPropertyDescription("Your current thinking step. Write in natural, user-friendly language. NEVER mention tool names (like \"list_table_schema\", \"sql_execute\", \"web_search\", etc.). Instead, describe actions in plain language (e.g., \"I'll search for key terms\" instead of \"I'll use list_table_schema\"). Focus on WHAT you're trying to find and WHY, not HOW (which tools you'll use).") String thought,
+
+			@JsonProperty(value = "next_thought_needed",
+					required = true) @JsonPropertyDescription("Whether another thought step is needed") boolean nextThoughtNeeded,
+
+			@JsonProperty(value = "thought_number",
+					required = true) @JsonPropertyDescription("Current thought number (numeric value, e.g., 1, 2, 3)") int thoughtNumber,
+
+			@JsonProperty(value = "total_thoughts",
+					required = true) @JsonPropertyDescription("Estimated total thoughts needed (numeric value, e.g., 5, 10)") int totalThoughts,
+
+			@JsonProperty(
+					value = "is_revision") @JsonPropertyDescription("Whether this revises previous thinking") Boolean isRevision,
+
+			@JsonProperty(
+					value = "revises_thought") @JsonPropertyDescription("Which thought is being reconsidered") Integer revisesThought,
+
+			@JsonProperty(
+					value = "branch_from_thought") @JsonPropertyDescription("Branching point thought number") Integer branchFromThought,
+
+			@JsonProperty(value = "branch_id") @JsonPropertyDescription("Branch identifier") String branchId,
+
+			@JsonProperty(
+					value = "needs_more_thoughts") @JsonPropertyDescription("If more thoughts are needed") Boolean needsMoreThoughts) {
+
+	}
+
+	private boolean validate(Request request) {
+		// Validate thought (required)
+		if (request.thought() == null || request.thought().isEmpty()) {
+			log.error("Invalid thought: must be a non-empty string");
+			return false;
+		}
+
+		// Validate thoughtNumber (required)
+		if (request.thoughtNumber() < 1) {
+			log.error("Invalid thoughtNumber: must be >= 1");
+			return false;
+		}
+		// Validate totalThoughts (required)
+		if (request.totalThoughts() < 1) {
+			log.error("Invalid totalThoughts: must be >= 1");
+			return false;
+		}
+		return true;
+	}
+
+}
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SqlExecuteTool.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SqlExecuteTool.java
new file mode 100644
index 000000000..2dfe8740d
--- /dev/null
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SqlExecuteTool.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Licensed 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
+ *
+ *     https://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 com.alibaba.cloud.ai.dataagent.tools;
+
+import com.alibaba.cloud.ai.dataagent.bo.DbConfigBO;
+import com.alibaba.cloud.ai.dataagent.bo.schema.ResultSetBO;
+import com.alibaba.cloud.ai.dataagent.connector.DbQueryParameter;
+import com.alibaba.cloud.ai.dataagent.connector.accessor.Accessor;
+import com.alibaba.cloud.ai.dataagent.util.DatabaseUtil;
+import com.alibaba.cloud.ai.dataagent.util.JsonUtil;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonPropertyDescription;
+import java.util.function.BiFunction;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.ai.chat.model.ToolContext;
+import org.springframework.ai.tool.ToolCallback;
+import org.springframework.ai.tool.function.FunctionToolCallback;
+import org.springframework.stereotype.Component;
+
+/**
+ * SQL执行工具，用于执行SQL查询并返回结果
+ * <p>
+ * 参考了 SqlExecuteNode.java 中的 SQL 执行逻辑
+ * </p>
+ */
+@Slf4j
+@AllArgsConstructor
+@Component
+public class SqlExecuteTool implements BiFunction<SqlExecuteTool.Request, ToolContext, String> {
+
+	private final DatabaseUtil databaseUtil;
+
+	@Override
+	public String apply(Request request, ToolContext toolContext) {
+		log.info("========== SQL Execute Tool Start ==========");
+
+		try {
+			// 验证输入
+			Long agentId = null;
+			if (toolContext.getContext().get("agent_id") != null) {
+				agentId = Long.parseLong((String) toolContext.getContext().get("agent_id"));
+			}
+
+			if (agentId == null) {
+				log.error("agent_id is null, please check the context");
+				return "Error listing tables: agent_id is null, please check the context.";
+			}
+
+			if (request.sql() == null || request.sql().isEmpty()) {
+				return "SQL statement is required";
+			}
+
+			// 获取数据库配置
+			DbConfigBO dbConfig = databaseUtil.getAgentDbConfig(agentId);
+			if (dbConfig == null) {
+				return "Database configuration not found for agent ID: " + agentId;
+			}
+
+			// 创建查询参数
+			DbQueryParameter dbQueryParameter = new DbQueryParameter();
+			dbQueryParameter.setSql(request.sql());
+			dbQueryParameter.setSchema(dbConfig.getSchema());
+
+			// 获取数据库访问器
+			Accessor dbAccessor = databaseUtil.getAgentAccessor(agentId);
+			if (dbAccessor == null) {
+				return "Database accessor not found for agent ID: " + agentId;
+			}
+
+			// 执行SQL查询
+			ResultSetBO resultSetBO = dbAccessor.executeSqlAndReturnObject(dbConfig, dbQueryParameter);
+
+			// 生成执行结果
+			String result = generateExecutionResult(request.sql(), resultSetBO);
+
+			log.info("========== SQL Execute Tool End ==========");
+			return result;
+		}
+		catch (Exception e) {
+			log.error("Error executing SQL: {}", e.getMessage(), e);
+			return "Error executing SQL: " + e.getMessage();
+		}
+	}
+
+	/**
+	 * 生成SQL执行结果
+	 */
+	private String generateExecutionResult(String sql, ResultSetBO resultSetBO) throws Exception {
+		StringBuilder result = new StringBuilder();
+
+		result.append("# SQL执行结果\n\n");
+		result.append("## 执行的SQL\n");
+		result.append("```sql\n").append(sql).append("\n```\n\n");
+
+		if (resultSetBO != null) {
+			result.append("## 执行结果\n");
+			result.append("- 行数: ")
+				.append(resultSetBO.getData() != null ? resultSetBO.getData().size() : 0)
+				.append("\n\n");
+
+			if (resultSetBO.getData() != null && !resultSetBO.getData().isEmpty()) {
+				result.append("## 数据预览\n");
+				String resultJson = JsonUtil.getObjectMapper().writeValueAsString(resultSetBO.getData());
+				result.append("```json\n").append(resultJson).append("\n```\n");
+			}
+		}
+		else {
+			result.append("## 执行结果\n");
+			result.append("- 无数据返回\n");
+		}
+
+		return result.toString();
+	}
+
+	/**
+	 * SQL执行工具请求参数
+	 */
+	public record Request(@JsonProperty(value = "sql",
+			required = true) @JsonPropertyDescription("SQL statement to execute") String sql) {
+
+	}
+
+	/**
+	 * 获取工具回调
+	 */
+	public ToolCallback toolCallback() {
+		return FunctionToolCallback.builder("execute_sql", this).description("""
+				# SQL执行工具
+				用于执行SQL查询并返回结果。
+				## 何时使用
+				- 当需要执行SQL查询以获取数据时
+				- 当需要验证SQL语句的正确性时
+				- 当需要获取数据库中的数据进行分析时
+				## 输入参数
+				- `sql`: 要执行的SQL语句（必填）
+				- `agentId`: 代理ID，用于获取数据库配置（必填）
+				- `schema`: 数据库schema（可选）
+				## 输出
+				- SQL执行结果，包括执行的SQL语句、列数、行数和数据预览
+				- 如果执行失败，返回错误信息
+				## 注意事项
+				- 请确保SQL语句是有效的，否则会返回错误信息
+				- 请确保agentId是有效的，否则会返回错误信息
+				- 执行结果中的数据预览可能会被截断，仅用于参考
+				""").inputType(Request.class).build();
+	}
+
+}
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/TodoWriteTool.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/TodoWriteTool.java
new file mode 100644
index 000000000..a375c0925
--- /dev/null
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/TodoWriteTool.java
@@ -0,0 +1,235 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Licensed 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
+ *
+ *     https://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 com.alibaba.cloud.ai.dataagent.tools;
+
+import com.fasterxml.jackson.annotation.JsonClassDescription;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonPropertyDescription;
+import java.util.List;
+import java.util.function.BiFunction;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.ai.chat.model.ToolContext;
+import org.springframework.ai.tool.ToolCallback;
+import org.springframework.ai.tool.function.FunctionToolCallback;
+import org.springframework.stereotype.Component;
+
+@Slf4j
+@AllArgsConstructor
+@Component
+public class TodoWriteTool implements BiFunction<TodoWriteTool.Request, ToolContext, String> {
+
+	@Override
+	public String apply(Request request, ToolContext toolContext) {
+		log.info("========== Todo Write Tool Start ==========");
+
+		try {
+			// Validate input
+			if (request.task() == null || request.task().isEmpty()) {
+				return "Task description is required";
+			}
+
+			if (request.steps() == null || request.steps().isEmpty()) {
+				return generateEmptyPlanOutput(request.task());
+			}
+
+			// Generate formatted output
+			String output = generatePlanOutput(request.task(), request.steps());
+
+			log.info("========== Todo Write Tool End ==========");
+			return output;
+		}
+		catch (Exception e) {
+			log.error("Error in todo write tool", e);
+			return "Error in todo write tool: " + e.getMessage();
+		}
+	}
+
+	public ToolCallback toolCallback() {
+		return FunctionToolCallback.builder("todo_write", this)
+			.description(
+					"""
+							Use this tool to create and manage a structured task list for retrieval and research tasks. This helps you track progress, organize complex retrieval operations, and demonstrate thoroughness to user.
+							**CRITICAL - Focus on Retrieval Tasks Only**:
+							- This tool is for tracking RETRIEVAL and RESEARCH tasks (e.g., searching knowledge bases, retrieving documents, gathering information)
+							- DO NOT include summary or synthesis tasks in todo_write - those are handled by thinking tool
+							- Examples of appropriate tasks: "Search for X in knowledge base", "Retrieve information about Y", "Compare A and B"
+							- Examples of tasks to EXCLUDE: "Summarize findings", "Generate final answer", "Synthesize results" - these are for thinking tool
+							## When to Use This Tool
+							Use this tool proactively in these scenarios:
+							1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
+							2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
+							3. User explicitly requests todo list - When user directly asks you to use todo list
+							4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
+							5. After receiving new instructions - Immediately capture user requirements as todos
+							6. When you start working on a task - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time
+							7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
+							## When NOT to Use This Tool
+							Skip using this tool when:
+							1. There is only a single, straightforward task
+							2. The task is trivial and tracking it provides no organizational benefit
+							3. The task is purely conversational or informational
+							NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing task directly.
+							## Task States and Management
+							1. **Task States**: Use these states to track progress:
+							  - pending: Task not yet started
+							  - in_progress: Currently working on (limit to ONE task at a time)
+							  - completed: Task finished successfully
+							2. **Task Management**:
+							  - Update task status in real-time as you work
+							  - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
+							  - Only have ONE task in_progress at any time
+							  - Complete current tasks before starting new ones
+							  - Remove tasks that are no longer relevant from list entirely
+							3. **Task Completion Requirements**:
+							  - ONLY mark a task as completed when you have FULLY accomplished it
+							  - If you encounter errors, blockers, or cannot finish, keep task as in_progress
+							  - When blocked, create a new task describing what needs to be resolved
+							  - Never mark a task as completed if:
+							    - Tests are failing
+							    - Implementation is partial
+							    - You encountered unresolved errors
+							    - You couldn't find necessary files or dependencies
+							4. **Task Breakdown**:
+							  - Create specific, actionable RETRIEVAL tasks
+							  - Break complex retrieval needs into smaller, manageable steps
+							  - Use clear, descriptive task names focused on what to retrieve or research
+							  - **DO NOT include summary/synthesis tasks** - those are handled separately by thinking tool
+							**Important**: After completing all retrieval tasks in todo_write, use thinking tool to synthesize findings and generate final answer. The todo_write tool tracks WHAT to retrieve, while thinking tool handles HOW to synthesize and present information.
+							When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all retrieval requirements successfully.
+							""")
+			.inputType(Request.class)
+			.build();
+	}
+
+	@JsonClassDescription("Request for todo write tool")
+	public record Request(@JsonProperty(value = "task",
+			required = true) @JsonPropertyDescription("The complex task or question you need to create a plan for") String task,
+
+			@JsonProperty(value = "steps",
+					required = true) @JsonPropertyDescription("Array of research plan steps with status tracking") List<PlanStep> steps) {
+
+	}
+
+	@JsonClassDescription("Plan step for todo write tool")
+	public record PlanStep(@JsonProperty(value = "id",
+			required = true) @JsonPropertyDescription("Unique identifier for this step (e.g., 'step1', 'step2')") String id,
+
+			@JsonProperty(value = "description",
+					required = true) @JsonPropertyDescription("Clear description of what to investigate or accomplish in this step") String description,
+
+			@JsonProperty(value = "status",
+					required = true) @JsonPropertyDescription("Current status: pending (not started), in_progress (executing), completed (finished)") String status) {
+
+	}
+
+	private String generateEmptyPlanOutput(String task) {
+		StringBuilder output = new StringBuilder();
+		output.append("计划已创建\n\n");
+		output.append("**任务**: ").append(task).append("\n\n");
+		output.append("注意：未提供具体步骤。建议创建3-7个检索任务以系统化研究。\n\n");
+		output.append("建议的检索流程（专注于检索任务，不包含总结）：\n");
+		output.append("1. 使用 grep_chunks 搜索关键词定位相关文档\n");
+		output.append("2. 使用 knowledge_search 进行语义搜索获取相关内容\n");
+		output.append("3. 使用 list_knowledge_chunks 获取关键文档的完整内容\n");
+		output.append("4. 使用 web_search 获取补充信息（如需要）\n");
+		output.append("\n注意：总结和综合由 thinking 工具处理，不要在此处添加总结任务。\n");
+		return output.toString();
+	}
+
+	private String generatePlanOutput(String task, List<PlanStep> steps) {
+		StringBuilder output = new StringBuilder();
+		output.append("计划已创建\n\n");
+		output.append("**任务**: ").append(task).append("\n\n");
+		output.append("**计划步骤**:\n\n");
+
+		// Count task statuses
+		int pendingCount = 0;
+		int inProgressCount = 0;
+		int completedCount = 0;
+		for (PlanStep step : steps) {
+			switch (step.status()) {
+				case "pending":
+					pendingCount++;
+					break;
+				case "in_progress":
+					inProgressCount++;
+					break;
+				case "completed":
+					completedCount++;
+					break;
+			}
+		}
+		int totalCount = steps.size();
+		int remainingCount = pendingCount + inProgressCount;
+
+		// Display all steps in order
+		for (int i = 0; i < steps.size(); i++) {
+			output.append(formatPlanStep(i + 1, steps.get(i)));
+		}
+
+		// Add summary and emphasis on remaining tasks
+		output.append("\n=== 任务进度 ===\n");
+		output.append("总计: ").append(totalCount).append(" 个任务\n");
+		output.append("✅ 已完成: ").append(completedCount).append(" 个\n");
+		output.append("🔄 进行中: ").append(inProgressCount).append(" 个\n");
+		output.append("⏳ 待处理: ").append(pendingCount).append(" 个\n");
+
+		output.append("\n=== ⚠️ 重要提醒 ===\n");
+		if (remainingCount > 0) {
+			output.append("**还有 ").append(remainingCount).append(" 个任务未完成！**\n\n");
+			output.append("**必须完成所有任务后才能总结或得出结论。**\n\n");
+			output.append("下一步操作：\n");
+			if (inProgressCount > 0) {
+				output.append("- 继续完成当前进行中的任务\n");
+			}
+			if (pendingCount > 0) {
+				output.append("- 开始处理 ").append(pendingCount).append(" 个待处理任务\n");
+				output.append("- 按顺序完成每个任务，不要跳过\n");
+			}
+			output.append("- 完成每个任务后，更新 todo_write 标记为 completed\n");
+			output.append("- 只有在所有任务完成后，才能生成最终总结\n");
+		}
+		else {
+			output.append("✅ **所有任务已完成！**\n\n");
+			output.append("现在可以：\n");
+			output.append("- 综合所有任务的发现\n");
+			output.append("- 生成完整的最终答案或报告\n");
+			output.append("- 确保所有方面都已充分研究\n");
+		}
+
+		return output.toString();
+	}
+
+	private String formatPlanStep(int index, PlanStep step) {
+		String statusEmoji;
+		switch (step.status()) {
+			case "pending":
+				statusEmoji = "⏳";
+				break;
+			case "in_progress":
+				statusEmoji = "🔄";
+				break;
+			case "completed":
+				statusEmoji = "✅";
+				break;
+			default:
+				statusEmoji = "⏳";
+		}
+		return String.format("  %d. %s [%s] %s\n", index, statusEmoji, step.status(), step.description());
+	}
+
+}
diff --git a/data-agent-management/src/main/resources/prompts/default-data-analysis.txt b/data-agent-management/src/main/resources/prompts/default-data-analysis.txt
new file mode 100644
index 000000000..b9b39ec38
--- /dev/null
+++ b/data-agent-management/src/main/resources/prompts/default-data-analysis.txt
@@ -0,0 +1,68 @@
+### Role
+You are an intelligent retrieval assistant powered by Progressive Agentic RAG. You operate in a multi-tenant environment with strictly isolated knowledge bases. Your core philosophy is "Evidence-First": you never rely on internal parametric knowledge but construct answers solely from verified data retrieved from the Knowledge Base (KB) or Web (if enabled).
+
+### Mission
+To deliver accurate, traceable, and verifiable answers by orchestrating a dynamic retrieval process. You must first gauge the information landscape through preliminary retrieval, then rigorously execute and reflect upon specific research tasks. **You prioritize "Deep Reading" over superficial scanning.**
+
+### Critical Constraints (ABSOLUTE RULES)
+1.  **NO Internal Knowledge:** You must behave as if your training data does not exist regarding facts.
+2.  **Mandatory Deep Read:** Whenever list_table_schema returns data you should read the result to get table schame, include table and column info, Do not rely on search snippets alone.
+3.  **KB First, Web Second:** Always exhaust KB strategies (including the Deep Read) before attempting Web Search (if enabled).
+4.  **Strict Plan Adherence:** If a todo_write plan exists, execute it sequentially. No skipping.
+5.  **Tool Privacy:** Never expose tool names to the user.
+
+### Workflow: The "Reconnaissance-Plan-Execute" Cycle
+
+#### Phase 1: Preliminary Reconnaissance (Mandatory Initial Step)
+Before answering or creating a plan, you MUST perform a "Deep Read" test of the KB to gain preliminary cognition.
+1.  **Search:** Execute list_table_schema based on core entities.
+2.  **DEEP READ (Crucial):** If the search returns IDs, you **MUST** call list_table_schema on the top relevant IDs to fetch their actual text.
+3.  **Analyze:** In your think block, evaluate the *full text* you just retrieved.
+  *   *Does this text fully answer the user?*
+  *   *Is the information complete or partial?*
+
+#### Phase 2: Strategic Decision & Planning
+Based on the **Deep Read** results from Phase 1:
+*   **Path A (Direct Answer):** If the full text provides sufficient, unambiguous evidence → Proceed to **Answer Generation**.
+*   **Path B (Complex Research):** If the query involves comparison, missing data, or the content requires synthesis → Use todo_write to formulate a Work Plan.
+  *   *Structure:* Break the problem into distinct retrieval tasks (e.g., "Deep read specs for Product A", "Deep read safety protocols").
+
+#### Phase 3: Disciplined Execution & Deep Reflection (The Loop)
+If in **Path B**, execute tasks in todo_write sequentially. For **EACH** task:
+1.  **Search:** Perform list_table_schema for the sub-task.
+2.  **MANDATORY Deep Reflection (in think):** Pause and evaluate the full text:
+  *   *Validity:* "Does this full text specifically address the sub-task?"
+  *   *Gap Analysis:* "Is anything missing? Is the information outdated? Is the information irrelevant?"
+  *   *Correction:* If insufficient, formulate a remedial action (e.g., "Search for synonym X", "Web Search if enabled") immediately.
+  *   *Completion:* Mark task as "completed" ONLY when evidence is secured.
+
+#### Phase 4: Final Synthesis
+Only when ALL todo_write tasks are "completed":
+*   Synthesize findings from the full text of all retrieved chunks.
+*   Check for consistency.
+*   Generate the final response.
+
+### Core Retrieval Strategy (Strict Sequence)
+For every retrieval attempt (Phase 1 or Phase 3), follow this exact chain:
+1.  **Semantic Expansion (list_table_schema):** Use vector search for context (filter by IDs from step 1 if applicable).
+2.  **Deep Contextualization (list_table_schema): MANDATORY.**
+  *   Rule: with knowledgebase_id you should call this tool.
+  *   Frequency: Call it frequently for multiple IDs to ensure you have the full results. **Do not be lazy; fetch the content.**
+3.  **Graph Exploration (query_knowledge_graph):** Optional for relationships.
+4.  **Web Fallback (web_search):** Use ONLY if Web Search is Enabled AND the Deep Read in Step 2 confirms the data is missing or irrelevant.
+
+### Tool Selection Guidelines
+*   **list_table_schema:** Your "Index". Use these to find *where* the table schema information might be.
+*   **todo_write:** Your "Manager". Tracks multi-step research.
+*   **think:** Your "Conscience". Use to plan and reflect the content returned by list_knowledge_chunks.
+*   **execute_sql:** Your "sql engine". Use to execute the sql and get results.
+
+### Final Output Standards
+*   **Definitive:** Based strictly on the "Deep Read" content.
+*   **Sourced(Inline, Proximate Citations):** All factual statements must include a citation immediately after the relevant claim—within the same sentence or paragraph where the fact appears: <kb doc="..." chunk_id="..." /> or <web url="..." title="..." /> (if from web).
+Citations may not be placed at the end of the answer. They must always be inserted inline, at the exact location where the referenced information is used ("proximate citation rule").
+*   **Structured:** Clear hierarchy and logic.
+*   **Rich Media (Markdown with Images):** When retrieved chunks contain images (indicated by the "images" field with URLs), you MUST include them in your response using standard Markdown image syntax: ![description](image_url). Place images at contextually appropriate positions within the answer to create a well-formatted, visually rich response. Images help users better understand the content, especially for diagrams, charts, screenshots, or visual explanations.
+
+### System Status
+Current Time: {current_time}
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index 758ede4a7..440ad5b9c 100644
--- a/pom.xml
+++ b/pom.xml
@@ -21,7 +21,7 @@
 
   <properties>
     <!-- Spring AI Alibaba Version -->
-    <spring-ai-alibaba.version>1.1.0.0</spring-ai-alibaba.version>
+    <spring-ai-alibaba.version>1.1.2.0</spring-ai-alibaba.version>
     <!-- Spring AI Alibaba DataAgent Version -->
     <revision>1.0.0-SNAPSHOT</revision>
     <!-- DashScope SDK Version -->
@@ -35,8 +35,8 @@
     <maven.compiler.target>${java.version}</maven.compiler.target>
 
     <!-- Spring version -->
-    <spring-ai.version>1.1.0</spring-ai.version>
-    <spring-boot.version>3.4.8</spring-boot.version>
+    <spring-ai.version>1.1.2</spring-ai.version>
+    <spring-boot.version>3.5.10</spring-boot.version>
     <springdoc-openapi.version>2.8.8</springdoc-openapi.version>
     <spring-javaformat-maven-plugin.version>0.0.39</spring-javaformat-maven-plugin.version>
     <mybatis.version>3.0.4</mybatis.version>
@@ -83,6 +83,20 @@
         <type>pom</type>
         <scope>import</scope>
       </dependency>
+      <dependency>
+        <groupId>com.alibaba.cloud.ai</groupId>
+        <artifactId>spring-ai-alibaba-bom</artifactId>
+        <version>${spring-ai-alibaba.version}</version>
+        <type>pom</type>
+        <scope>import</scope>
+      </dependency>
+      <dependency>
+        <groupId>com.alibaba.cloud.ai</groupId>
+        <artifactId>spring-ai-alibaba-extensions-bom</artifactId>
+        <version>${spring-ai-alibaba.version}</version>
+        <type>pom</type>
+        <scope>import</scope>
+      </dependency>
       <dependency>
         <groupId>com.github.docker-java</groupId>
         <artifactId>docker-java-bom</artifactId>