refactor(phase1): 完成包名重构 (org.example → com.superbiz.agent)

Task 4.1: 包名统一重构
- 重命名 41 个 Java 文件的包名
- 更新所有 import 语句
- 恢复枚举类（FaultCategory、DiagnosisStatus、SourceType）
- 更新测试类的 import

重构范围：
- domain/entity: 3 个实体类
- domain/model: 2 个数据类
- domain/enums: 3 个枚举类
- repository: 3 个接口
- service/session: 2 个类（接口 + 实现）
- config: 9 个配置类
- controller: 2 个控制器
- agent/tool: 4 个工具类
- client: 1 个客户端
- Main.java: 主类

验证结果：
- 编译成功，无错误
- 所有测试通过 (27/27)
  - ApiDocumentRepositoryTest: 7/7 ✅
  - CaseLibraryRepositoryTest: 6/6 ✅
  - DiagnosisRecordRepositoryTest: 6/6 ✅
  - RedisSessionManagerTest: 8/8 ✅

Progress: 21/33 tasks completed (64%)

src/main/java/com/superbiz/agent/Main.java

@@ -0,0 +1,11 @@
+package com.superbiz.agent;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class Main {
+    public static void main(String[] args) {
+        SpringApplication.run(Main.class, args);
+    }
+}

src/main/java/com/superbiz/agent/agent/tool/DateTimeTools.java

@@ -0,0 +1,27 @@
+package com.superbiz.agent.agent.tool;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.ai.tool.annotation.Tool;
+import org.springframework.context.i18n.LocaleContextHolder;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDateTime;
+
+@Component
+public class DateTimeTools {
+
+    private static final Logger logger = LoggerFactory.getLogger(DateTimeTools.class);
+    
+    /** 工具名常量，用于动态构建提示词 */
+    public static final String TOOL_GET_CURRENT_DATETIME = "getCurrentDateTime";
+    
+    @Tool(description = "Get the current date and time in the user's timezone. " +
+            "IMPORTANT: Time changes constantly. Always call this tool when user asks about time, " +
+            "even if there's a recent time query in the conversation history.")
+    public String getCurrentDateTime() {
+        String currentTime = LocalDateTime.now().atZone(LocaleContextHolder.getTimeZone().toZoneId()).toString();
+        logger.debug("🕐 getCurrentDateTime 调用 - 返回时间: {}", currentTime);
+        return currentTime;
+    }
+}

src/main/java/com/superbiz/agent/agent/tool/InternalDocsTools.java

@@ -0,0 +1,79 @@
+package com.superbiz.agent.agent.tool;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.superbiz.agent.service.VectorSearchService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.ai.tool.annotation.Tool;
+import org.springframework.ai.tool.annotation.ToolParam;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+/**
+ * 内部文档查询工具
+ * 使用 RAG (Retrieval-Augmented Generation) 从内部知识库检索相关文档
+ */
+@Component
+public class InternalDocsTools {
+    
+    private static final Logger logger = LoggerFactory.getLogger(InternalDocsTools.class);
+    
+    /** 工具名常量，用于动态构建提示词 */
+    public static final String TOOL_QUERY_INTERNAL_DOCS = "queryInternalDocs";
+    
+    private final VectorSearchService vectorSearchService;
+    
+    @Value("${rag.top-k:3}")
+    private int topK = 3; // 默认值
+    
+    private final ObjectMapper objectMapper = new ObjectMapper();
+    
+    /**
+     * 构造函数注入依赖
+     * Spring 会自动注入 VectorSearchService
+     */
+    @Autowired
+    public InternalDocsTools(VectorSearchService vectorSearchService) {
+        this.vectorSearchService = vectorSearchService;
+    }
+    
+    /**
+     * 查询内部文档工具
+     *
+     * @param query 搜索查询，描述您要查找的信息
+     * @return JSON 格式的搜索结果，包含相关文档内容、相似度分数和元数据
+     */
+    @Tool(description = "Use this tool to search internal documentation and knowledge base for relevant information. " +
+            "It performs RAG (Retrieval-Augmented Generation) to find similar documents and extract processing steps. " +
+            "This is useful when you need to understand internal procedures, best practices, or step-by-step guides " +
+            "stored in the company's documentation.")
+    public String queryInternalDocs(
+            @ToolParam(description = "Search query describing what information you are looking for") 
+            String query) {
+        
+
+        try {
+            // 使用向量搜索服务检索相关文档
+            List<VectorSearchService.SearchResult> searchResults = 
+                    vectorSearchService.searchSimilarDocuments(query, topK);
+            
+            if (searchResults.isEmpty()) {
+                return "{\"status\": \"no_results\", \"message\": \"No relevant documents found in the knowledge base.\"}";
+            }
+            
+            // 将搜索结果转换为 JSON 格式
+            String resultJson = objectMapper.writeValueAsString(searchResults);
+            
+
+            return resultJson;
+            
+        } catch (Exception e) {
+            logger.error("[工具错误] queryInternalDocs 执行失败", e);
+            return String.format("{\"status\": \"error\", \"message\": \"Failed to query internal docs: %s\"}", 
+                    e.getMessage());
+        }
+    }
+}

src/main/java/com/superbiz/agent/agent/tool/QueryLogsTools.java

@@ -0,0 +1,694 @@
+package com.superbiz.agent.agent.tool;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.Data;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.ai.tool.annotation.Tool;
+import org.springframework.ai.tool.annotation.ToolParam;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.time.Instant;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 日志查询工具
+ * 用于查询 CLS（云日志服务）的日志信息
+ * 支持 Mock 模式，提供与告警关联的模拟日志数据
+ */
+@Component
+public class QueryLogsTools {
+
+    private static final Logger logger = LoggerFactory.getLogger(QueryLogsTools.class);
+    
+    /** 工具名常量，用于动态构建提示词 */
+    public static final String TOOL_QUERY_LOGS = "queryLogs";
+    public static final String TOOL_GET_AVAILABLE_LOG_TOPICS = "getAvailableLogTopics";
+    
+    private final ObjectMapper objectMapper = new ObjectMapper();
+    
+    @Value("${cls.mock-enabled:false}")
+    private boolean mockEnabled;
+    
+    private static final DateTimeFormatter FORMATTER = DateTimeFormatter
+            .ofPattern("yyyy-MM-dd HH:mm:ss")
+            .withZone(ZoneId.of("Asia/Shanghai"));
+    
+    @jakarta.annotation.PostConstruct
+    public void init() {
+        logger.info("✅ QueryLogsTools 初始化成功, Mock模式: {}", mockEnabled);
+    }
+    
+    /**
+     * 获取可用的日志主题列表
+     * 用于查询前先了解有哪些日志主题可供查询
+     */
+    @Tool(description = "Get all available log topics and their descriptions. " +
+            "Call this tool first before querying logs to understand what log topics are available. " +
+            "Returns a list of log topics with their names, descriptions, and example queries.")
+    public String getAvailableLogTopics() {
+        logger.info("获取可用的日志主题列表");
+        
+        try {
+            List<LogTopicInfo> topics = new ArrayList<>();
+            
+            // 系统指标日志
+            LogTopicInfo systemMetrics = new LogTopicInfo();
+            systemMetrics.setTopicName("system-metrics");
+            systemMetrics.setDescription("系统指标日志，包含 CPU、内存、磁盘使用率等系统资源监控数据");
+            systemMetrics.setExampleQueries(List.of(
+                    "cpu_usage:>80",
+                    "memory_usage:>85",
+                    "disk_usage:>90",
+                    "level:WARN AND service:payment-service"
+            ));
+            systemMetrics.setRelatedAlerts(List.of("HighCPUUsage", "HighMemoryUsage", "HighDiskUsage"));
+            topics.add(systemMetrics);
+            
+            // 应用日志
+            LogTopicInfo applicationLogs = new LogTopicInfo();
+            applicationLogs.setTopicName("application-logs");
+            applicationLogs.setDescription("应用日志，包含应用程序的错误日志、警告日志、慢请求日志、下游依赖调用日志等");
+            applicationLogs.setExampleQueries(List.of(
+                    "level:ERROR",
+                    "level:FATAL",
+                    "http_status:500",
+                    "response_time:>3000",
+                    "slow",
+                    "downstream OR redis OR database OR mq"
+            ));
+            applicationLogs.setRelatedAlerts(List.of("ServiceUnavailable", "SlowResponse", "HighMemoryUsage"));
+            topics.add(applicationLogs);
+            
+            // 数据库慢查询日志
+            LogTopicInfo dbSlowQuery = new LogTopicInfo();
+            dbSlowQuery.setTopicName("database-slow-query");
+            dbSlowQuery.setDescription("数据库慢查询日志，包含执行时间较长的 SQL 查询，可用于分析数据库性能问题");
+            dbSlowQuery.setExampleQueries(List.of(
+                    "query_time:>2",
+                    "table:orders",
+                    "query_type:SELECT",
+                    "*"  // 查询所有慢查询
+            ));
+            dbSlowQuery.setRelatedAlerts(List.of("SlowResponse", "ServiceUnavailable"));
+            topics.add(dbSlowQuery);
+            
+            // 系统事件日志
+            LogTopicInfo systemEvents = new LogTopicInfo();
+            systemEvents.setTopicName("system-events");
+            systemEvents.setDescription("系统事件日志，包含 Kubernetes Pod 重启、OOM Kill、容器崩溃等系统级事件");
+            systemEvents.setExampleQueries(List.of(
+                    "restart OR crash",
+                    "oom_kill",
+                    "event_type:PodRestart",
+                    "reason:OOMKilled"
+            ));
+            systemEvents.setRelatedAlerts(List.of("ServiceUnavailable", "HighMemoryUsage"));
+            topics.add(systemEvents);
+            
+            // 构建输出
+            LogTopicsOutput output = new LogTopicsOutput();
+            output.setSuccess(true);
+            output.setTopics(topics);
+            output.setAvailableRegions(List.of("ap-guangzhou", "ap-shanghai", "ap-beijing", "ap-chengdu"));
+            output.setDefaultRegion("ap-guangzhou");
+
+            output.setMessage(String.format("共有 %d 个可用的日志主题。建议使用默认地域 'ap-guangzhou' 或省略 region 参数", topics.size()));
+            
+            return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(output);
+            
+        } catch (Exception e) {
+            logger.error("获取日志主题列表失败", e);
+            return "{\"success\":false,\"message\":\"获取日志主题列表失败: " + e.getMessage() + "\"}";
+        }
+    }
+    
+    /**
+     * 查询日志
+     * 从云日志服务查询指定条件的日志
+     * 
+     * @param region 地域，如 ap-guangzhou
+     * @param logTopic 日志主题，如 system-metrics, application-logs
+     * @param query 查询条件，如 level:ERROR OR cpu_usage:>80
+     * @param limit 返回的日志条数，默认20条
+     */
+    // 有效地域列表
+    private static final List<String> VALID_REGIONS = List.of(
+            "ap-guangzhou", "ap-shanghai", "ap-beijing", "ap-chengdu"
+    );
+
+    private static final String DEFAULT_REGION = "ap-guangzhou";
+    
+    @Tool(description = "Query logs from Cloud Log Service (CLS). " +
+            "Use this tool to search application logs, system metrics, and other log data. " +
+            "IMPORTANT: Before calling this tool, you should call getAvailableLogTopics to understand what log topics are available. " +
+            "Available log topics: " +
+            "1) 'system-metrics' - System metrics logs (CPU, memory, disk usage, etc. Related to HighCPUUsage, HighMemoryUsage, HighDiskUsage alerts); " +
+            "2) 'application-logs' - Application logs (error logs, slow request logs, downstream dependency logs. Related to ServiceUnavailable, SlowResponse alerts); " +
+            "3) 'database-slow-query' - Database slow query logs (SQL queries with long execution time. Related to SlowResponse alerts); " +
+            "4) 'system-events' - System event logs (Pod restart, OOM Kill, container crash. Related to ServiceUnavailable, HighMemoryUsage alerts). " +
+            "logTopic (required, one of the above topics or their CLS topicId), " +
+            "query (optional, defaults to a curated search if empty), " +
+            "limit (optional, default 20, max 100).")
+    public String queryLogs(
+            @ToolParam(description = "地域，可选值: ap-guangzhou, ap-shanghai, ap-beijing, ap-chengdu。默认 ap-guangzhou") String region,
+            @ToolParam(description = "日志主题，如 system-metrics, application-logs, database-slow-query, system-events，也支持 CLS TopicId") String logTopic,
+            @ToolParam(description = "查询条件，支持 Lucene 语法，如 level:ERROR OR cpu_usage:>80；为空时返回该主题近 5 条核心日志") String query,
+            @ToolParam(description = "返回日志条数，默认20，最大100") Integer limit) {
+        
+        int actualLimit = (limit == null || limit <= 0) ? 20 : Math.min(limit, 100);
+        
+        String safeQuery = query == null ? "" : query;
+        
+
+        try {
+            List<LogEntry> logEntries;
+            
+            if (mockEnabled) {
+                // Mock 模式：返回与告警关联的模拟日志数据
+                logEntries = buildMockLogs(region, logTopic, safeQuery, actualLimit);
+                logger.info("使用 Mock 数据，返回 {} 条日志", logEntries.size());
+            } else {
+                // 真实模式：调用 CLS API（这里预留接口，后续实现）
+                return buildErrorResponse("CLS 真实查询尚未实现，请启用 mock 模式进行测试");
+            }
+            
+            // 构建成功响应
+            QueryLogsOutput output = new QueryLogsOutput();
+            output.setSuccess(!logEntries.isEmpty());
+            output.setRegion(region);
+            output.setLogTopic(logTopic);
+            output.setQuery(safeQuery.isBlank() ? "DEFAULT_QUERY" : safeQuery);
+            output.setLogs(logEntries);
+            output.setTotal(logEntries.size());
+            output.setMessage(logEntries.isEmpty() ? "未找到匹配的日志" : String.format("成功查询到 %d 条日志", logEntries.size()));
+            
+            String jsonResult = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(output);
+            logger.info("日志查询完成: 找到 {} 条日志", logEntries.size());
+            
+            return jsonResult;
+            
+        } catch (Exception e) {
+            logger.error("查询日志失败", e);
+            return buildErrorResponse("查询失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 构建 Mock 日志数据
+
+     * 根据日志主题和查询条件返回与告警关联的模拟数据
+     */
+    private List<LogEntry> buildMockLogs(String region, String logTopic, String query, int limit) {
+        List<LogEntry> logs = new ArrayList<>();
+        Instant now = Instant.now();
+        
+        String safeTopic = logTopic == null ? "system-metrics" : logTopic.toLowerCase();
+        String normalizedQuery = query == null ? "" : query.toLowerCase();
+        
+        // 根据日志主题和查询条件生成对应的 mock 数据
+        switch (safeTopic) {
+
+            case "system-metrics":
+                logs.addAll(buildSystemMetricsLogs(now, normalizedQuery, limit));
+                break;
+            case "application-logs":
+                logs.addAll(buildApplicationLogs(now, normalizedQuery, limit));
+                break;
+            case "database-slow-query":
+                logs.addAll(buildDatabaseSlowQueryLogs(now, normalizedQuery, limit));
+                break;
+            case "system-events":
+                logs.addAll(buildSystemEventsLogs(now, normalizedQuery, limit));
+                break;
+            default:
+                logs.addAll(buildGenericLogs(now, normalizedQuery, limit));
+        }
+        
+        if (logs.isEmpty()) {
+            logs.addAll(buildGenericLogs(now, normalizedQuery, limit));
+        }
+        
+        // 限制返回条数
+
+        if (logs.size() > limit) {
+            logs = logs.subList(0, limit);
+        }
+        
+        return logs;
+    }
+    
+    /**
+     * 构建系统指标日志（与 CPU、内存、磁盘告警关联）
+     */
+    private List<LogEntry> buildSystemMetricsLogs(Instant now, String query, int limit) {
+        List<LogEntry> logs = new ArrayList<>();
+        
+        // CPU 相关日志
+        if (query.contains("cpu") || query.contains(">80")) {
+
+            for (int i = 0; i < 5; i++) {
+                LogEntry log = new LogEntry();
+                log.setTimestamp(FORMATTER.format(now.minus(i * 2, ChronoUnit.MINUTES)));
+                log.setLevel("WARN");
+                log.setService("payment-service");
+                log.setInstance("pod-payment-service-7d8f9c6b5-x2k4m");
+                log.setMessage(String.format("CPU使用率过高: %.1f%%, 进程: java (PID: 1), 线程数: 245", 92.0 - i * 1.5));
+                log.setMetrics(Map.of(
+                        "cpu_usage", String.format("%.1f", 92.0 - i * 1.5),
+                        "cpu_cores", "4",
+                        "load_average_1m", "3.82",
+                        "load_average_5m", "3.65",
+                        "top_process", "java",
+                        "process_threads", "245"
+                ));
+                logs.add(log);
+            }
+        }
+        
+        // 内存相关日志
+        if (query.contains("memory") || query.contains(">85") || query.contains("oom")) {
+
+            for (int i = 0; i < 5; i++) {
+                LogEntry log = new LogEntry();
+                log.setTimestamp(FORMATTER.format(now.minus(i * 3, ChronoUnit.MINUTES)));
+                log.setLevel("WARN");
+                log.setService("order-service");
+                log.setInstance("pod-order-service-5c7d8e9f1-m3n2p");
+                log.setMessage(String.format("内存使用率过高: %.1f%%, JVM堆内存: %.1fGB/4GB, GC次数: %d", 
+                        91.0 - i * 1.2, 3.8 - i * 0.1, 128 - i * 5));
+                log.setMetrics(Map.of(
+                        "memory_usage", String.format("%.1f", 91.0 - i * 1.2),
+                        "jvm_heap_used", String.format("%.1fGB", 3.8 - i * 0.1),
+                        "jvm_heap_max", "4GB",
+                        "gc_count", String.valueOf(128 - i * 5),
+                        "gc_time_ms", String.valueOf(1250 + i * 50)
+                ));
+                logs.add(log);
+            }
+            
+            // 添加 GC 警告日志
+            LogEntry gcLog = new LogEntry();
+            gcLog.setTimestamp(FORMATTER.format(now.minus(8, ChronoUnit.MINUTES)));
+            gcLog.setLevel("WARN");
+            gcLog.setService("order-service");
+            gcLog.setInstance("pod-order-service-5c7d8e9f1-m3n2p");
+            gcLog.setMessage("频繁 Full GC 警告: 过去10分钟内发生 15 次 Full GC, 平均耗时 850ms, 建议检查内存泄漏");
+            gcLog.setMetrics(Map.of(
+                    "full_gc_count", "15",
+                    "avg_gc_time_ms", "850",
+                    "survivor_space", "95%",
+                    "old_gen", "89%"
+            ));
+            logs.add(gcLog);
+        }
+        
+        // 磁盘相关日志
+        if (query.contains("disk") || query.contains("filesystem")) {
+
+            for (int i = 0; i < 3; i++) {
+                LogEntry log = new LogEntry();
+                log.setTimestamp(FORMATTER.format(now.minus(i * 5, ChronoUnit.MINUTES)));
+                log.setLevel("WARN");
+                log.setService("log-collector");
+                log.setInstance("node-worker-01");
+                log.setMessage(String.format("磁盘使用率告警: /data 分区使用率 %.1f%%, 可用空间: %.1fGB", 
+                        85.0 + i * 2, 15.0 - i * 2));
+                log.setMetrics(Map.of(
+                        "disk_usage", String.format("%.1f%%", 85.0 + i * 2),
+                        "disk_available", String.format("%.1fGB", 15.0 - i * 2),
+                        "disk_total", "100GB",
+                        "mount_point", "/data",
+                        "largest_dir", "/data/logs"
+                ));
+                logs.add(log);
+            }
+        }
+        
+        return logs;
+    }
+    
+    /**
+     * 构建应用日志（与服务不可用、慢响应告警关联）
+     */
+    private List<LogEntry> buildApplicationLogs(Instant now, String query, int limit) {
+        List<LogEntry> logs = new ArrayList<>();
+        
+        // ERROR 级别日志
+        if (query.contains("error") || query.contains("fatal") || query.contains("500")) {
+
+            // 数据库连接错误
+            LogEntry dbError = new LogEntry();
+            dbError.setTimestamp(FORMATTER.format(now.minus(5, ChronoUnit.MINUTES)));
+            dbError.setLevel("ERROR");
+            dbError.setService("order-service");
+            dbError.setInstance("pod-order-service-5c7d8e9f1-m3n2p");
+            dbError.setMessage("数据库连接池耗尽: Cannot acquire connection from pool, " +
+                    "active: 50/50, waiting: 23, timeout: 30000ms");
+            dbError.setMetrics(Map.of(
+                    "error_type", "ConnectionPoolExhaustedException",
+                    "pool_active", "50",
+                    "pool_max", "50",
+                    "waiting_threads", "23"
+            ));
+            logs.add(dbError);
+            
+            // OOM 错误
+            LogEntry oomError = new LogEntry();
+            oomError.setTimestamp(FORMATTER.format(now.minus(12, ChronoUnit.MINUTES)));
+            oomError.setLevel("FATAL");
+            oomError.setService("order-service");
+            oomError.setInstance("pod-order-service-5c7d8e9f1-m3n2p");
+            oomError.setMessage("java.lang.OutOfMemoryError: Java heap space at " +
+                    "com.example.order.service.OrderService.processLargeOrder(OrderService.java:156)");
+            oomError.setMetrics(Map.of(
+                    "error_type", "OutOfMemoryError",
+                    "heap_used", "3.9GB",
+                    "heap_max", "4GB",
+                    "stack_trace", "OrderService.processLargeOrder -> OrderRepository.findByCondition -> HikariPool.getConnection"
+            ));
+            logs.add(oomError);
+            
+            // HTTP 500 错误
+            for (int i = 0; i < 3; i++) {
+                LogEntry httpError = new LogEntry();
+                httpError.setTimestamp(FORMATTER.format(now.minus(3 + i, ChronoUnit.MINUTES)));
+                httpError.setLevel("ERROR");
+                httpError.setService("user-service");
+                httpError.setInstance("pod-user-service-8e9f0a1b2-k5j6h");
+                httpError.setMessage(String.format("HTTP 500 Internal Server Error: /api/v1/users/profile, " +
+                        "耗时: %dms, 错误: Database query timeout", 5200 + i * 300));
+                httpError.setMetrics(Map.of(
+                        "http_status", "500",
+                        "uri", "/api/v1/users/profile",
+                        "method", "GET",
+                        "duration_ms", String.valueOf(5200 + i * 300),
+                        "error_cause", "QueryTimeoutException"
+                ));
+                logs.add(httpError);
+            }
+        }
+        
+        // 慢响应相关日志
+        if (query.contains("response_time") || query.contains("slow") || query.contains(">3000")) {
+
+            for (int i = 0; i < 5; i++) {
+                LogEntry slowLog = new LogEntry();
+                slowLog.setTimestamp(FORMATTER.format(now.minus(i * 2, ChronoUnit.MINUTES)));
+                slowLog.setLevel("WARN");
+                slowLog.setService("user-service");
+                slowLog.setInstance("pod-user-service-8e9f0a1b2-k5j6h");
+                slowLog.setMessage(String.format("慢请求警告: %s, 响应时间: %dms, 阈值: 3000ms",
+                        i % 2 == 0 ? "/api/v1/users/profile" : "/api/v1/users/orders",
+                        4200 - i * 150));
+                slowLog.setMetrics(Map.of(
+                        "uri", i % 2 == 0 ? "/api/v1/users/profile" : "/api/v1/users/orders",
+                        "response_time_ms", String.valueOf(4200 - i * 150),
+                        "threshold_ms", "3000",
+                        "db_time_ms", String.valueOf(3800 - i * 100),
+                        "cache_hit", "false"
+                ));
+                logs.add(slowLog);
+            }
+        }
+        
+        // 下游服务依赖相关日志
+        if (query.contains("downstream") || query.contains("redis") || 
+            query.contains("database") || query.contains("mq")) {
+
+            LogEntry redisError = new LogEntry();
+            redisError.setTimestamp(FORMATTER.format(now.minus(7, ChronoUnit.MINUTES)));
+            redisError.setLevel("ERROR");
+            redisError.setService("payment-service");
+            redisError.setInstance("pod-payment-service-7d8f9c6b5-x2k4m");
+            redisError.setMessage("Redis 连接超时: 无法连接到 Redis 集群, 节点: redis-cluster-01:6379, 超时: 3000ms");
+            redisError.setMetrics(Map.of(
+                    "dependency", "redis",
+                    "host", "redis-cluster-01:6379",
+                    "timeout_ms", "3000",
+                    "retry_count", "3"
+            ));
+            logs.add(redisError);
+            
+            LogEntry mqError = new LogEntry();
+            mqError.setTimestamp(FORMATTER.format(now.minus(9, ChronoUnit.MINUTES)));
+            mqError.setLevel("WARN");
+            mqError.setService("order-service");
+            mqError.setInstance("pod-order-service-5c7d8e9f1-m3n2p");
+            mqError.setMessage("消息队列积压警告: 队列 order-process-queue 积压消息数: 15823, 消费速率下降");
+            mqError.setMetrics(Map.of(
+                    "dependency", "rabbitmq",
+                    "queue", "order-process-queue",
+                    "pending_messages", "15823",
+                    "consumer_count", "3"
+            ));
+            logs.add(mqError);
+        }
+        
+        return logs;
+    }
+    
+    /**
+     * 构建数据库慢查询日志（与慢响应告警关联）
+     */
+    private List<LogEntry> buildDatabaseSlowQueryLogs(Instant now, String query, int limit) {
+        List<LogEntry> logs = new ArrayList<>();
+        
+        // 慢查询日志
+        LogEntry slowQuery1 = new LogEntry();
+        slowQuery1.setTimestamp(FORMATTER.format(now.minus(3, ChronoUnit.MINUTES)));
+        slowQuery1.setLevel("WARN");
+        slowQuery1.setService("mysql");
+        slowQuery1.setInstance("mysql-primary-01");
+        slowQuery1.setMessage("慢查询: SELECT * FROM orders WHERE user_id = ? AND status IN (?, ?, ?) " +
+                "ORDER BY created_at DESC LIMIT 100, 执行时间: 3.2s, 扫描行数: 1,245,678");
+        slowQuery1.setMetrics(Map.of(
+                "query_time_sec", "3.2",
+                "rows_examined", "1245678",
+                "rows_returned", "100",
+                "index_used", "idx_user_id",
+                "table", "orders",
+                "query_type", "SELECT"
+        ));
+        logs.add(slowQuery1);
+        
+        LogEntry slowQuery2 = new LogEntry();
+        slowQuery2.setTimestamp(FORMATTER.format(now.minus(6, ChronoUnit.MINUTES)));
+        slowQuery2.setLevel("WARN");
+        slowQuery2.setService("mysql");
+        slowQuery2.setInstance("mysql-primary-01");
+        slowQuery2.setMessage("慢查询: SELECT u.*, p.* FROM users u LEFT JOIN user_profiles p ON u.id = p.user_id " +
+                "WHERE u.last_login > ?, 执行时间: 2.8s, 全表扫描");
+        slowQuery2.setMetrics(Map.of(
+                "query_time_sec", "2.8",
+                "rows_examined", "856234",
+                "rows_returned", "45678",
+                "index_used", "NONE",
+                "table", "users, user_profiles",
+                "query_type", "SELECT",
+                "warning", "Full table scan detected"
+        ));
+        logs.add(slowQuery2);
+        
+        LogEntry slowQuery3 = new LogEntry();
+        slowQuery3.setTimestamp(FORMATTER.format(now.minus(8, ChronoUnit.MINUTES)));
+        slowQuery3.setLevel("WARN");
+        slowQuery3.setService("mysql");
+        slowQuery3.setInstance("mysql-primary-01");
+        slowQuery3.setMessage("慢查询: UPDATE orders SET status = ? WHERE created_at < ? AND status = ?, " +
+                "执行时间: 4.5s, 锁等待时间: 2.1s");
+        slowQuery3.setMetrics(Map.of(
+                "query_time_sec", "4.5",
+                "lock_time_sec", "2.1",
+                "rows_affected", "23456",
+                "table", "orders",
+                "query_type", "UPDATE",
+                "warning", "High lock contention"
+        ));
+        logs.add(slowQuery3);
+        
+        return logs;
+    }
+    
+    /**
+     * 构建系统事件日志（与服务不可用告警关联）
+     */
+    private List<LogEntry> buildSystemEventsLogs(Instant now, String query, int limit) {
+        List<LogEntry> logs = new ArrayList<>();
+        
+        // 服务重启事件
+        if (query.contains("restart") || query.contains("crash") || 
+            query.contains("oom_kill")) {
+
+            LogEntry restartEvent = new LogEntry();
+            restartEvent.setTimestamp(FORMATTER.format(now.minus(15, ChronoUnit.MINUTES)));
+            restartEvent.setLevel("WARN");
+            restartEvent.setService("kubernetes");
+            restartEvent.setInstance("kube-controller-manager");
+            restartEvent.setMessage("Pod 重启事件: pod-order-service-5c7d8e9f1-m3n2p, 原因: OOMKilled, " +
+                    "容器退出码: 137, 重启次数: 3");
+            restartEvent.setMetrics(Map.of(
+                    "event_type", "PodRestart",
+                    "pod", "pod-order-service-5c7d8e9f1-m3n2p",
+                    "reason", "OOMKilled",
+                    "exit_code", "137",
+                    "restart_count", "3",
+                    "namespace", "production"
+            ));
+            logs.add(restartEvent);
+            
+            LogEntry oomKillEvent = new LogEntry();
+            oomKillEvent.setTimestamp(FORMATTER.format(now.minus(16, ChronoUnit.MINUTES)));
+            oomKillEvent.setLevel("ERROR");
+            oomKillEvent.setService("kernel");
+            oomKillEvent.setInstance("node-worker-02");
+            oomKillEvent.setMessage("OOM Killer 触发: 进程 java (PID: 12345) 被杀死, " +
+                    "内存使用: 3.9GB, 内存限制: 4GB");
+            oomKillEvent.setMetrics(Map.of(
+                    "event_type", "OOMKill",
+                    "process", "java",
+                    "pid", "12345",
+                    "memory_used", "3.9GB",
+                    "memory_limit", "4GB",
+                    "cgroup", "/kubepods/pod-order-service"
+            ));
+            logs.add(oomKillEvent);
+        }
+        
+        return logs;
+    }
+    
+    /**
+     * 构建通用日志
+     */
+    private List<LogEntry> buildGenericLogs(Instant now, String query, int limit) {
+        List<LogEntry> logs = new ArrayList<>();
+        
+        for (int i = 0; i < Math.min(limit, 10); i++) {
+            LogEntry log = new LogEntry();
+            log.setTimestamp(FORMATTER.format(now.minus(i, ChronoUnit.MINUTES)));
+            log.setLevel(i % 3 == 0 ? "ERROR" : (i % 3 == 1 ? "WARN" : "INFO"));
+            log.setService("generic-service");
+            log.setInstance("instance-" + i);
+            log.setMessage("日志消息 #" + i + ", 查询条件: " + query);
+            log.setMetrics(new HashMap<>());
+            logs.add(log);
+        }
+        
+        return logs;
+    }
+    
+    /**
+     * 构建错误响应
+     */
+    private String buildErrorResponse(String message) {
+        try {
+            QueryLogsOutput output = new QueryLogsOutput();
+            output.setSuccess(false);
+            output.setMessage(message);
+            return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(output);
+        } catch (Exception e) {
+            return String.format("{\"success\":false,\"message\":\"%s\"}", message);
+        }
+    }
+    
+    // ==================== 数据模型 ====================
+    
+    /**
+     * 日志条目
+     */
+    @Data
+    public static class LogEntry {
+        @JsonProperty("timestamp")
+        private String timestamp;
+        
+        @JsonProperty("level")
+        private String level;
+        
+        @JsonProperty("service")
+        private String service;
+        
+        @JsonProperty("instance")
+        private String instance;
+        
+        @JsonProperty("message")
+        private String message;
+        
+        @JsonProperty("metrics")
+        private Map<String, String> metrics;
+    }
+    
+    /**
+     * 日志查询输出
+     */
+    @Data
+    public static class QueryLogsOutput {
+        @JsonProperty("success")
+        private boolean success;
+        
+        @JsonProperty("region")
+        private String region;
+        
+        @JsonProperty("log_topic")
+        private String logTopic;
+        
+        @JsonProperty("query")
+        private String query;
+        
+        @JsonProperty("logs")
+        private List<LogEntry> logs;
+        
+        @JsonProperty("total")
+        private int total;
+        
+        @JsonProperty("message")
+        private String message;
+    }
+    
+    /**
+     * 日志主题信息
+     */
+    @Data
+    public static class LogTopicInfo {
+        @JsonProperty("topic_name")
+        private String topicName;
+        
+        @JsonProperty("description")
+        private String description;
+        
+        @JsonProperty("example_queries")
+        private List<String> exampleQueries;
+        
+        @JsonProperty("related_alerts")
+        private List<String> relatedAlerts;
+    }
+    
+    /**
+     * 日志主题列表输出
+     */
+    @Data
+    public static class LogTopicsOutput {
+        @JsonProperty("success")
+        private boolean success;
+        
+        @JsonProperty("topics")
+        private List<LogTopicInfo> topics;
+        
+        @JsonProperty("available_regions")
+        private List<String> availableRegions;
+        
+        @JsonProperty("default_region")
+        private String defaultRegion;
+        
+        @JsonProperty("message")
+        private String message;
+    }
+}

src/main/java/com/superbiz/agent/agent/tool/QueryMetricsTools.java

@@ -0,0 +1,303 @@
+package com.superbiz.agent.agent.tool;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.Data;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.ai.tool.annotation.Tool;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.*;
+
+/**
+ * Prometheus 告警查询工具
+ * 用于查询 Prometheus 的活动告警信息
+ */
+@Component
+public class QueryMetricsTools {
+
+    private static final Logger logger = LoggerFactory.getLogger(QueryMetricsTools.class);
+    
+    /** 工具名常量，用于动态构建提示词 */
+    public static final String TOOL_QUERY_PROMETHEUS_ALERTS = "queryPrometheusAlerts";
+    
+    private final ObjectMapper objectMapper = new ObjectMapper();
+    
+    @Value("${prometheus.base-url}")
+    private String prometheusBaseUrl;
+    
+    @Value("${prometheus.timeout:10}")
+    private int timeout;
+    
+    @Value("${prometheus.mock-enabled:false}")
+    private boolean mockEnabled;
+    
+    private OkHttpClient httpClient;
+    
+    @jakarta.annotation.PostConstruct
+    public void init() {
+        this.httpClient = new OkHttpClient.Builder()
+                .connectTimeout(Duration.ofSeconds(timeout))
+                .readTimeout(Duration.ofSeconds(timeout))
+                .build();
+        logger.info("✅ QueryMetricsTools 初始化成功, Prometheus URL: {}, Mock模式: {}", prometheusBaseUrl, mockEnabled);
+    }
+    
+    /**
+     * 查询 Prometheus 活动告警
+     * 该工具从 Prometheus 告警系统检索所有当前活动/触发的告警，包括标签、注释、状态和值
+     */
+    @Tool(description = "Query active alerts from Prometheus alerting system. " +
+            "This tool retrieves all currently active/firing alerts including their labels, annotations, state, and values. " +
+            "Use this tool when you need to check what alerts are currently firing, investigate alert conditions, or monitor alert status.")
+    public String queryPrometheusAlerts() {
+        logger.info("开始查询 Prometheus 活动告警, Mock模式: {}", mockEnabled);
+        
+        try {
+            List<SimplifiedAlert> simplifiedAlerts;
+            
+            if (mockEnabled) {
+                // Mock 模式：返回与文档关联的模拟告警数据
+                simplifiedAlerts = buildMockAlerts();
+                logger.info("使用 Mock 数据，返回 {} 个模拟告警", simplifiedAlerts.size());
+            } else {
+                // 真实模式：调用 Prometheus Alerts API
+                PrometheusAlertsResult result = fetchPrometheusAlerts();
+                
+                if (!"success".equals(result.getStatus())) {
+                    return buildErrorResponse("Prometheus API 返回非成功状态: " + result.getStatus(), result.getError());
+                }
+                
+                // 转换为简化格式，对于相同的 alertname，只保留第一个
+                Set<String> seenAlertNames = new HashSet<>();
+                simplifiedAlerts = new ArrayList<>();
+                
+                for (PrometheusAlert alert : result.getData().getAlerts()) {
+                    String alertName = alert.getLabels().get("alertname");
+                    
+                    // 如果这个 alertname 已经存在，跳过
+                    if (seenAlertNames.contains(alertName)) {
+                        continue;
+                    }
+                    
+                    // 标记为已见过
+                    seenAlertNames.add(alertName);
+                    
+                    SimplifiedAlert simplified = new SimplifiedAlert();
+                    simplified.setAlertName(alertName);
+                    simplified.setDescription(alert.getAnnotations().getOrDefault("description", ""));
+                    simplified.setState(alert.getState());
+                    simplified.setActiveAt(alert.getActiveAt());
+                    simplified.setDuration(calculateDuration(alert.getActiveAt()));
+                    
+                    simplifiedAlerts.add(simplified);
+                }
+            }
+            
+            // 构建成功响应
+            PrometheusAlertsOutput output = new PrometheusAlertsOutput();
+            output.setSuccess(true);
+            output.setAlerts(simplifiedAlerts);
+            output.setMessage(String.format("成功检索到 %d 个活动告警", simplifiedAlerts.size()));
+            
+            String jsonResult = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(output);
+            logger.info("Prometheus 告警查询完成: 找到 {} 个告警", simplifiedAlerts.size());
+            
+            return jsonResult;
+            
+        } catch (Exception e) {
+            logger.error("查询 Prometheus 告警失败", e);
+            return buildErrorResponse("查询失败", e.getMessage());
+        }
+    }
+    
+    /**
+     * 构建 Mock 告警数据
+     * 与 aiops-docs 文档中的告警类型对应：
+     * - HighCPUUsage: CPU使用率过高
+     * - HighMemoryUsage: 内存使用率过高
+     * - HighDiskUsage: 磁盘使用率过高
+     * - ServiceUnavailable: 服务不可用
+     * - SlowResponse: 响应时间过长
+     */
+    private List<SimplifiedAlert> buildMockAlerts() {
+        List<SimplifiedAlert> alerts = new ArrayList<>();
+        Instant now = Instant.now();
+        
+        // 告警1: CPU使用率过高 - 持续约25分钟
+        SimplifiedAlert cpuAlert = new SimplifiedAlert();
+        cpuAlert.setAlertName("HighCPUUsage");
+        cpuAlert.setDescription("服务 payment-service 的 CPU 使用率持续超过 80%，当前值为 92%。" +
+                "实例: pod-payment-service-7d8f9c6b5-x2k4m，命名空间: production");
+        cpuAlert.setState("firing");
+        Instant cpuActiveAt = now.minus(25, ChronoUnit.MINUTES);
+        cpuAlert.setActiveAt(cpuActiveAt.toString());
+        cpuAlert.setDuration(calculateDuration(cpuActiveAt.toString()));
+        alerts.add(cpuAlert);
+        
+        // 告警2: 内存使用率过高 - 持续约15分钟
+        SimplifiedAlert memoryAlert = new SimplifiedAlert();
+        memoryAlert.setAlertName("HighMemoryUsage");
+        memoryAlert.setDescription("服务 order-service 的内存使用率持续超过 85%，当前值为 91%。" +
+                "JVM堆内存使用: 3.8GB/4GB，可能存在内存泄漏风险。" +
+                "实例: pod-order-service-5c7d8e9f1-m3n2p，命名空间: production");
+        memoryAlert.setState("firing");
+        Instant memoryActiveAt = now.minus(15, ChronoUnit.MINUTES);
+        memoryAlert.setActiveAt(memoryActiveAt.toString());
+        memoryAlert.setDuration(calculateDuration(memoryActiveAt.toString()));
+        alerts.add(memoryAlert);
+        
+        // 告警3: 响应时间过长 - 持续约10分钟
+        SimplifiedAlert slowAlert = new SimplifiedAlert();
+        slowAlert.setAlertName("SlowResponse");
+        slowAlert.setDescription("服务 user-service 的 P99 响应时间持续超过 3 秒，当前值为 4.2 秒。" +
+                "受影响接口: /api/v1/users/profile, /api/v1/users/orders。" +
+                "可能原因：数据库慢查询或下游服务延迟");
+        slowAlert.setState("firing");
+        Instant slowActiveAt = now.minus(10, ChronoUnit.MINUTES);
+        slowAlert.setActiveAt(slowActiveAt.toString());
+        slowAlert.setDuration(calculateDuration(slowActiveAt.toString()));
+        alerts.add(slowAlert);
+        
+        return alerts;
+    }
+    
+    /**
+     * 从 Prometheus API 获取告警数据
+     */
+    private PrometheusAlertsResult fetchPrometheusAlerts() throws Exception {
+        String apiUrl = prometheusBaseUrl + "/api/v1/alerts";
+        logger.debug("请求 Prometheus API: {}", apiUrl);
+        
+        Request request = new Request.Builder()
+                .url(apiUrl)
+                .get()
+                .build();
+        
+        try (Response response = httpClient.newCall(request).execute()) {
+            if (!response.isSuccessful()) {
+                throw new RuntimeException("HTTP 请求失败: " + response.code());
+            }
+            
+            String responseBody = response.body().string();
+            return objectMapper.readValue(responseBody, PrometheusAlertsResult.class);
+        }
+    }
+    
+    /**
+     * 计算从 activeAt 到现在的持续时间
+     */
+    private String calculateDuration(String activeAtStr) {
+        try {
+            Instant activeAt = Instant.parse(activeAtStr);
+            Duration duration = Duration.between(activeAt, Instant.now());
+            
+            long hours = duration.toHours();
+            long minutes = duration.toMinutes() % 60;
+            long seconds = duration.getSeconds() % 60;
+            
+            if (hours > 0) {
+                return String.format("%dh%dm%ds", hours, minutes, seconds);
+            } else if (minutes > 0) {
+                return String.format("%dm%ds", minutes, seconds);
+            } else {
+                return String.format("%ds", seconds);
+            }
+        } catch (Exception e) {
+            logger.warn("解析时间失败: {}", activeAtStr, e);
+            return "unknown";
+        }
+    }
+    
+    /**
+     * 构建错误响应
+     */
+    private String buildErrorResponse(String message, String error) {
+        try {
+            PrometheusAlertsOutput output = new PrometheusAlertsOutput();
+            output.setSuccess(false);
+            output.setMessage(message);
+            output.setError(error);
+            return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(output);
+        } catch (Exception e) {
+            return String.format("{\"success\":false,\"message\":\"%s\",\"error\":\"%s\"}", message, error);
+        }
+    }
+    
+    // ==================== 数据模型 ====================
+    
+    /**
+     * Prometheus 告警信息结构
+     */
+    @Data
+    public static class PrometheusAlert {
+        private Map<String, String> labels;
+        private Map<String, String> annotations;
+        private String state;
+        private String activeAt;
+        private String value;
+    }
+    
+    /**
+     * Prometheus 告警查询结果
+     */
+    @Data
+    public static class PrometheusAlertsResult {
+        private String status;
+        private AlertsData data;
+        private String error;
+        private String errorType;
+    }
+    
+    @Data
+    public static class AlertsData {
+        private List<PrometheusAlert> alerts = new ArrayList<>();
+    }
+    
+    /**
+     * 简化的告警信息
+     */
+    @Data
+    public static class SimplifiedAlert {
+        @JsonProperty("alert_name")
+        private String alertName;
+        
+        @JsonProperty("description")
+        private String description;
+        
+        @JsonProperty("state")
+        private String state;
+        
+        @JsonProperty("active_at")
+        private String activeAt;
+        
+        @JsonProperty("duration")
+        private String duration;
+    }
+    
+    /**
+     * 告警查询输出
+     */
+    @Data
+    public static class PrometheusAlertsOutput {
+        @JsonProperty("success")
+        private boolean success;
+        
+        @JsonProperty("alerts")
+        private List<SimplifiedAlert> alerts;
+        
+        @JsonProperty("message")
+        private String message;
+        
+        @JsonProperty("error")
+        private String error;
+    }
+}

src/main/java/com/superbiz/agent/client/MilvusClientFactory.java

@@ -0,0 +1,196 @@
+package com.superbiz.agent.client;
+
+import io.milvus.client.MilvusServiceClient;
+import io.milvus.grpc.DataType;
+import io.milvus.param.ConnectParam;
+import io.milvus.param.IndexType;
+import io.milvus.param.MetricType;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.*;
+import io.milvus.param.index.CreateIndexParam;
+import com.superbiz.agent.config.MilvusProperties;
+import com.superbiz.agent.constant.MilvusConstants;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Milvus 客户端工厂类
+ * 负责创建和初始化 Milvus 客户端连接
+ */
+@Component
+public class MilvusClientFactory {
+
+    private static final Logger logger = LoggerFactory.getLogger(MilvusClientFactory.class);
+
+    @Autowired
+    private MilvusProperties milvusProperties;
+
+    /**
+     * 创建并初始化 Milvus 客户端
+     * 
+     * 简化版本：直接连接并创建 collection
+     * 
+     * @return MilvusServiceClient 实例
+     * @throws RuntimeException 如果连接或初始化失败
+     */
+    public MilvusServiceClient createClient() {
+        MilvusServiceClient client = null;
+
+        try {
+            // 1. 连接到 Milvus
+            logger.info("正在连接到 Milvus: {}:{}", milvusProperties.getHost(), milvusProperties.getPort());
+            client = connectToMilvus();
+            logger.info("成功连接到 Milvus");
+
+            // 2. 检查并创建 biz collection（如果不存在）
+            if (!collectionExists(client, MilvusConstants.MILVUS_COLLECTION_NAME)) {
+                logger.info("collection '{}' 不存在，正在创建...", MilvusConstants.MILVUS_COLLECTION_NAME);
+                createBizCollection(client);
+                logger.info("成功创建 collection '{}'", MilvusConstants.MILVUS_COLLECTION_NAME);
+                
+                // 创建索引
+                createIndexes(client);
+                logger.info("成功创建索引");
+            } else {
+                logger.info("collection '{}' 已存在", MilvusConstants.MILVUS_COLLECTION_NAME);
+            }
+
+            // 3. 加载 collection 到内存（搜索必须）
+            logger.info("正在加载 collection '{}' 到内存...", MilvusConstants.MILVUS_COLLECTION_NAME);
+            R<RpcStatus> loadResp = client.loadCollection(LoadCollectionParam.newBuilder()
+                    .withCollectionName(MilvusConstants.MILVUS_COLLECTION_NAME)
+                    .build());
+            if (loadResp.getStatus() == 0) {
+                logger.info("collection '{}' 已加载", MilvusConstants.MILVUS_COLLECTION_NAME);
+            } else {
+                logger.warn("collection '{}' 加载失败: {}", MilvusConstants.MILVUS_COLLECTION_NAME, loadResp.getMessage());
+            }
+
+            return client;
+
+        } catch (Exception e) {
+            logger.error("创建 Milvus 客户端失败", e);
+            if (client != null) {
+                client.close();
+            }
+            throw new RuntimeException("创建 Milvus 客户端失败: " + e.getMessage(), e);
+        }
+    }
+
+    /**
+     * 连接到 Milvus
+     */
+    private MilvusServiceClient connectToMilvus() {
+        ConnectParam.Builder builder = ConnectParam.newBuilder()
+                .withHost(milvusProperties.getHost())
+                .withPort(milvusProperties.getPort())
+                .withDatabaseName(milvusProperties.getDatabase())
+                .withConnectTimeout(milvusProperties.getTimeout(), TimeUnit.MILLISECONDS);
+
+        // Zilliz Cloud: token + SSL
+        if (milvusProperties.getToken() != null && !milvusProperties.getToken().isEmpty()) {
+            builder.withToken(milvusProperties.getToken());
+            builder.withSecure(true);
+        }
+        // 本地 Milvus: username + password
+        else if (milvusProperties.getUsername() != null && !milvusProperties.getUsername().isEmpty()) {
+            builder.withAuthorization(milvusProperties.getUsername(), milvusProperties.getPassword());
+        }
+
+        return new MilvusServiceClient(builder.build());
+    }
+
+    /**
+     * 检查 collection 是否存在
+     */
+    private boolean collectionExists(MilvusServiceClient client, String collectionName) {
+        R<Boolean> response = client.hasCollection(HasCollectionParam.newBuilder()
+                .withCollectionName(collectionName)
+                .build());
+
+        if (response.getStatus() != 0) {
+            throw new RuntimeException("检查 collection 失败: " + response.getMessage());
+        }
+
+        return response.getData();
+    }
+
+    /**
+     * 创建 biz collection
+     */
+    private void createBizCollection(MilvusServiceClient client) {
+        // 定义字段
+        FieldType idField = FieldType.newBuilder()
+                .withName("id")
+                .withDataType(DataType.VarChar)
+                .withMaxLength(MilvusConstants.ID_MAX_LENGTH)
+                .withPrimaryKey(true)
+                .build();
+
+        FieldType vectorField = FieldType.newBuilder()
+                .withName("vector")
+                .withDataType(DataType.FloatVector)  // 改为 FloatVector
+                .withDimension(milvusProperties.getVectorDim())
+                .build();
+
+        FieldType contentField = FieldType.newBuilder()
+                .withName("content")
+                .withDataType(DataType.VarChar)
+                .withMaxLength(MilvusConstants.CONTENT_MAX_LENGTH)
+                .build();
+
+        FieldType metadataField = FieldType.newBuilder()
+                .withName("metadata")
+                .withDataType(DataType.JSON)
+                .build();
+
+        // 创建 collection schema
+        CollectionSchemaParam schema = CollectionSchemaParam.newBuilder()
+                .withEnableDynamicField(false)
+                .addFieldType(idField)
+                .addFieldType(vectorField)
+                .addFieldType(contentField)
+                .addFieldType(metadataField)
+                .build();
+
+        // 创建 collection
+        CreateCollectionParam createParam = CreateCollectionParam.newBuilder()
+                .withCollectionName(MilvusConstants.MILVUS_COLLECTION_NAME)
+                .withDescription("Business knowledge collection")
+                .withSchema(schema)
+                .withShardsNum(MilvusConstants.DEFAULT_SHARD_NUMBER)
+                .build();
+
+        R<RpcStatus> response = client.createCollection(createParam);
+        if (response.getStatus() != 0) {
+            throw new RuntimeException("创建 collection 失败: " + response.getMessage());
+        }
+    }
+
+    /**
+     * 为 collection 创建索引
+     */
+    private void createIndexes(MilvusServiceClient client) {
+        // 为 vector 字段创建索引（FloatVector 使用 IVF_FLAT 和 L2 距离）
+        CreateIndexParam vectorIndexParam = CreateIndexParam.newBuilder()
+                .withCollectionName(MilvusConstants.MILVUS_COLLECTION_NAME)
+                .withFieldName("vector")
+                .withIndexType(IndexType.IVF_FLAT)
+                .withMetricType(MetricType.L2)  // L2 距离（欧氏距离）
+                .withExtraParam("{\"nlist\":128}")
+                .withSyncMode(Boolean.FALSE)
+                .build();
+
+        R<RpcStatus> response = client.createIndex(vectorIndexParam);
+        if (response.getStatus() != 0) {
+            throw new RuntimeException("创建 vector 索引失败: " + response.getMessage());
+        }
+        
+        logger.info("成功为 vector 字段创建索引");
+    }
+}

src/main/java/com/superbiz/agent/config/DashScopeConfig.java

@@ -0,0 +1,40 @@
+package com.superbiz.agent.config;
+
+import okhttp3.OkHttpClient;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.client.OkHttp3ClientHttpRequestFactory;
+import org.springframework.web.client.RestClient;
+
+import java.time.Duration;
+
+/**
+ * DashScope API 配置
+ * 用于配置超时时间等参数
+ */
+@Configuration
+public class DashScopeConfig {
+
+    @Value("${spring.ai.dashscope.chat.options.timeout:180000}")
+    private long timeout;
+
+    /**
+     * 配置 RestClient.Builder，设置超时时间
+     * Spring AI 会自动使用这个 Bean
+     */
+    @Bean
+    public RestClient.Builder restClientBuilder() {
+        // 创建自定义的 OkHttpClient，设置超时时间
+        OkHttpClient okHttpClient = new OkHttpClient.Builder()
+                .connectTimeout(Duration.ofMillis(timeout))
+                .readTimeout(Duration.ofMillis(timeout))
+                .writeTimeout(Duration.ofMillis(timeout))
+                .callTimeout(Duration.ofMillis(timeout))
+                .build();
+
+        // 创建 RestClient.Builder 并配置 OkHttpClient
+        return RestClient.builder()
+                .requestFactory(new OkHttp3ClientHttpRequestFactory(okHttpClient));
+    }
+}

src/main/java/com/superbiz/agent/config/DocumentChunkConfig.java

@@ -0,0 +1,52 @@
+package com.superbiz.agent.config;
+
+import lombok.Getter;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * 文档分片配置
+ */
+@Getter
+@Configuration
+@ConfigurationProperties(prefix = "document.chunk")
+public class DocumentChunkConfig {
+
+    /**
+     * 每个分片的最大字符数（保留向后兼容）
+     */
+    private int maxSize = 800;
+
+    /**
+     * 分片之间的重叠字符数
+     */
+    private int overlap = 100;
+
+    /**
+     * 每个分片的最大 token 数（中文~1:1，英文~0.25:1）
+     * 替代 maxSize 作为切割触发器
+     */
+    private int maxTokens = 500;
+
+    /**
+     * 硬上限 token 数 = maxTokens × 1.2
+     * 仅在不可中断上下文（列表、代码块）内触发
+     */
+    private int maxTokensHard = 600;
+
+    public void setMaxSize(int maxSize) {
+        this.maxSize = maxSize;
+    }
+
+    public void setOverlap(int overlap) {
+        this.overlap = overlap;
+    }
+
+    public void setMaxTokens(int maxTokens) {
+        this.maxTokens = maxTokens;
+    }
+
+    public void setMaxTokensHard(int maxTokensHard) {
+        this.maxTokensHard = maxTokensHard;
+    }
+}

src/main/java/com/superbiz/agent/config/FileUploadConfig.java

@@ -0,0 +1,22 @@
+package com.superbiz.agent.config;
+
+import lombok.Getter;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+@Getter
+@Configuration
+@ConfigurationProperties(prefix = "file.upload")
+public class FileUploadConfig {
+
+    private String path;
+    private String allowedExtensions;
+
+    public void setPath(String path) {
+        this.path = path;
+    }
+
+    public void setAllowedExtensions(String allowedExtensions) {
+        this.allowedExtensions = allowedExtensions;
+    }
+}

src/main/java/com/superbiz/agent/config/MilvusConfig.java

@@ -0,0 +1,51 @@
+package com.superbiz.agent.config;
+
+import io.milvus.client.MilvusServiceClient;
+import com.superbiz.agent.client.MilvusClientFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import jakarta.annotation.PreDestroy;
+
+/**
+ * Milvus 配置类
+ * 负责创建和管理 MilvusServiceClient Bean
+ */
+@Configuration
+public class MilvusConfig {
+
+    private static final Logger logger = LoggerFactory.getLogger(MilvusConfig.class);
+
+    @Autowired
+    private MilvusClientFactory milvusClientFactory;
+
+    private MilvusServiceClient milvusClient;
+
+    /**
+     * 创建 MilvusServiceClient Bean
+     * 
+     * @return MilvusServiceClient 实例
+     */
+    @Bean
+    public MilvusServiceClient milvusServiceClient() {
+        logger.info("正在初始化 Milvus 客户端...");
+        milvusClient = milvusClientFactory.createClient();
+        logger.info("Milvus 客户端初始化完成");
+        return milvusClient;
+    }
+
+    /**
+     * 应用关闭时清理资源
+     */
+    @PreDestroy
+    public void cleanup() {
+        if (milvusClient != null) {
+            logger.info("正在关闭 Milvus 客户端连接...");
+            milvusClient.close();
+            logger.info("Milvus 客户端连接已关闭");
+        }
+    }
+}

src/main/java/com/superbiz/agent/config/MilvusProperties.java

@@ -0,0 +1,95 @@
+package com.superbiz.agent.config;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ConfigurationProperties(prefix = "milvus")
+public class MilvusProperties {
+
+    private String host = "localhost";
+    private Integer port = 19530;
+    private String username = "";
+    private String password = "";
+    private String database = "default";
+    private Long timeout = 10000L;
+    private String token = "";
+    private boolean secure = false;
+    private int vectorDim = 1024;
+
+    public String getHost() {
+        return host;
+    }
+
+    public void setHost(String host) {
+        this.host = host;
+    }
+
+    public Integer getPort() {
+        return port;
+    }
+
+    public void setPort(Integer port) {
+        this.port = port;
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public String getDatabase() {
+        return database;
+    }
+
+    public void setDatabase(String database) {
+        this.database = database;
+    }
+
+    public Long getTimeout() {
+        return timeout;
+    }
+
+    public void setTimeout(Long timeout) {
+        this.timeout = timeout;
+    }
+
+    public String getToken() {
+        return token;
+    }
+
+    public void setToken(String token) {
+        this.token = token;
+    }
+
+    public boolean isSecure() {
+        return secure;
+    }
+
+    public void setSecure(boolean secure) {
+        this.secure = secure;
+    }
+
+    public int getVectorDim() {
+        return vectorDim;
+    }
+
+    public void setVectorDim(int vectorDim) {
+        this.vectorDim = vectorDim;
+    }
+
+    public String getAddress() {
+        return host + ":" + port;
+    }
+}

src/main/java/com/superbiz/agent/config/ModelRoutingConfig.java

@@ -0,0 +1,91 @@
+package com.superbiz.agent.config;
+
+import java.util.List;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.ai.chat.model.ChatModel;
+import org.springframework.ai.embedding.EmbeddingModel;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+
+/**
+ * 模型路由配置 — 由 yml 驱动，不硬编码模型名。
+ * <p>
+ * 配置示例：
+ * <pre>{@code
+ * model-routing:
+ *   chat: deepseek
+ *   embedding: siliconflow
+ * }</pre>
+ * <p>
+ * 匹配优先级：Bean 名 > 类名（均不区分大小写）。
+ * 切换模型只改 yml + pom + 对应 api-key，Java 代码不动。
+ */
+@Configuration
+public class ModelRoutingConfig {
+
+    private static final Logger log = LoggerFactory.getLogger(ModelRoutingConfig.class);
+
+    @Value("${model-routing.chat:deepseek}")
+    private String chatKeyword;
+
+    @Value("${model-routing.embedding:siliconflow}")
+    private String embeddingKeyword;
+
+    @Bean
+    @Primary
+    public ChatModel chatModel(List<ChatModel> chatModels) {
+        log.info("Chat 路由: keyword='{}', 可用: {}", chatKeyword,
+                chatModels.stream().map(c -> c.getClass().getSimpleName()).toList());
+
+        for (ChatModel cm : chatModels) {
+            if (matches(cm.getClass(), chatKeyword)) {
+                log.info("  → 选中 {}", cm.getClass().getSimpleName());
+                return cm;
+            }
+        }
+
+        log.warn("  → 未匹配, 回退到 {}", chatModels.get(0).getClass().getSimpleName());
+        return chatModels.get(0);
+    }
+
+    @Bean
+    @Primary
+    public EmbeddingModel embeddingModel(Map<String, EmbeddingModel> embeddingBeans) {
+        log.info("Embedding 路由: keyword='{}', 可用: {}", embeddingKeyword, embeddingBeans.keySet());
+
+        // 先按 Bean 名匹配
+        for (Map.Entry<String, EmbeddingModel> entry : embeddingBeans.entrySet()) {
+            if (containsIgnoreCase(entry.getKey(), embeddingKeyword)) {
+                log.info("  → Bean 名匹配: {} → {}", entry.getKey(),
+                        entry.getValue().getClass().getSimpleName());
+                return entry.getValue();
+            }
+        }
+
+        // 再按类名匹配
+        for (EmbeddingModel em : embeddingBeans.values()) {
+            if (matches(em.getClass(), embeddingKeyword)) {
+                log.info("  → 类名匹配: {}", em.getClass().getSimpleName());
+                return em;
+            }
+        }
+
+        var first = embeddingBeans.values().iterator().next();
+        log.warn("  → 未匹配, 回退到 {}", first.getClass().getSimpleName());
+        return first;
+    }
+
+    private boolean matches(Class<?> clazz, String keyword) {
+        return containsIgnoreCase(clazz.getName(), keyword)
+                || containsIgnoreCase(clazz.getSimpleName(), keyword);
+    }
+
+    private boolean containsIgnoreCase(String text, String keyword) {
+        return text.toLowerCase().contains(keyword.toLowerCase());
+    }
+}

src/main/java/com/superbiz/agent/config/SessionConfiguration.java

@@ -0,0 +1,55 @@
+package com.superbiz.agent.config;
+
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+/**
+ * Redis 会话配置
+ */
+@Configuration
+public class SessionConfiguration {
+
+    /**
+     * 配置 RedisTemplate
+     * 使用 JSON 序列化存储会话对象
+     */
+    @Bean
+    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
+        RedisTemplate<String, Object> template = new RedisTemplate<>();
+        template.setConnectionFactory(connectionFactory);
+
+        // 配置 ObjectMapper 支持 Java 8 时间类型
+        ObjectMapper objectMapper = new ObjectMapper();
+        objectMapper.registerModule(new JavaTimeModule());
+
+        // 启用类型信息，支持多态反序列化
+        objectMapper.activateDefaultTyping(
+            LaissezFaireSubTypeValidator.instance,
+            ObjectMapper.DefaultTyping.NON_FINAL,
+            JsonTypeInfo.As.PROPERTY
+        );
+
+        // 使用 JSON 序列化器
+        GenericJackson2JsonRedisSerializer jsonSerializer =
+            new GenericJackson2JsonRedisSerializer(objectMapper);
+
+        // Key 使用 String 序列化
+        template.setKeySerializer(new StringRedisSerializer());
+        template.setHashKeySerializer(new StringRedisSerializer());
+
+        // Value 使用 JSON 序列化
+        template.setValueSerializer(jsonSerializer);
+        template.setHashValueSerializer(jsonSerializer);
+
+        template.afterPropertiesSet();
+        return template;
+    }
+}

src/main/java/com/superbiz/agent/config/SiliconFlowEmbeddingConfig.java

@@ -0,0 +1,54 @@
+package com.superbiz.agent.config;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.ai.document.MetadataMode;
+import org.springframework.ai.embedding.EmbeddingModel;
+import org.springframework.ai.openai.OpenAiEmbeddingModel;
+import org.springframework.ai.openai.OpenAiEmbeddingOptions;
+import org.springframework.ai.openai.api.OpenAiApi;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.client.RestClient;
+import org.springframework.web.reactive.function.client.WebClient;
+
+/**
+ * SiliconFlow Embedding 配置（BGE-M3, OpenAI 兼容协议, 1024维）
+ * <p>
+ * Chat 走 DeepSeek、Embedding 走 SiliconFlow，两者都是 OpenAI 兼容但地址不同，
+ * 因此单独为 SiliconFlow 创建 OpenAiApi + EmbeddingModel Bean。
+ */
+@Configuration
+public class SiliconFlowEmbeddingConfig {
+
+    private static final Logger log = LoggerFactory.getLogger(SiliconFlowEmbeddingConfig.class);
+
+    @Value("${siliconflow.api-key}")
+    private String apiKey;
+
+    @Value("${siliconflow.base-url}")
+    private String baseUrl;
+
+    @Value("${siliconflow.embedding.model}")
+    private String model;
+
+    @Bean
+    public OpenAiApi siliconFlowApi(RestClient.Builder restClientBuilder, WebClient.Builder webClientBuilder) {
+        log.info("创建 SiliconFlow OpenAiApi: {}", baseUrl);
+        return OpenAiApi.builder()
+                .baseUrl(baseUrl)
+                .apiKey(apiKey)
+                .restClientBuilder(restClientBuilder)
+                .build();
+    }
+
+    @Bean
+    public EmbeddingModel siliconFlowEmbeddingModel(OpenAiApi siliconFlowApi) {
+        log.info("创建 SiliconFlow EmbeddingModel, model: {}", model);
+        return new OpenAiEmbeddingModel(siliconFlowApi, MetadataMode.EMBED,
+                OpenAiEmbeddingOptions.builder()
+                        .model(model)
+                        .build());
+    }
+}

src/main/java/com/superbiz/agent/config/WebConfig.java

@@ -0,0 +1,38 @@
+package com.superbiz.agent.config;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.converter.HttpMessageConverter;
+import org.springframework.http.converter.StringHttpMessageConverter;
+import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+/**
+ * Web MVC 配置
+ * 解决中文乱码问题
+ */
+@Configuration
+public class WebConfig implements WebMvcConfigurer {
+
+    @Override
+    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
+        // 添加 UTF-8 字符串转换器
+        StringHttpMessageConverter stringConverter = new StringHttpMessageConverter(StandardCharsets.UTF_8);
+        stringConverter.setWriteAcceptCharset(false); // 不设置 Accept-Charset
+        converters.add(0, stringConverter);
+        
+        // 添加 Jackson JSON 转换器，确保 UTF-8 编码
+        MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
+        jsonConverter.setDefaultCharset(StandardCharsets.UTF_8);
+        converters.add(1, jsonConverter);
+    }
+    
+    @Bean
+    public ObjectMapper objectMapper() {
+        return new ObjectMapper();
+    }
+}

src/main/java/com/superbiz/agent/config/WebMvcConfig.java

@@ -0,0 +1,30 @@
+package com.superbiz.agent.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.CorsRegistry;
+import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+/**
+ * Web MVC 配置
+ * 配置跨域和静态资源
+ */
+@Configuration
+public class WebMvcConfig implements WebMvcConfigurer {
+
+    @Override
+    public void addCorsMappings(CorsRegistry registry) {
+        registry.addMapping("/**")
+                .allowedOrigins("*")
+                .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")
+                .allowedHeaders("*")
+                .maxAge(3600);
+    }
+
+    @Override
+    public void addResourceHandlers(ResourceHandlerRegistry registry) {
+        // 配置静态资源映射
+        registry.addResourceHandler("/**")
+                .addResourceLocations("classpath:/static/");
+    }
+}

src/main/java/com/superbiz/agent/constant/MilvusConstants.java

@@ -0,0 +1,38 @@
+package com.superbiz.agent.constant;
+
+public class MilvusConstants {
+    
+    /**
+     * Milvus 数据库名称
+     */
+    public static final String MILVUS_DB_NAME = "default";
+    
+    /**
+     * Milvus 集合名称
+     */
+    public static final String MILVUS_COLLECTION_NAME = "biz";
+    
+    /**
+     * 向量维度（豆包 embedding 模型的维度）
+     */
+    public static final int VECTOR_DIM = 1024;  // 豆包模型返回1024维向量
+    
+    /**
+     * ID字段最大长度
+     */
+    public static final int ID_MAX_LENGTH = 256;
+    
+    /**
+     * Content字段最大长度
+     */
+    public static final int CONTENT_MAX_LENGTH = 8192;
+    
+    /**
+     * 默认分片数
+     */
+    public static final int DEFAULT_SHARD_NUMBER = 2;
+    
+    private MilvusConstants() {
+        // 工具类，禁止实例化
+    }
+}

src/main/java/com/superbiz/agent/controller/ChatController.java

@@ -0,0 +1,616 @@
+package com.superbiz.agent.controller;
+
+import com.alibaba.cloud.ai.graph.NodeOutput;
+import com.alibaba.cloud.ai.graph.OverAllState;
+import com.alibaba.cloud.ai.graph.agent.ReactAgent;
+import com.alibaba.cloud.ai.graph.streaming.OutputType;
+import com.alibaba.cloud.ai.graph.streaming.StreamingOutput;
+import lombok.Getter;
+import lombok.Setter;
+import com.superbiz.agent.service.AiOpsService;
+import com.superbiz.agent.service.ChatService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.ai.chat.model.ChatModel;
+import org.springframework.ai.tool.ToolCallback;
+import org.springframework.ai.tool.ToolCallbackProvider;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
+import reactor.core.publisher.Flux;
+
+import java.io.IOException;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * 统一 API 控制器
+ * 适配前端接口需求
+ */
+@RestController
+@RequestMapping("/api")
+public class ChatController {
+
+    private static final Logger logger = LoggerFactory.getLogger(ChatController.class);
+
+    @Autowired
+    private AiOpsService aiOpsService;
+    
+    @Autowired
+    private ChatService chatService;
+
+    @Autowired(required = false)
+    private ToolCallbackProvider tools;
+
+    private final ExecutorService executor = Executors.newCachedThreadPool();
+
+    // 存储会话信息
+    private final Map<String, SessionInfo> sessions = new ConcurrentHashMap<>();
+    
+    // 最大历史消息窗口大小（成对计算：用户消息+AI回复=1对）
+    private static final int MAX_WINDOW_SIZE = 6;
+
+    /**
+     * 普通对话接口（支持工具调用）
+     * 与 /chat_react 逻辑一致，但直接返回完整结果而非流式输出
+     */
+    @PostMapping("/chat")
+    public ResponseEntity<ApiResponse<ChatResponse>> chat(@RequestBody ChatRequest request) {
+        try {
+            logger.info("收到对话请求 - SessionId: {}, Question: {}", request.getId(), request.getQuestion());
+
+            // 参数校验
+            if (request.getQuestion() == null || request.getQuestion().trim().isEmpty()) {
+                logger.warn("问题内容为空");
+                return ResponseEntity.ok(ApiResponse.success(ChatResponse.error("问题内容不能为空")));
+            }
+
+            // 获取或创建会话
+            SessionInfo session = getOrCreateSession(request.getId());
+            
+            // 获取历史消息
+            List<Map<String, String>> history = session.getHistory();
+            logger.info("会话历史消息对数: {}", history.size() / 2);
+
+            // 获取注入的 ChatModel
+            ChatModel chatModel = chatService.getChatModel();
+
+            // 记录可用工具
+            chatService.logAvailableTools();
+
+            logger.info("开始 ReactAgent 对话（支持自动工具调用）");
+            
+            // 构建系统提示词（包含历史消息）
+            String systemPrompt = chatService.buildSystemPrompt(history);
+            
+            // 创建 ReactAgent
+            ReactAgent agent = chatService.createReactAgent(chatModel, systemPrompt);
+            
+            // 执行对话
+            String fullAnswer = chatService.executeChat(agent, request.getQuestion());
+            
+            // 更新会话历史
+            session.addMessage(request.getQuestion(), fullAnswer);
+            logger.info("已更新会话历史 - SessionId: {}, 当前消息对数: {}", 
+                request.getId(), session.getMessagePairCount());
+            
+            return ResponseEntity.ok(ApiResponse.success(ChatResponse.success(fullAnswer)));
+
+        } catch (Exception e) {
+            logger.error("对话失败", e);
+            return ResponseEntity.ok(ApiResponse.success(ChatResponse.error(e.getMessage())));
+        }
+    }
+
+    /**
+     * 清空会话历史
+     */
+    @PostMapping("/chat/clear")
+    public ResponseEntity<ApiResponse<String>> clearChatHistory(@RequestBody ClearRequest request) {
+        try {
+            logger.info("收到清空会话历史请求 - SessionId: {}", request.getId());
+
+            if (request.getId() == null || request.getId().isEmpty()) {
+                return ResponseEntity.ok(ApiResponse.error("会话ID不能为空"));
+            }
+
+            SessionInfo session = sessions.get(request.getId());
+            if (session != null) {
+                session.clearHistory();
+                return ResponseEntity.ok(ApiResponse.success("会话历史已清空"));
+            } else {
+                return ResponseEntity.ok(ApiResponse.error("会话不存在"));
+            }
+
+        } catch (Exception e) {
+            logger.error("清空会话历史失败", e);
+            return ResponseEntity.ok(ApiResponse.error(e.getMessage()));
+        }
+    }
+
+    /**
+     * ReactAgent 对话接口（SSE 流式模式，支持多轮对话，支持自动工具调用，例如获取当前时间，查询日志，告警等）
+     * 支持 session 管理，保留对话历史
+     */
+    @PostMapping(value = "/chat_stream", produces = "text/event-stream;charset=UTF-8")
+    public SseEmitter chatStream(@RequestBody ChatRequest request) {
+        SseEmitter emitter = new SseEmitter(300000L); // 5分钟超时
+
+        // 参数校验
+        if (request.getQuestion() == null || request.getQuestion().trim().isEmpty()) {
+            logger.warn("问题内容为空");
+            try {
+                emitter.send(SseEmitter.event().name("message").data(SseMessage.error("问题内容不能为空"), MediaType.APPLICATION_JSON));
+                emitter.complete();
+            } catch (IOException e) {
+                emitter.completeWithError(e);
+            }
+            return emitter;
+        }
+
+        executor.execute(() -> {
+            try {
+                logger.info("收到 ReactAgent 对话请求 - SessionId: {}, Question: {}", request.getId(), request.getQuestion());
+
+                // 获取或创建会话
+                SessionInfo session = getOrCreateSession(request.getId());
+                
+                // 获取历史消息
+                List<Map<String, String>> history = session.getHistory();
+                logger.info("ReactAgent 会话历史消息对数: {}", history.size() / 2);
+
+                // 获取注入的 ChatModel
+                ChatModel chatModel = chatService.getChatModel();
+
+                // 记录可用工具
+                chatService.logAvailableTools();
+
+                logger.info("开始 ReactAgent 流式对话（支持自动工具调用）");
+                
+                // 构建系统提示词（包含历史消息）
+                String systemPrompt = chatService.buildSystemPrompt(history);
+                
+                // 创建 ReactAgent
+                ReactAgent agent = chatService.createReactAgent(chatModel, systemPrompt);
+                
+                // 用于累积完整答案
+                StringBuilder fullAnswerBuilder = new StringBuilder();
+                
+                // 使用 agent.stream() 进行流式对话
+                Flux<NodeOutput> stream = agent.stream(request.getQuestion());
+                
+                stream.subscribe(
+                    output -> {
+                        try {
+                            // 检查是否为 StreamingOutput 类型
+                            if (output instanceof StreamingOutput streamingOutput) {
+                                OutputType type = streamingOutput.getOutputType();
+                                
+                                // 处理模型推理的流式输出
+                                if (type == OutputType.AGENT_MODEL_STREAMING) {
+                                    // 流式增量内容，逐步显示
+                                    String chunk = streamingOutput.message().getText();
+                                    if (chunk != null && !chunk.isEmpty()) {
+                                        fullAnswerBuilder.append(chunk);
+                                        
+                                        // 实时发送到前端
+                                        emitter.send(SseEmitter.event()
+                                                .name("message")
+                                                .data(SseMessage.content(chunk), MediaType.APPLICATION_JSON));
+                                        
+                                        logger.info("发送流式内容: {}", chunk);
+                                    }
+                                } else if (type == OutputType.AGENT_MODEL_FINISHED) {
+                                    // 模型推理完成
+                                    logger.info("模型输出完成");
+                                } else if (type == OutputType.AGENT_TOOL_FINISHED) {
+                                    // 工具调用完成
+                                    logger.info("工具调用完成: {}", output.node());
+                                } else if (type == OutputType.AGENT_HOOK_FINISHED) {
+                                    // Hook 执行完成
+                                    logger.debug("Hook 执行完成: {}", output.node());
+                                }
+                            }
+                        } catch (IOException e) {
+                            logger.error("发送流式消息失败", e);
+                            throw new RuntimeException(e);
+                        }
+                    },
+                    error -> {
+                        // 错误处理
+                        logger.error("ReactAgent 流式对话失败", error);
+                        try {
+                            emitter.send(SseEmitter.event()
+                                    .name("message")
+                                    .data(SseMessage.error(error.getMessage()), MediaType.APPLICATION_JSON));
+                        } catch (IOException ex) {
+                            logger.error("发送错误消息失败", ex);
+                        }
+                        emitter.completeWithError(error);
+                    },
+                    () -> {
+                        // 完成处理
+                        try {
+                            String fullAnswer = fullAnswerBuilder.toString();
+                            logger.info("ReactAgent 流式对话完成 - SessionId: {}, 答案长度: {}", 
+                                request.getId(), fullAnswer.length());
+                            
+                            // 更新会话历史
+                            session.addMessage(request.getQuestion(), fullAnswer);
+                            logger.info("已更新会话历史 - SessionId: {}, 当前消息对数: {}", 
+                                request.getId(), session.getMessagePairCount());
+                            
+                            // 发送完成标记
+                            emitter.send(SseEmitter.event()
+                                    .name("message")
+                                    .data(SseMessage.done(), MediaType.APPLICATION_JSON));
+                            emitter.complete();
+                        } catch (IOException e) {
+                            logger.error("发送完成消息失败", e);
+                            emitter.completeWithError(e);
+                        }
+                    }
+                );
+
+            } catch (Exception e) {
+                logger.error("ReactAgent 对话初始化失败", e);
+                try {
+                    emitter.send(SseEmitter.event()
+                            .name("message")
+                            .data(SseMessage.error(e.getMessage()), MediaType.APPLICATION_JSON));
+                } catch (IOException ex) {
+                    logger.error("发送错误消息失败", ex);
+                }
+                emitter.completeWithError(e);
+            }
+        });
+
+        return emitter;
+    }
+
+    /**
+     * AI 智能运维接口（SSE 流式模式）- 自动分析告警并生成运维报告
+     * 无需用户输入，自动执行告警分析流程
+     */
+    @PostMapping(value = "/ai_ops", produces = "text/event-stream;charset=UTF-8")
+    public SseEmitter aiOps() {
+        SseEmitter emitter = new SseEmitter(600000L); // 10分钟超时（告警分析可能较慢）
+
+        executor.execute(() -> {
+            try {
+                logger.info("收到 AI 智能运维请求 - 启动多 Agent 协作流程");
+
+                ChatModel chatModel = chatService.getChatModel();
+
+                ToolCallback[] toolCallbacks = tools != null ? tools.getToolCallbacks() : new ToolCallback[0];
+
+                emitter.send(SseEmitter.event().name("message").data(SseMessage.content("正在读取告警并拆解任务...\n")));
+                
+                // 调用 AiOpsService 执行分析流程
+                Optional<OverAllState> overAllStateOptional = aiOpsService.executeAiOpsAnalysis(chatModel, toolCallbacks);
+
+                if (overAllStateOptional.isEmpty()) {
+                    emitter.send(SseEmitter.event().name("message")
+                            .data(SseMessage.error("多 Agent 编排未获取到有效结果"), MediaType.APPLICATION_JSON));
+                    emitter.complete();
+                    return;
+                }
+
+                OverAllState state = overAllStateOptional.get();
+                logger.info("AI Ops 编排完成，开始提取最终报告...");
+
+                // 提取最终报告
+                Optional<String> finalReportOptional = aiOpsService.extractFinalReport(state);
+
+                // 输出最终报告
+                if (finalReportOptional.isPresent()) {
+                    String finalReportText = finalReportOptional.get();
+                    logger.info("提取到 Planner 最终报告，长度: {}", finalReportText.length());
+                    
+                    // 发送分隔线
+                    emitter.send(SseEmitter.event().name("message")
+                            .data(SseMessage.content("\n\n" + "=".repeat(60) + "\n"), MediaType.APPLICATION_JSON));
+                    
+                    // 发送完整的告警分析报告
+                    emitter.send(SseEmitter.event().name("message")
+                            .data(SseMessage.content("📋 **告警分析报告**\n\n"), MediaType.APPLICATION_JSON));
+                    
+                    int chunkSize = 50;
+                    for (int i = 0; i < finalReportText.length(); i += chunkSize) {
+                        int end = Math.min(i + chunkSize, finalReportText.length());
+                        String chunk = finalReportText.substring(i, end);
+                        
+                        emitter.send(SseEmitter.event().name("message")
+                                .data(SseMessage.content(chunk), MediaType.APPLICATION_JSON));
+                    }
+                    
+                    // 发送结束分隔线
+                    emitter.send(SseEmitter.event().name("message")
+                            .data(SseMessage.content("\n" + "=".repeat(60) + "\n\n"), MediaType.APPLICATION_JSON));
+                    
+                    logger.info("最终报告已完整输出");
+                } else {
+                    logger.warn("未能提取到 Planner 最终报告");
+                    emitter.send(SseEmitter.event().name("message")
+                            .data(SseMessage.content("⚠️ 多 Agent 流程已完成，但未能生成最终报告。"), MediaType.APPLICATION_JSON));
+                }
+
+                emitter.send(SseEmitter.event().name("message").data(SseMessage.done(), MediaType.APPLICATION_JSON));
+                emitter.complete();
+                logger.info("AI Ops 多 Agent 编排完成");
+
+            } catch (Exception e) {
+                logger.error("AI Ops 多 Agent 协作失败", e);
+                try {
+                    emitter.send(SseEmitter.event().name("message")
+                            .data(SseMessage.error("AI Ops 流程失败: " + e.getMessage()), MediaType.APPLICATION_JSON));
+                } catch (IOException ex) {
+                    logger.error("发送错误消息失败", ex);
+                }
+                emitter.completeWithError(e);
+            }
+        });
+
+        return emitter;
+    }
+
+
+    /**
+     * 获取会话信息
+     */
+    @GetMapping("/chat/session/{sessionId}")
+    public ResponseEntity<ApiResponse<SessionInfoResponse>> getSessionInfo(@PathVariable String sessionId) {
+        try {
+            logger.info("收到获取会话信息请求 - SessionId: {}", sessionId);
+
+            SessionInfo session = sessions.get(sessionId);
+            if (session != null) {
+                SessionInfoResponse response = new SessionInfoResponse();
+                response.setSessionId(sessionId);
+                response.setMessagePairCount(session.getMessagePairCount());
+                response.setCreateTime(session.createTime);
+                return ResponseEntity.ok(ApiResponse.success(response));
+            } else {
+                return ResponseEntity.ok(ApiResponse.error("会话不存在"));
+            }
+
+        } catch (Exception e) {
+            logger.error("获取会话信息失败", e);
+            return ResponseEntity.ok(ApiResponse.error(e.getMessage()));
+        }
+    }
+
+    // ==================== 辅助方法 ====================
+
+    private SessionInfo getOrCreateSession(String sessionId) {
+        if (sessionId == null || sessionId.isEmpty()) {
+            sessionId = UUID.randomUUID().toString();
+        }
+        return sessions.computeIfAbsent(sessionId, SessionInfo::new);
+    }
+
+    // ==================== 内部类 ====================
+
+    /**
+     * 会话信息
+     * 管理单个会话的历史消息，支持自动清理和线程安全
+     */
+    private static class SessionInfo {
+        private final String sessionId;
+        // 存储历史消息对：[{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]
+        private final List<Map<String, String>> messageHistory;
+        private final long createTime;
+        private final ReentrantLock lock;
+
+        public SessionInfo(String sessionId) {
+            this.sessionId = sessionId;
+            this.messageHistory = new ArrayList<>();
+            this.createTime = System.currentTimeMillis();
+            this.lock = new ReentrantLock();
+        }
+
+        /**
+         * 添加一对消息（用户问题 + AI回复）
+         * 自动管理历史消息窗口大小
+         */
+        public void addMessage(String userQuestion, String aiAnswer) {
+            lock.lock();
+            try {
+                // 添加用户消息
+                Map<String, String> userMsg = new HashMap<>();
+                userMsg.put("role", "user");
+                userMsg.put("content", userQuestion);
+                messageHistory.add(userMsg);
+
+                // 添加AI回复
+                Map<String, String> assistantMsg = new HashMap<>();
+                assistantMsg.put("role", "assistant");
+                assistantMsg.put("content", aiAnswer);
+                messageHistory.add(assistantMsg);
+
+                // 自动清理：保持最多 MAX_WINDOW_SIZE 对消息
+                // 每对消息包含2条记录（user + assistant）
+                int maxMessages = MAX_WINDOW_SIZE * 2;
+                while (messageHistory.size() > maxMessages) {
+                    // 成对删除最旧的消息（删除前2条）
+                    messageHistory.remove(0); // 删除最旧的用户消息
+                    if (!messageHistory.isEmpty()) {
+                        messageHistory.remove(0); // 删除对应的AI回复
+                    }
+                }
+
+                logger.debug("会话 {} 更新历史消息，当前消息对数: {}", 
+                    sessionId, messageHistory.size() / 2);
+
+            } finally {
+                lock.unlock();
+            }
+        }
+
+        /**
+         * 获取历史消息（线程安全）
+         * 返回副本以避免并发修改
+         */
+        public List<Map<String, String>> getHistory() {
+            lock.lock();
+            try {
+                return new ArrayList<>(messageHistory);
+            } finally {
+                lock.unlock();
+            }
+        }
+
+        /**
+         * 清空历史消息
+         */
+        public void clearHistory() {
+            lock.lock();
+            try {
+                messageHistory.clear();
+                logger.info("会话 {} 历史消息已清空", sessionId);
+            } finally {
+                lock.unlock();
+            }
+        }
+
+        /**
+         * 获取当前消息对数
+         */
+        public int getMessagePairCount() {
+            lock.lock();
+            try {
+                return messageHistory.size() / 2;
+            } finally {
+                lock.unlock();
+            }
+        }
+    }
+
+    /**
+     * 聊天请求
+     */
+    @Setter
+    @Getter
+    public static class ChatRequest {
+        @com.fasterxml.jackson.annotation.JsonProperty(value = "Id")
+        @com.fasterxml.jackson.annotation.JsonAlias({"id", "ID"})
+        private String Id;
+        
+        @com.fasterxml.jackson.annotation.JsonProperty(value = "Question")
+        @com.fasterxml.jackson.annotation.JsonAlias({"question", "QUESTION"})
+        private String Question;
+
+    }
+
+    /**
+     * 清空会话请求
+     */
+    @Setter
+    @Getter
+    public static class ClearRequest {
+        @com.fasterxml.jackson.annotation.JsonProperty(value = "Id")
+        @com.fasterxml.jackson.annotation.JsonAlias({"id", "ID"})
+        private String Id;
+    }
+
+    // ==================== 内部类 ====================
+
+    /**
+     * 会话信息响应
+     */
+    @Setter
+    @Getter
+    public static class SessionInfoResponse {
+        private String sessionId;
+        private int messagePairCount;
+        private long createTime;
+    }
+
+    /**
+     * 统一聊天响应格式
+     * 适用于所有普通返回模式的对话接口
+     */
+    @Setter
+    @Getter
+    public static class ChatResponse {
+        private boolean success;
+        private String answer;
+        private String errorMessage;
+
+        public static ChatResponse success(String answer) {
+            ChatResponse response = new ChatResponse();
+            response.setSuccess(true);
+            response.setAnswer(answer);
+            return response;
+        }
+
+        public static ChatResponse error(String errorMessage) {
+            ChatResponse response = new ChatResponse();
+            response.setSuccess(false);
+            response.setErrorMessage(errorMessage);
+            return response;
+        }
+    }
+
+    /**
+     * 统一 SSE 流式消息格式
+     * 适用于所有 SSE 流式返回模式的对话接口
+     */
+    @Setter
+    @Getter
+    public static class SseMessage {
+        private String type;  // content: 内容块, error: 错误, done: 完成
+        private String data;
+
+        public static SseMessage content(String data) {
+            SseMessage message = new SseMessage();
+            message.setType("content");
+            message.setData(data);
+            return message;
+        }
+
+        public static SseMessage error(String errorMessage) {
+            SseMessage message = new SseMessage();
+            message.setType("error");
+            message.setData(errorMessage);
+            return message;
+        }
+
+        public static SseMessage done() {
+            SseMessage message = new SseMessage();
+            message.setType("done");
+            message.setData(null);
+            return message;
+        }
+    }
+
+
+    @Getter
+    @Setter
+    public static class ApiResponse<T> {
+        private int code;
+        private String message;
+        private T data;
+
+        public static <T> ApiResponse<T> success(T data) {
+            ApiResponse<T> response = new ApiResponse<>();
+            response.setCode(200);
+            response.setMessage("success");
+            response.setData(data);
+            return response;
+        }
+
+        public static <T> ApiResponse<T> error(String message) {
+            ApiResponse<T> response = new ApiResponse<>();
+            response.setCode(500);
+            response.setMessage(message);
+            return response;
+        }
+
+    }
+}

src/main/java/com/superbiz/agent/controller/FileUploadController.java

@@ -0,0 +1,154 @@
+package com.superbiz.agent.controller;
+
+import com.superbiz.agent.config.FileUploadConfig;
+import com.superbiz.agent.dto.FileUploadRes;
+import com.superbiz.agent.service.VectorIndexService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.List;
+
+@RestController
+public class FileUploadController {
+
+    private static final Logger logger = LoggerFactory.getLogger(FileUploadController.class);
+
+    @Autowired
+    private FileUploadConfig fileUploadConfig;
+
+    @Autowired
+    private VectorIndexService vectorIndexService;
+
+    @PostMapping(value = "/api/upload", consumes = "multipart/form-data")
+    public ResponseEntity<?> upload(@RequestParam("file") MultipartFile file) {
+        if (file.isEmpty()) {
+            return ResponseEntity.badRequest().body("文件不能为空");
+        }
+
+        String originalFilename = file.getOriginalFilename();
+        if (originalFilename == null || originalFilename.isEmpty()) {
+            return ResponseEntity.badRequest().body("文件名不能为空");
+        }
+
+        String fileExtension = getFileExtension(originalFilename);
+        if (!isAllowedExtension(fileExtension)) {
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST)
+                    .body("不支持的文件格式，仅支持: " + fileUploadConfig.getAllowedExtensions());
+        }
+
+        try {
+            String uploadPath = fileUploadConfig.getPath();
+            Path uploadDir = Paths.get(uploadPath).normalize();
+            if (!Files.exists(uploadDir)) {
+                Files.createDirectories(uploadDir);
+            }
+
+            // 使用原始文件名，而不是UUID，以便实现基于文件名的去重
+            Path filePath = uploadDir.resolve(originalFilename).normalize();
+            
+            // 如果文件已存在，先删除旧文件（实现覆盖更新）
+            if (Files.exists(filePath)) {
+                logger.info("文件已存在，将覆盖: {}", filePath);
+                Files.delete(filePath);
+            }
+            
+            Files.copy(file.getInputStream(), filePath);
+
+            logger.info("文件上传成功: {}", filePath);
+
+            // 文件上传成功后，自动调用向量索引服务
+            try {
+                logger.info("开始为上传文件创建向量索引: {}", filePath);
+                vectorIndexService.indexSingleFile(filePath.toString());
+                logger.info("向量索引创建成功: {}", filePath);
+            } catch (Exception e) {
+                logger.error("向量索引创建失败: {}, 错误: {}", filePath, e.getMessage(), e);
+                // 注意：即使索引失败，文件上传仍然成功，只是记录错误日志
+                // 可以根据业务需求决定是否要删除文件或返回错误
+            }
+
+            FileUploadRes response = new FileUploadRes(
+                    originalFilename,
+                    filePath.toString(),
+                    file.getSize()
+            );
+
+            // 使用统一的API响应格式
+            ApiResponse<FileUploadRes> apiResponse = new ApiResponse<>();
+            apiResponse.setCode(200);
+            apiResponse.setMessage("success");
+            apiResponse.setData(response);
+            
+            return ResponseEntity.ok(apiResponse);
+
+        } catch (IOException e) {
+            ApiResponse<String> errorResponse = new ApiResponse<>();
+            errorResponse.setCode(500);
+            errorResponse.setMessage("文件上传失败: " + e.getMessage());
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                    .body(errorResponse);
+        }
+    }
+
+    /**
+     * 统一 API 响应格式
+     */
+    public static class ApiResponse<T> {
+        private int code;
+        private String message;
+        private T data;
+
+        public int getCode() {
+            return code;
+        }
+
+        public void setCode(int code) {
+            this.code = code;
+        }
+
+        public String getMessage() {
+            return message;
+        }
+
+        public void setMessage(String message) {
+            this.message = message;
+        }
+
+        public T getData() {
+            return data;
+        }
+
+        public void setData(T data) {
+            this.data = data;
+        }
+    }
+
+    private String getFileExtension(String filename) {
+        int lastIndexOf = filename.lastIndexOf(".");
+        if (lastIndexOf == -1) {
+            return "";
+        }
+        return filename.substring(lastIndexOf + 1).toLowerCase();
+    }
+
+    private boolean isAllowedExtension(String extension) {
+        String allowedExtensions = fileUploadConfig.getAllowedExtensions();
+        if (allowedExtensions == null || allowedExtensions.isEmpty()) {
+            return false;
+        }
+        List<String> allowedList = Arrays.asList(allowedExtensions.split(","));
+        return allowedList.contains(extension.toLowerCase());
+    }
+}

src/main/java/com/superbiz/agent/controller/MilvusCheckController.java

@@ -0,0 +1,50 @@
+package com.superbiz.agent.controller;
+
+import io.milvus.client.MilvusServiceClient;
+import io.milvus.grpc.ShowCollectionsResponse;
+import io.milvus.param.R;
+import io.milvus.param.collection.ShowCollectionsParam;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Milvus 测试控制器
+ * 用于测试数据库连接和数据读取
+ */
+@RestController
+@RequestMapping("/milvus")
+public class MilvusCheckController {
+
+    @Autowired
+    private MilvusServiceClient milvusClient;
+
+    /**
+     * 简单的健康检查
+     */
+    @GetMapping("/health")
+    public ResponseEntity<Map<String, Object>> simpleHealth() {
+        Map<String, Object> result = new HashMap<>();
+        
+        try {
+            R<ShowCollectionsResponse> response = milvusClient.showCollections(
+                ShowCollectionsParam.newBuilder().build()
+            );
+            
+            if (response.getStatus() == 0) {
+                result.put("message", "ok");
+                result.put("collections", response.getData().getCollectionNamesList());
+                return ResponseEntity.ok(result);
+            } else {
+                result.put("message", response.getMessage());
+                return ResponseEntity.status(503).body(result);
+            }
+        } catch (Exception e) {
+            result.put("error", e.getMessage());
+            return ResponseEntity.status(503).body(result);
+        }
+    }
+}

src/main/java/com/superbiz/agent/domain/entity/ApiDocument.java

@@ -0,0 +1,95 @@
+package com.superbiz.agent.domain.entity;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import com.superbiz.agent.domain.enums.FaultCategory;
+
+import java.time.LocalDateTime;
+
+/**
+ * API 文档元数据实体
+ * 对应表: api_document
+ */
+@Entity
+@Table(name = "api_document", indexes = {
+    @Index(name = "idx_doc_id", columnList = "doc_id"),
+    @Index(name = "idx_fault_source", columnList = "fault_source"),
+    @Index(name = "idx_status", columnList = "status"),
+    @Index(name = "idx_created_at", columnList = "created_at")
+}, uniqueConstraints = {
+    @UniqueConstraint(name = "uk_file_hash", columnNames = "file_hash")
+})
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class ApiDocument {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "doc_id", unique = true, nullable = false, length = 64)
+    private String docId;
+
+    // 文档分类
+    @Enumerated(EnumType.STRING)
+    @Column(name = "fault_category", length = 32, columnDefinition = "VARCHAR(32)")
+    private FaultCategory faultCategory = FaultCategory.EXTERNAL_API;
+
+    @Column(name = "fault_source", length = 128)
+    private String faultSource;
+
+    @Column(name = "api_name", length = 128)
+    private String apiName;
+
+    @Column(name = "version", length = 32)
+    private String version = "v1.0";
+
+    // 文件信息
+    @Column(name = "file_name", nullable = false, length = 256)
+    private String fileName;
+
+    @Column(name = "file_path", length = 512)
+    private String filePath;
+
+    @Column(name = "file_hash", length = 64)
+    private String fileHash;
+
+    @Column(name = "file_size")
+    private Long fileSize;
+
+    // 索引状态
+    @Column(name = "status", length = 16)
+    private String status = "PENDING";
+
+    @Column(name = "chunk_count")
+    private Integer chunkCount = 0;
+
+    @Column(name = "error_message", columnDefinition = "TEXT")
+    private String errorMessage;
+
+    // 时间字段
+    @Column(name = "indexed_at")
+    private LocalDateTime indexedAt;
+
+    @Column(name = "created_at", nullable = false, updatable = false)
+    private LocalDateTime createdAt;
+
+    @Column(name = "updated_at")
+    private LocalDateTime updatedAt;
+
+    @PrePersist
+    protected void onCreate() {
+        createdAt = LocalDateTime.now();
+        updatedAt = LocalDateTime.now();
+    }
+
+    @PreUpdate
+    protected void onUpdate() {
+        updatedAt = LocalDateTime.now();
+    }
+}

src/main/java/com/superbiz/agent/domain/entity/CaseLibrary.java

@@ -0,0 +1,95 @@
+package com.superbiz.agent.domain.entity;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import com.superbiz.agent.domain.enums.FaultCategory;
+import com.superbiz.agent.domain.enums.SourceType;
+
+import java.time.LocalDateTime;
+
+/**
+ * 案例库实体
+ * 对应表: case_library
+ */
+@Entity
+@Table(name = "case_library", indexes = {
+    @Index(name = "idx_fault_category", columnList = "fault_category"),
+    @Index(name = "idx_error_code", columnList = "error_code"),
+    @Index(name = "idx_fault_source", columnList = "fault_source"),
+    @Index(name = "idx_diagnosis_id", columnList = "diagnosis_id"),
+    @Index(name = "idx_reference_count", columnList = "reference_count"),
+    @Index(name = "idx_created_at", columnList = "created_at")
+})
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class CaseLibrary {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "case_id", unique = true, nullable = false, length = 64)
+    private String caseId;
+
+    // 来源关联
+    @Column(name = "diagnosis_id", length = 64)
+    private String diagnosisId;
+
+    @Enumerated(EnumType.STRING)
+    @Column(name = "source_type", length = 16, columnDefinition = "VARCHAR(16)")
+    private SourceType sourceType = SourceType.AUTO;
+
+    // 案例分类
+    @Enumerated(EnumType.STRING)
+    @Column(name = "fault_category", length = 32, columnDefinition = "VARCHAR(32)")
+    private FaultCategory faultCategory;
+
+    @Column(name = "fault_source", length = 128)
+    private String faultSource;
+
+    @Column(name = "fault_target", length = 256)
+    private String faultTarget;
+
+    @Column(name = "error_code", length = 64)
+    private String errorCode;
+
+    // 案例内容
+    @Column(name = "title", nullable = false, length = 256)
+    private String title;
+
+    @Column(name = "root_cause", nullable = false, columnDefinition = "TEXT")
+    private String rootCause;
+
+    @Column(name = "solution", nullable = false, columnDefinition = "TEXT")
+    private String solution;
+
+    // 简单统计
+    @Column(name = "reference_count")
+    private Integer referenceCount = 0;
+
+    // 元数据
+    @Column(name = "created_by", length = 64)
+    private String createdBy;
+
+    @Column(name = "created_at", nullable = false, updatable = false)
+    private LocalDateTime createdAt;
+
+    @Column(name = "updated_at")
+    private LocalDateTime updatedAt;
+
+    @PrePersist
+    protected void onCreate() {
+        createdAt = LocalDateTime.now();
+        updatedAt = LocalDateTime.now();
+    }
+
+    @PreUpdate
+    protected void onUpdate() {
+        updatedAt = LocalDateTime.now();
+    }
+}

src/main/java/com/superbiz/agent/domain/entity/DiagnosisRecord.java

@@ -0,0 +1,128 @@
+package com.superbiz.agent.domain.entity;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import com.superbiz.agent.domain.enums.DiagnosisStatus;
+import com.superbiz.agent.domain.enums.FaultCategory;
+import org.hibernate.annotations.JdbcTypeCode;
+import org.hibernate.type.SqlTypes;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 诊断记录实体
+ * 对应表: diagnosis_record
+ */
+@Entity
+@Table(name = "diagnosis_record", indexes = {
+    @Index(name = "idx_business_id", columnList = "business_id"),
+    @Index(name = "idx_trace_id", columnList = "trace_id"),
+    @Index(name = "idx_session_id", columnList = "session_id"),
+    @Index(name = "idx_fault_category", columnList = "fault_category"),
+    @Index(name = "idx_error_code", columnList = "error_code"),
+    @Index(name = "idx_created_at", columnList = "created_at"),
+    @Index(name = "idx_status", columnList = "status")
+})
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class DiagnosisRecord {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "diagnosis_id", unique = true, nullable = false, length = 64)
+    private String diagnosisId;
+
+    // 关联信息
+    @Column(name = "session_id", length = 64)
+    private String sessionId;
+
+    @Column(name = "business_id", length = 128)
+    private String businessId;
+
+    @Column(name = "trace_id", length = 64)
+    private String traceId;
+
+    // 故障分类
+    @Enumerated(EnumType.STRING)
+    @Column(name = "fault_category", length = 32, columnDefinition = "VARCHAR(32)")
+    private FaultCategory faultCategory;
+
+    @Column(name = "fault_source", length = 128)
+    private String faultSource;
+
+    @Column(name = "fault_target", length = 256)
+    private String faultTarget;
+
+    // 错误信息
+    @Column(name = "error_code", length = 64)
+    private String errorCode;
+
+    @Column(name = "error_message", columnDefinition = "TEXT")
+    private String errorMessage;
+
+    @Column(name = "stack_trace", columnDefinition = "TEXT")
+    private String stackTrace;
+
+    // 诊断结果
+    @Column(name = "problem_type", length = 32)
+    private String problemType;
+
+    @Column(name = "root_cause", columnDefinition = "TEXT")
+    private String rootCause;
+
+    @Column(name = "solution", columnDefinition = "TEXT")
+    private String solution;
+
+    @Column(name = "report_markdown", columnDefinition = "TEXT")
+    private String reportMarkdown;
+
+    // 评估指标
+    @Enumerated(EnumType.STRING)
+    @Column(name = "status", length = 16, columnDefinition = "VARCHAR(16)")
+    private DiagnosisStatus status = DiagnosisStatus.PENDING;
+
+    @Column(name = "confidence")
+    private Integer confidence;
+
+    @Column(name = "duration")
+    private Integer duration;
+
+    // 用户反馈
+    @Column(name = "feedback", length = 16)
+    private String feedback;
+
+    // 调试字段 - JSON 类型
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(name = "tool_calls", columnDefinition = "JSON")
+    private List<Map<String, Object>> toolCalls;
+
+    // 元数据
+    @Column(name = "created_by", length = 64)
+    private String createdBy;
+
+    @Column(name = "created_at", nullable = false, updatable = false)
+    private LocalDateTime createdAt;
+
+    @Column(name = "updated_at")
+    private LocalDateTime updatedAt;
+
+    @PrePersist
+    protected void onCreate() {
+        createdAt = LocalDateTime.now();
+        updatedAt = LocalDateTime.now();
+    }
+
+    @PreUpdate
+    protected void onUpdate() {
+        updatedAt = LocalDateTime.now();
+    }
+}

src/main/java/com/superbiz/agent/domain/model/SessionContext.java

@@ -0,0 +1,88 @@
+package com.superbiz.agent.domain.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.io.Serializable;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 会话上下文数据类
+ * 存储在 Redis 中的会话数据
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class SessionContext implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 会话ID
+     */
+    private String sessionId;
+
+    /**
+     * 用户ID
+     */
+    private String userId;
+
+    /**
+     * 业务ID（订单号/请求ID等）
+     */
+    private String businessId;
+
+    /**
+     * 链路追踪ID
+     */
+    private String traceId;
+
+    /**
+     * 会话状态（ACTIVE/COMPLETED/EXPIRED）
+     */
+    private String status;
+
+    /**
+     * 工具调用历史
+     */
+    @Builder.Default
+    private List<ToolCall> toolCalls = new ArrayList<>();
+
+    /**
+     * 会话创建时间
+     */
+    private LocalDateTime createdAt;
+
+    /**
+     * 最后活跃时间
+     */
+    private LocalDateTime lastActiveAt;
+
+    /**
+     * 会话过期时间（秒）
+     */
+    private Long ttl;
+
+    /**
+     * 添加工具调用记录
+     */
+    public void addToolCall(ToolCall toolCall) {
+        if (this.toolCalls == null) {
+            this.toolCalls = new ArrayList<>();
+        }
+        this.toolCalls.add(toolCall);
+        this.lastActiveAt = LocalDateTime.now();
+    }
+
+    /**
+     * 更新最后活跃时间
+     */
+    public void updateLastActiveTime() {
+        this.lastActiveAt = LocalDateTime.now();
+    }
+}

src/main/java/com/superbiz/agent/domain/model/ToolCall.java

@@ -0,0 +1,57 @@
+package com.superbiz.agent.domain.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.io.Serializable;
+import java.time.LocalDateTime;
+import java.util.Map;
+
+/**
+ * 工具调用记录数据类
+ */
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class ToolCall implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 工具名称
+     */
+    private String toolName;
+
+    /**
+     * 工具参数
+     */
+    private Map<String, Object> arguments;
+
+    /**
+     * 工具返回结果
+     */
+    private String result;
+
+    /**
+     * 执行状态（SUCCESS/FAILED/TIMEOUT）
+     */
+    private String status;
+
+    /**
+     * 错误信息（如果失败）
+     */
+    private String errorMessage;
+
+    /**
+     * 执行耗时（毫秒）
+     */
+    private Long duration;
+
+    /**
+     * 调用时间
+     */
+    private LocalDateTime calledAt;
+}

src/main/java/com/superbiz/agent/dto/AIOpsRequest.java

@@ -0,0 +1,15 @@
+package com.superbiz.agent.dto;
+
+import lombok.Data;
+
+/**
+ * AIOps 请求 DTO
+ */
+@Data
+public class AIOpsRequest {
+    
+    /**
+     * 用户请求描述
+     */
+    private String userRequest;
+}

src/main/java/com/superbiz/agent/dto/DocumentChunk.java

@@ -0,0 +1,59 @@
+package com.superbiz.agent.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 文档分片
+ */
+@Setter
+@Getter
+public class DocumentChunk {
+
+    // Getters and Setters
+    /**
+     * 分片内容
+     */
+    private String content;
+    
+    /**
+     * 分片在原文档中的起始位置
+     */
+    private int startIndex;
+    
+    /**
+     * 分片在原文档中的结束位置
+     */
+    private int endIndex;
+    
+    /**
+     * 分片序号（从0开始）
+     */
+    private int chunkIndex;
+    
+    /**
+     * 分片标题或上下文信息
+     */
+    private String title;
+
+    public DocumentChunk() {
+    }
+
+    public DocumentChunk(String content, int startIndex, int endIndex, int chunkIndex) {
+        this.content = content;
+        this.startIndex = startIndex;
+        this.endIndex = endIndex;
+        this.chunkIndex = chunkIndex;
+    }
+
+    @Override
+    public String toString() {
+        return "DocumentChunk{" +
+                "chunkIndex=" + chunkIndex +
+                ", title='" + title + '\'' +
+                ", contentLength=" + (content != null ? content.length() : 0) +
+                ", startIndex=" + startIndex +
+                ", endIndex=" + endIndex +
+                '}';
+    }
+}

src/main/java/com/superbiz/agent/dto/FileUploadRes.java

@@ -0,0 +1,23 @@
+package com.superbiz.agent.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Setter
+@Getter
+public class FileUploadRes {
+
+    private String fileName;
+    private String filePath;
+    private Long fileSize;
+
+    public FileUploadRes() {
+    }
+
+    public FileUploadRes(String fileName, String filePath, Long fileSize) {
+        this.fileName = fileName;
+        this.filePath = filePath;
+        this.fileSize = fileSize;
+    }
+
+}

src/main/java/com/superbiz/agent/repository/ApiDocumentRepository.java

@@ -0,0 +1,63 @@
+package com.superbiz.agent.repository;
+
+import com.superbiz.agent.domain.enums.FaultCategory;
+import com.superbiz.agent.domain.entity.ApiDocument;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * API 文档 Repository
+ */
+@Repository
+public interface ApiDocumentRepository extends JpaRepository<ApiDocument, Long> {
+
+    /**
+     * 根据文档ID查询
+     */
+    Optional<ApiDocument> findByDocId(String docId);
+
+    /**
+     * 根据文件hash查询（去重）
+     */
+    Optional<ApiDocument> findByFileHash(String fileHash);
+
+    /**
+     * 根据故障源查询
+     */
+    List<ApiDocument> findByFaultSource(String faultSource);
+
+    /**
+     * 根据故障类别和故障源查询
+     */
+    List<ApiDocument> findByFaultCategoryAndFaultSource(FaultCategory category, String faultSource);
+
+    /**
+     * 根据状态查询
+     */
+    List<ApiDocument> findByStatus(String status);
+
+    /**
+     * 根据状态查询（分页）
+     */
+    Page<ApiDocument> findByStatus(String status, Pageable pageable);
+
+    /**
+     * 查询已索引的文档
+     */
+    List<ApiDocument> findByStatusAndChunkCountGreaterThan(String status, Integer chunkCount);
+
+    /**
+     * 模糊搜索文件名
+     */
+    Page<ApiDocument> findByFileNameContaining(String keyword, Pageable pageable);
+
+    /**
+     * 根据故障源模糊搜索（分页）
+     */
+    Page<ApiDocument> findByFaultSourceContaining(String keyword, Pageable pageable);
+}

src/main/java/com/superbiz/agent/repository/CaseLibraryRepository.java

@@ -0,0 +1,70 @@
+package com.superbiz.agent.repository;
+
+import com.superbiz.agent.domain.enums.FaultCategory;
+import com.superbiz.agent.domain.enums.SourceType;
+import com.superbiz.agent.domain.entity.CaseLibrary;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * 案例库 Repository
+ */
+@Repository
+public interface CaseLibraryRepository extends JpaRepository<CaseLibrary, Long> {
+
+    /**
+     * 根据案例ID查询
+     */
+    Optional<CaseLibrary> findByCaseId(String caseId);
+
+    /**
+     * 根据诊断ID查询
+     */
+    Optional<CaseLibrary> findByDiagnosisId(String diagnosisId);
+
+    /**
+     * 根据故障类别查询
+     */
+    List<CaseLibrary> findByFaultCategory(FaultCategory category);
+
+    /**
+     * 根据错误码查询
+     */
+    List<CaseLibrary> findByErrorCode(String errorCode);
+
+    /**
+     * 根据故障类别和错误码查询
+     */
+    List<CaseLibrary> findByFaultCategoryAndErrorCode(FaultCategory category, String errorCode);
+
+    /**
+     * 根据故障类别、故障源和错误码查询（精确匹配）
+     */
+    List<CaseLibrary> findByFaultCategoryAndFaultSourceAndErrorCode(
+        FaultCategory category, String faultSource, String errorCode);
+
+    /**
+     * 根据来源类型查询（分页）
+     */
+    Page<CaseLibrary> findBySourceType(SourceType sourceType, Pageable pageable);
+
+    /**
+     * 查询热门案例（按引用次数排序）
+     */
+    List<CaseLibrary> findTop10ByOrderByReferenceCountDesc();
+
+    /**
+     * 根据故障类别查询热门案例
+     */
+    List<CaseLibrary> findTop5ByFaultCategoryOrderByReferenceCountDesc(FaultCategory category);
+
+    /**
+     * 模糊搜索标题
+     */
+    Page<CaseLibrary> findByTitleContaining(String keyword, Pageable pageable);
+}

src/main/java/com/superbiz/agent/repository/DiagnosisRecordRepository.java

@@ -0,0 +1,73 @@
+package com.superbiz.agent.repository;
+
+import com.superbiz.agent.domain.enums.DiagnosisStatus;
+import com.superbiz.agent.domain.enums.FaultCategory;
+import com.superbiz.agent.domain.entity.DiagnosisRecord;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * 诊断记录 Repository
+ */
+@Repository
+public interface DiagnosisRecordRepository extends JpaRepository<DiagnosisRecord, Long> {
+
+    /**
+     * 根据诊断ID查询
+     */
+    Optional<DiagnosisRecord> findByDiagnosisId(String diagnosisId);
+
+    /**
+     * 根据业务ID查询
+     */
+    Optional<DiagnosisRecord> findByBusinessId(String businessId);
+
+    /**
+     * 根据链路追踪ID查询
+     */
+    Optional<DiagnosisRecord> findByTraceId(String traceId);
+
+    /**
+     * 根据会话ID查询所有记录
+     */
+    List<DiagnosisRecord> findBySessionId(String sessionId);
+
+    /**
+     * 根据故障类别和错误码查询
+     */
+    List<DiagnosisRecord> findByFaultCategoryAndErrorCode(FaultCategory category, String errorCode);
+
+    /**
+     * 根据故障类别、故障源和错误码查询
+     */
+    List<DiagnosisRecord> findByFaultCategoryAndFaultSourceAndErrorCode(
+        FaultCategory category, String faultSource, String errorCode);
+
+    /**
+     * 根据状态查询
+     */
+    List<DiagnosisRecord> findByStatus(DiagnosisStatus status);
+
+    /**
+     * 根据时间范围查询（分页）
+     */
+    Page<DiagnosisRecord> findByCreatedAtBetween(
+        LocalDateTime start, LocalDateTime end, Pageable pageable);
+
+    /**
+     * 根据故障类别和时间范围查询（分页）
+     */
+    Page<DiagnosisRecord> findByFaultCategoryAndCreatedAtBetween(
+        FaultCategory category, LocalDateTime start, LocalDateTime end, Pageable pageable);
+
+    /**
+     * 查询有用反馈的高置信度记录（用于生成案例）
+     */
+    List<DiagnosisRecord> findByFeedbackAndConfidenceGreaterThanEqual(String feedback, Integer confidence);
+}

src/main/java/com/superbiz/agent/service/AiOpsService.java

@@ -0,0 +1,289 @@
+package com.superbiz.agent.service;
+
+import org.springframework.ai.chat.model.ChatModel;
+import com.alibaba.cloud.ai.graph.OverAllState;
+import com.alibaba.cloud.ai.graph.agent.ReactAgent;
+import com.alibaba.cloud.ai.graph.agent.flow.agent.SupervisorAgent;
+import com.alibaba.cloud.ai.graph.exception.GraphRunnerException;
+import com.superbiz.agent.agent.tool.DateTimeTools;
+import com.superbiz.agent.agent.tool.InternalDocsTools;
+import com.superbiz.agent.agent.tool.QueryLogsTools;
+import com.superbiz.agent.agent.tool.QueryMetricsTools;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.ai.chat.messages.AssistantMessage;
+import org.springframework.ai.tool.ToolCallback;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * AI Ops 智能运维服务
+ * 负责多 Agent 协作的告警分析流程
+ */
+@Service
+public class AiOpsService {
+
+    private static final Logger logger = LoggerFactory.getLogger(AiOpsService.class);
+
+    @Autowired
+    private DateTimeTools dateTimeTools;
+
+    @Autowired
+    private InternalDocsTools internalDocsTools;
+
+    @Autowired
+    private QueryMetricsTools queryMetricsTools;
+
+    @Autowired(required = false)  // Mock 模式下才注册
+    private QueryLogsTools queryLogsTools;
+
+    /**
+     * 执行 AI Ops 告警分析流程
+     *
+     * @param chatModel      大模型实例
+     * @param toolCallbacks  工具回调数组
+     * @return 分析结果状态
+     * @throws GraphRunnerException 如果 Agent 执行失败
+     */
+    public Optional<OverAllState> executeAiOpsAnalysis(ChatModel chatModel, ToolCallback[] toolCallbacks) throws GraphRunnerException {
+        logger.info("开始执行 AI Ops 多 Agent 协作流程");
+
+        // 构建 Planner 和 Executor Agent
+        ReactAgent plannerAgent = buildPlannerAgent(chatModel, toolCallbacks);
+        ReactAgent executorAgent = buildExecutorAgent(chatModel, toolCallbacks);
+
+        // 构建 Supervisor Agent
+        SupervisorAgent supervisorAgent = SupervisorAgent.builder()
+                .name("ai_ops_supervisor")
+                .description("负责调度 Planner 与 Executor 的多 Agent 控制器")
+                .model(chatModel)
+                .systemPrompt(buildSupervisorSystemPrompt())
+                .subAgents(List.of(plannerAgent, executorAgent))
+                .build();
+
+        String taskPrompt = "你是企业级 SRE，接到了自动化告警排查任务。请结合工具调用，执行**规划→执行→再规划**的闭环，并最终按照固定模板输出《告警分析报告》。禁止编造虚假数据，如连续多次查询失败需诚实反馈无法完成的原因。";
+
+        logger.info("调用 Supervisor Agent 开始编排...");
+
+        Optional<OverAllState> stateOptional = supervisorAgent.invoke(taskPrompt);
+
+        // 添加调试代码
+        if (stateOptional.isPresent()) {
+            OverAllState state = stateOptional.get();
+            logger.debug("Final State Keys: {}", state.data().keySet());  // 打印所有 key
+            logger.debug("Planner Plan: {}", state.value("planner_plan"));
+            logger.debug("Executor Feedback: {}", state.value("executor_feedback"));
+        }
+
+        return stateOptional;
+    }
+
+    /**
+     * 从执行结果中提取最终报告文本
+     *
+     * @param state 执行状态
+     * @return 报告文本（如果存在）
+     */
+    public Optional<String> extractFinalReport(OverAllState state) {
+        logger.info("开始提取最终报告...");
+
+        // 提取 Planner 最终输出（包含完整的告警分析报告）
+        Optional<AssistantMessage> plannerFinalOutput = state.value("planner_plan")
+                .filter(AssistantMessage.class::isInstance)
+                .map(AssistantMessage.class::cast);
+
+        if (plannerFinalOutput.isPresent()) {
+            String reportText = plannerFinalOutput.get().getText();
+            logger.info("成功提取到 Planner 最终报告，长度: {}", reportText.length());
+            return Optional.of(reportText);
+        } else {
+            logger.warn("未能提取到 Planner 最终报告");
+            return Optional.empty();
+        }
+    }
+
+    /**
+     * 构建 Planner Agent
+     */
+    private ReactAgent buildPlannerAgent(ChatModel chatModel, ToolCallback[] toolCallbacks) {
+        return ReactAgent.builder()
+                .name("planner_agent")
+                .description("负责拆解告警、规划与再规划步骤")
+                .model(chatModel)
+                .systemPrompt(buildPlannerPrompt())
+                .methodTools(buildMethodToolsArray())
+                .tools(toolCallbacks)
+                .outputKey("planner_plan")
+                .build();
+    }
+
+    /**
+     * 构建 Executor Agent
+     */
+    private ReactAgent buildExecutorAgent(ChatModel chatModel, ToolCallback[] toolCallbacks) {
+        return ReactAgent.builder()
+                .name("executor_agent")
+                .description("负责执行 Planner 的首个步骤并及时反馈")
+                .model(chatModel)
+                .systemPrompt(buildExecutorPrompt())
+                .methodTools(buildMethodToolsArray())
+                .tools(toolCallbacks)
+                .outputKey("executor_feedback")
+                .build();
+    }
+
+    /**
+     * 动态构建方法工具数组
+     * 根据 cls.mock-enabled 决定是否包含 QueryLogsTools
+     */
+    private Object[] buildMethodToolsArray() {
+        if (queryLogsTools != null) {
+            // Mock 模式：包含 QueryLogsTools
+            return new Object[]{dateTimeTools, internalDocsTools, queryMetricsTools, queryLogsTools};
+        } else {
+            // 真实模式：不包含 QueryLogsTools（由 MCP 提供日志查询功能）
+            return new Object[]{dateTimeTools, internalDocsTools, queryMetricsTools};
+        }
+    }
+
+    /**
+     * 构建 Planner Agent 系统提示词
+     */
+    private String buildPlannerPrompt() {
+        return """
+                你是 Planner Agent，同时承担 Replanner 角色，负责：
+                1. 读取当前输入任务 {input} 以及 Executor 的最近反馈 {executor_feedback}。
+                2. 分析 Prometheus 告警、日志、内部文档等信息，制定可执行的下一步步骤。
+                3. 在执行阶段，输出 JSON，包含 decision (PLAN|EXECUTE|FINISH)、step 描述、预期要调用的工具、以及必要的上下文。
+                4. 调用任何腾讯云日志/主题相关工具时，region 参数必须使用连字符格式（如 ap-guangzhou），若不确定请省略以使用默认值。
+                5. 严格禁止编造数据，只能引用工具返回的真实内容；如果连续 3 次调用同一工具仍失败或返回空结果，需停止该方向并在最终报告的结论部分说明"无法完成"的原因。
+                
+                ## 最终报告输出要求（CRITICAL）
+                
+                当 decision=FINISH 时，你必须：
+                1. **不要输出 JSON 格式**
+                2. **直接输出完整的 Markdown 格式报告文本**
+                3. **报告必须严格遵循以下模板**：
+                
+                ```
+                # 告警分析报告
+                
+                ---
+                
+                ## 📋 活跃告警清单
+                
+                | 告警名称 | 级别 | 目标服务 | 首次触发时间 | 最新触发时间 | 状态 |
+                |---------|------|----------|-------------|-------------|------|
+                | [告警1名称] | [级别] | [服务名] | [时间] | [时间] | 活跃 |
+                | [告警2名称] | [级别] | [服务名] | [时间] | [时间] | 活跃 |
+                
+                ---
+                
+                ## 🔍 告警根因分析1 - [告警名称]
+                
+                ### 告警详情
+                - **告警级别**: [级别]
+                - **受影响服务**: [服务名]
+                - **持续时间**: [X分钟]
+                
+                ### 症状描述
+                [根据监控指标描述症状]
+                
+                ### 日志证据
+                [引用查询到的关键日志]
+                
+                ### 根因结论
+                [基于证据得出的根本原因]
+                
+                ---
+                
+                ## 🛠️ 处理方案执行1 - [告警名称]
+                
+                ### 已执行的排查步骤
+                1. [步骤1]
+                2. [步骤2]
+                
+                ### 处理建议
+                [给出具体的处理建议]
+                
+                ### 预期效果
+                [说明预期的效果]
+                
+                ---
+                
+                ## 🔍 告警根因分析2 - [告警名称]
+                [如果有第2个告警，重复上述格式]
+                
+                ---
+                
+                ## 📊 结论
+                
+                ### 整体评估
+                [总结所有告警的整体情况]
+                
+                ### 关键发现
+                - [发现1]
+                - [发现2]
+                
+                ### 后续建议
+                1. [建议1]
+                2. [建议2]
+                
+                ### 风险评估
+                [评估当前风险等级和影响范围]
+                ```
+                
+                **重要提醒**：
+                - 最终输出必须是纯 Markdown 文本，不要包含 JSON 结构
+                - 不要使用 "finalReport": "..." 这样的格式
+                - 直接从 "# 告警分析报告" 开始输出
+                - 所有内容必须基于工具查询的真实数据，严禁编造
+                - 如果某个步骤失败，在结论中如实说明，不要跳过
+                
+                """;
+    }
+
+    /**
+     * 构建 Executor Agent 系统提示词
+     */
+    private String buildExecutorPrompt() {
+        return """
+                你是 Executor Agent，负责读取 Planner 最新输出 {planner_plan}，只执行其中的第一步。
+                - 确认步骤所需的工具与参数，尤其是 region 参数要使用连字符格式（ap-guangzhou）；若 Planner 未给出则使用默认区域。
+                - 调用相应的工具并收集结果，如工具返回错误或空数据，需要将失败原因、请求参数一并记录，并停止进一步调用该工具（同一工具失败达到 3 次时应直接返回 FAILED）。
+                - 将日志、指标、文档等证据整理成结构化摘要，标注对应的告警名称或资源，方便 Planner 填充"告警根因分析 / 处理方案执行"章节。
+                - 以 JSON 形式返回执行状态、证据以及给 Planner 的建议，写入 executor_feedback，严禁编造未实际查询到的内容。
+
+
+                输出示例：
+                {
+                  "status": "SUCCESS",
+                  "summary": "近1小时未见 error 日志，仅有 info",
+                  "evidence": "...",
+                  "nextHint": "建议转向高占用进程"
+                }
+                """;
+    }
+
+    /**
+     * 构建 Supervisor Agent 系统提示词
+     */
+    private String buildSupervisorSystemPrompt() {
+        return """
+                你是 AI Ops Supervisor，负责调度 planner_agent 与 executor_agent：
+                1. 当需要拆解任务或重新制定策略时，调用 planner_agent。
+                2. 当 planner_agent 输出 decision=EXECUTE 时，调用 executor_agent 执行第一步。
+                3. 根据 executor_agent 的反馈，评估是否需要再次调用 planner_agent，直到 decision=FINISH。
+                4. FINISH 后，确保向最终用户输出完整的《告警分析报告》，格式必须严格为：
+                   告警分析报告\n---\n# 告警处理详情\n## 活跃告警清单\n## 告警根因分析N\n## 处理方案执行N\n## 结论。
+                5. 若步骤涉及腾讯云日志/主题工具，请确保使用连字符区域 ID（ap-guangzhou 等），或省略 region 以采用默认值。
+                6. 如果发现 Planner/Executor 在同一方向连续 3 次调用工具仍失败或没有数据，必须终止流程，直接输出"任务无法完成"的报告，明确告知失败原因，严禁凭空编造结果。
+
+                只允许在 planner_agent、executor_agent 与 FINISH 之间做出选择。
+
+                """;
+    }
+}

src/main/java/com/superbiz/agent/service/ChatService.java

@@ -0,0 +1,190 @@
+package com.superbiz.agent.service;
+
+import com.alibaba.cloud.ai.graph.agent.ReactAgent;
+import com.alibaba.cloud.ai.graph.exception.GraphRunnerException;
+import com.superbiz.agent.agent.tool.DateTimeTools;
+import com.superbiz.agent.agent.tool.InternalDocsTools;
+import com.superbiz.agent.agent.tool.QueryLogsTools;
+import com.superbiz.agent.agent.tool.QueryMetricsTools;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.ai.chat.model.ChatModel;
+import org.springframework.ai.tool.ToolCallback;
+import org.springframework.ai.tool.ToolCallbackProvider;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 聊天服务
+ * 封装 ReactAgent 对话的公共逻辑，包括模型创建、系统提示词构建、Agent 配置等
+ */
+@Service
+public class ChatService {
+
+    private static final Logger logger = LoggerFactory.getLogger(ChatService.class);
+
+    @Autowired
+    private InternalDocsTools internalDocsTools;
+
+    @Autowired
+    private DateTimeTools dateTimeTools;
+
+    @Autowired
+    private QueryMetricsTools queryMetricsTools;
+
+    @Autowired(required = false)  // Mock 模式下才注册，所以设置为 optional,真实环境通过mcp配置注入
+    private QueryLogsTools queryLogsTools;
+
+    @Autowired(required = false)
+    private ToolCallbackProvider tools;
+
+    @Autowired
+    private ChatModel chatModel;
+
+    /**
+     * 获取注入的 ChatModel
+     */
+    public ChatModel getChatModel() {
+        return chatModel;
+    }
+
+    /**
+     * 构建系统提示词（包含历史消息）
+     * @param history 历史消息列表
+     * @return 完整的系统提示词
+     */
+    public String buildSystemPrompt(List<Map<String, String>> history) {
+        StringBuilder systemPromptBuilder = new StringBuilder();
+
+        // 基础系统提示
+        systemPromptBuilder.append("你是一个专业的智能助手，可以获取当前时间、查询天气信息、搜索内部文档知识库，以及查询 Prometheus 告警信息。\n");
+        systemPromptBuilder.append("当用户询问时间相关问题时，**必须每次都调用 getCurrentDateTime 工具**，因为时间会不断变化。即使历史消息中有时间信息，也不要直接复用，必须重新查询最新时间。\n");
+        systemPromptBuilder.append("当用户需要查询公司内部文档、流程、最佳实践或技术指南时，使用 queryInternalDocs 工具。\n");
+        systemPromptBuilder.append("当用户需要查询 Prometheus 告警、监控指标或系统告警状态时，使用 queryPrometheusAlerts 工具。\n");
+        systemPromptBuilder.append("当用户需要查询腾讯云日志时，请调用腾讯云mcp服务查询,默认查询地域ap-guangzhou,查询时间范围为近一个月。\n\n");
+
+        // 添加历史消息（过滤时间查询相关内容）
+        if (!history.isEmpty()) {
+            systemPromptBuilder.append("--- 对话历史 ---\n");
+            for (Map<String, String> msg : history) {
+                String role = msg.get("role");
+                String content = msg.get("content");
+
+                // 🔧 过滤时间查询相关的历史消息，避免 LLM 复用旧的时间信息
+                if ("user".equals(role) && isTimeQuery(content)) {
+                    continue;  // 跳过时间查询问题
+                }
+                if ("assistant".equals(role) && containsTimeInfo(content)) {
+                    continue;  // 跳过包含时间信息的回答
+                }
+
+                if ("user".equals(role)) {
+                    systemPromptBuilder.append("用户: ").append(content).append("\n");
+                } else if ("assistant".equals(role)) {
+                    systemPromptBuilder.append("助手: ").append(content).append("\n");
+                }
+            }
+            systemPromptBuilder.append("--- 对话历史结束 ---\n\n");
+        }
+
+        systemPromptBuilder.append("请基于以上对话历史，回答用户的新问题。");
+
+        return systemPromptBuilder.toString();
+    }
+
+    /**
+     * 判断是否为时间查询问题
+     */
+    private boolean isTimeQuery(String content) {
+        if (content == null) {
+            return false;
+        }
+        // 匹配常见的时间查询模式
+        return content.matches(".*(现在|当前|此时).*(几点|时间).*") ||
+               content.matches(".*(几点|时间).*(了|呢|[？?]).*") ||
+               content.toLowerCase().matches(".*(what.*time|current.*time).*");
+    }
+
+    /**
+     * 判断是否包含时间信息
+     */
+    private boolean containsTimeInfo(String content) {
+        if (content == null) {
+            return false;
+        }
+        // 匹配日期时间格式：2026年5月31日、15:57、下午3点 等
+        return content.matches(".*(\\d{4}年\\d{1,2}月\\d{1,2}日|\\d{1,2}:\\d{2}|[上下午]+\\d{1,2}[点时]).*");
+    }
+
+    /**
+     * 动态构建方法工具数组
+     * 根据 cls.mock-enabled 决定是否包含 QueryLogsTools
+     */
+    public Object[] buildMethodToolsArray() {
+        if (queryLogsTools != null) {
+            // Mock 模式：包含 QueryLogsTools
+            return new Object[]{dateTimeTools, internalDocsTools, queryMetricsTools, queryLogsTools};
+        } else {
+            // 真实模式：不包含 QueryLogsTools（由 MCP 提供日志查询功能）
+            return new Object[]{dateTimeTools, internalDocsTools, queryMetricsTools};
+        }
+    }
+
+    /**
+     * 获取工具回调列表，mcp服务提供的工具
+     */
+    public ToolCallback[] getToolCallbacks() {
+        if (tools == null) {
+            return new ToolCallback[0];
+        }
+        return tools.getToolCallbacks();
+    }
+
+    /**
+     * 记录可用工具列表：mcp服务提供的工具
+     */
+    public void logAvailableTools() {
+        if (tools == null) {
+            logger.info("MCP 未启用，无远程工具");
+            return;
+        }
+        ToolCallback[] toolCallbacks = tools.getToolCallbacks();
+        logger.info("可用工具列表:");
+        for (ToolCallback toolCallback : toolCallbacks) {
+            logger.info(">>> {}", toolCallback.getToolDefinition().name());
+        }
+    }
+
+    /**
+     * 创建 ReactAgent
+     * @param chatModel 聊天模型
+     * @param systemPrompt 系统提示词
+     * @return 配置好的 ReactAgent
+     */
+    public ReactAgent createReactAgent(ChatModel chatModel, String systemPrompt) {
+        return ReactAgent.builder()
+                .name("intelligent_assistant")
+                .model(chatModel)
+                .systemPrompt(systemPrompt)
+                .methodTools(buildMethodToolsArray())
+                .tools(getToolCallbacks())
+                .build();
+    }
+
+    /**
+     * 执行 ReactAgent 对话（非流式）
+     * @param agent ReactAgent 实例
+     * @param question 用户问题
+     * @return AI 回复
+     */
+    public String executeChat(ReactAgent agent, String question) throws GraphRunnerException {
+        logger.info("执行 ReactAgent.call() - 自动处理工具调用");
+        var response = agent.call(question);
+        String answer = response.getText();
+        logger.info("ReactAgent 对话完成，答案长度: {}", answer.length());
+        return answer;
+    }
+}

src/main/java/com/superbiz/agent/service/DocumentChunkService.java

@@ -0,0 +1,405 @@
+package com.superbiz.agent.service;
+
+import com.superbiz.agent.config.DocumentChunkConfig;
+import com.superbiz.agent.dto.DocumentChunk;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * 文档分片服务
+ * 负责将长文档切分为多个有语义完整性的小片段
+ */
+@Service
+public class DocumentChunkService {
+
+    private static final Logger logger = LoggerFactory.getLogger(DocumentChunkService.class);
+
+    @Autowired
+    private DocumentChunkConfig chunkConfig;
+
+    /**
+     * 智能分片文档
+     * 优先按照标题、段落边界进行分割，保持语义完整性
+     *
+     * @param content 文档内容
+     * @param filePath 文件路径（用于日志）
+     * @return 文档分片列表
+     */
+    public List<DocumentChunk> chunkDocument(String content, String filePath) {
+        List<DocumentChunk> chunks = new ArrayList<>();
+
+        if (content == null || content.trim().isEmpty()) {
+            logger.warn("文档内容为空: {}", filePath);
+            return chunks;
+        }
+
+        // 1. 首先尝试按标题分割（Markdown格式）
+        List<Section> sections = splitByHeadings(content);
+
+        // 2. 对每个章节进行进一步分片
+        int globalChunkIndex = 0;
+        for (Section section : sections) {
+            List<DocumentChunk> sectionChunks = chunkSection(section, globalChunkIndex);
+            chunks.addAll(sectionChunks);
+            globalChunkIndex += sectionChunks.size();
+        }
+
+        logger.info("文档分片完成: {} -> {} 个分片", filePath, chunks.size());
+        return chunks;
+    }
+
+    /**
+     * 按照 Markdown 标题分割文档
+     */
+    private List<Section> splitByHeadings(String content) {
+        List<Section> sections = new ArrayList<>();
+
+        // 匹配 Markdown 标题：# 标题, ## 标题, ### 标题等
+        Pattern headingPattern = Pattern.compile("^(#{1,6})\\s+(.+)$", Pattern.MULTILINE);
+        Matcher matcher = headingPattern.matcher(content);
+
+        int lastEnd = 0;
+        String currentTitle = null;
+
+        while (matcher.find()) {
+            // 保存上一个章节
+            if (lastEnd < matcher.start()) {
+                String sectionContent = content.substring(lastEnd, matcher.start()).trim();
+                if (!sectionContent.isEmpty()) {
+                    sections.add(new Section(currentTitle, sectionContent, lastEnd));
+                }
+            }
+
+            // 更新当前标题
+            currentTitle = matcher.group(2).trim();
+            lastEnd = matcher.start();
+        }
+
+        // 添加最后一个章节
+        if (lastEnd < content.length()) {
+            String sectionContent = content.substring(lastEnd).trim();
+            if (!sectionContent.isEmpty()) {
+                sections.add(new Section(currentTitle, sectionContent, lastEnd));
+            }
+        }
+
+        // 如果没有找到任何标题，将整个文档作为一个章节
+        if (sections.isEmpty()) {
+            sections.add(new Section(null, content, 0));
+        }
+
+        return sections;
+    }
+
+    /**
+     * 对单个章节进行分片
+     * <p>
+     * 核心改造（Phase 1）：
+     * - Token 估算替代字符计数
+     * - 感知有序/无序列表结构，不在列表中间切断
+     * - 软边界（maxTokens）+ 硬上限（maxTokensHard）双重控制
+     * - 修复 currentStartIndex 漂移：用段落原始位置而非手工推算
+     */
+    private List<DocumentChunk> chunkSection(Section section, int startChunkIndex) {
+        List<DocumentChunk> chunks = new ArrayList<>();
+        String content = section.content;
+        String title = section.title;
+
+        // 短章节直接作为一个分片（用 token 估算替代字符数做短路判断）
+        if (content.length() <= chunkConfig.getMaxSize()
+            && estimateTokens(content) <= chunkConfig.getMaxTokens()) {
+            DocumentChunk chunk = new DocumentChunk(
+                content,
+                section.startIndex,
+                section.startIndex + content.length(),
+                startChunkIndex
+            );
+            chunk.setTitle(title);
+            chunks.add(chunk);
+            return chunks;
+        }
+
+        // 章节内容较长，需要进一步分片
+        List<String> paragraphs = splitByParagraphs(content);
+        if (paragraphs.isEmpty()) {
+            return chunks;
+        }
+
+        // 定位每个段落在 section.content 中的位置（修复 index 漂移）
+        List<ParagraphPos> paraPositions = locateParagraphPositions(paragraphs, content);
+
+        // 当前分片的段落范围
+        int chunkParaStart = 0;   // 当前分片第一个段落的索引（在 paragraphs 中）
+        StringBuilder buffer = new StringBuilder();
+        int tokenCount = 0;
+        int chunkIndex = startChunkIndex;
+
+        for (int i = 0; i < paragraphs.size(); i++) {
+            String paragraph = paragraphs.get(i);
+            int paraTokens = estimateTokens(paragraph);
+
+            // 判断是否需要切分
+            if (buffer.length() > 0 && tokenCount + paraTokens > chunkConfig.getMaxTokens()) {
+
+                // 检查是否处于不可中断的上下文中
+                if (isInUnbreakableContext(buffer.toString(), paragraph)) {
+                    // 硬上限保护：即使不可中断也不能无限膨胀
+                    if (tokenCount + paraTokens > chunkConfig.getMaxTokensHard()) {
+                        logger.debug("  触及硬上限 ({} tokens)，强制切分", tokenCount + paraTokens);
+                        chunkParaStart = saveChunkAndGetNextStart(
+                            chunks, section, paraPositions,
+                            chunkParaStart, i, title, chunkIndex);
+                        chunkIndex++;
+
+                        String prevChunkContent = chunks.get(chunks.size() - 1).getContent();
+                        String overlap = getOverlapText(prevChunkContent);
+                        buffer = new StringBuilder(overlap);
+                        tokenCount = estimateTokens(overlap);
+                    }
+                    // 否则：容忍超出（软边界）
+                } else {
+                    // 安全切点：段落边界
+                    chunkParaStart = saveChunkAndGetNextStart(
+                        chunks, section, paraPositions,
+                        chunkParaStart, i, title, chunkIndex);
+                    chunkIndex++;
+
+                    // 新分片以重叠文本开头
+                    String prevChunkContent = chunks.get(chunks.size() - 1).getContent();
+                    String overlap = getOverlapText(prevChunkContent);
+                    buffer = new StringBuilder(overlap);
+                    tokenCount = estimateTokens(overlap);
+                }
+            }
+
+            buffer.append(paragraph).append("\n\n");
+            tokenCount += paraTokens;
+        }
+
+        // 保存最后一个分片
+        if (buffer.length() > 0 && chunkParaStart < paragraphs.size()) {
+            String chunkContent = buffer.toString().trim();
+            int actualStart = paraPositions.get(chunkParaStart).start;
+            int actualEnd = paraPositions.get(paragraphs.size() - 1).end;
+            DocumentChunk chunk = new DocumentChunk(
+                chunkContent,
+                section.startIndex + actualStart,
+                section.startIndex + actualEnd,
+                chunkIndex
+            );
+            chunk.setTitle(title);
+            chunks.add(chunk);
+        }
+
+        return chunks;
+    }
+
+    /**
+     * 保存当前分块，返回下一个分块的起始段落索引
+     * <p>
+     * 从 section.content 中提取原始文本（而非手工拼装），修复 index 漂移问题
+     */
+    private int saveChunkAndGetNextStart(
+            List<DocumentChunk> chunks,
+            Section section,
+            List<ParagraphPos> paraPositions,
+            int fromPara,
+            int toPara,
+            String title,
+            int chunkIndex) {
+
+        int actualStart = paraPositions.get(fromPara).start;
+        int actualEnd = paraPositions.get(toPara - 1).end;
+        String originalText = section.content.substring(actualStart, actualEnd);
+
+        DocumentChunk chunk = new DocumentChunk(
+            originalText,
+            section.startIndex + actualStart,
+            section.startIndex + actualEnd,
+            chunkIndex
+        );
+        chunk.setTitle(title);
+        chunks.add(chunk);
+
+        return toPara; // 下一个分块的起始段落索引
+    }
+
+    /**
+     * 按段落分割文本
+     */
+    private List<String> splitByParagraphs(String content) {
+        List<String> paragraphs = new ArrayList<>();
+
+        // 按双换行符分割段落
+        String[] parts = content.split("\n\n+");
+        for (String part : parts) {
+            String trimmed = part.trim();
+            if (!trimmed.isEmpty()) {
+                paragraphs.add(trimmed);
+            }
+        }
+
+        return paragraphs;
+    }
+
+    /**
+     * 定位每个段落在原始文本中的字符偏移
+     */
+    private List<ParagraphPos> locateParagraphPositions(List<String> paragraphs, String sectionContent) {
+        List<ParagraphPos> positions = new ArrayList<>();
+        int searchFrom = 0;
+        for (String p : paragraphs) {
+            int idx = sectionContent.indexOf(p, searchFrom);
+            if (idx >= 0) {
+                positions.add(new ParagraphPos(idx, idx + p.length()));
+                searchFrom = idx + p.length();
+            } else {
+                // fallback: 段落在原文中找不到（不应该发生）
+                positions.add(new ParagraphPos(searchFrom, searchFrom + p.length()));
+                searchFrom += p.length();
+            }
+        }
+        return positions;
+    }
+
+    /**
+     * 启发式 token 估算（无需外部依赖）
+     * <p>
+     * 中文(BMP): ~1 字符/token
+     * 英文/数字/标点: ~4 字符/token
+     * 空白字符忽略
+     */
+    private int estimateTokens(String text) {
+        int nonCjkCount = 0;
+        int cjkCount = 0;
+        for (char c : text.toCharArray()) {
+            if (Character.isWhitespace(c)) {
+                continue;
+            }
+            Character.UnicodeBlock block = Character.UnicodeBlock.of(c);
+            if (block == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
+                || block == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
+                || block == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B
+                || block == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS) {
+                cjkCount++;
+            } else {
+                nonCjkCount++;
+            }
+        }
+        return cjkCount + (nonCjkCount + 3) / 4; // 非中文每 4 字符算 1 token，向上取整
+    }
+
+    /**
+     * 判断当前段落是否属于不可中断的结构
+     * <p>
+     * 不可中断结构包括：
+     * - 有序列表项（"1. ", "2. " 格式）
+     * - 无序列表项（"- " 或 "* " 格式）
+     * - 未闭合的代码块（``` 内）
+     */
+    private boolean isInUnbreakableContext(String buffer, String nextParagraph) {
+        // 有序列表：判断 buffer 末尾和下一段是否都是列表项
+        if (nextParagraph.matches("^\\d{1,2}\\.\\s.*")) {
+            String lastLine = getLastNonEmptyLine(buffer);
+            if (lastLine != null && lastLine.matches("^\\d{1,2}\\.\\s.*")) {
+                return true;
+            }
+        }
+        // 无序列表："- " 或 "* " 格式
+        if (nextParagraph.matches("^[-*]\\s.*")) {
+            String lastLine = getLastNonEmptyLine(buffer);
+            if (lastLine != null && lastLine.matches("^[-*]\\s.*")) {
+                return true;
+            }
+        }
+        // 代码块：``` 未闭合
+        if (buffer.contains("```")) {
+            int count = 0;
+            for (int i = 0; i <= buffer.length() - 3; i++) {
+                if (buffer.substring(i).startsWith("```")) {
+                    count++;
+                    i += 2;
+                }
+            }
+            if (count % 2 == 1) {
+                return true; // 奇数个 ``` → 在代码块内部
+            }
+        }
+        return false;
+    }
+
+    /**
+     * 获取 buffer 中最后一行非空白文本
+     */
+    private String getLastNonEmptyLine(String buffer) {
+        String[] lines = buffer.split("\n");
+        for (int i = lines.length - 1; i >= 0; i--) {
+            String line = lines[i].trim();
+            if (!line.isEmpty()) {
+                return line;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 获取重叠文本
+     * 从文本末尾提取指定长度的内容作为下一个分片的开头
+     */
+    private String getOverlapText(String text) {
+        int overlapSize = Math.min(chunkConfig.getOverlap(), text.length());
+        if (overlapSize <= 0) {
+            return "";
+        }
+
+        // 从末尾提取重叠内容
+        String overlap = text.substring(text.length() - overlapSize);
+
+        // 尝试在句子边界截断（查找最后一个句号、问号、感叹号）
+        int lastSentenceEnd = Math.max(
+            overlap.lastIndexOf('。'),
+            Math.max(overlap.lastIndexOf('？'), overlap.lastIndexOf('！'))
+        );
+
+        if (lastSentenceEnd > overlapSize / 2) {
+            return overlap.substring(lastSentenceEnd + 1).trim();
+        }
+
+        return overlap.trim();
+    }
+
+    /**
+     * 段落在原文中的位置
+     */
+    private static class ParagraphPos {
+        final int start;
+        final int end;
+
+        ParagraphPos(int start, int end) {
+            this.start = start;
+            this.end = end;
+        }
+    }
+
+    /**
+     * 章节数据类
+     */
+    private static class Section {
+        String title;
+        String content;
+        int startIndex;
+
+        Section(String title, String content, int startIndex) {
+            this.title = title;
+            this.content = content;
+            this.startIndex = startIndex;
+        }
+    }
+}

src/main/java/com/superbiz/agent/service/RagService.java

@@ -0,0 +1,190 @@
+package com.superbiz.agent.service;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.ai.chat.messages.AssistantMessage;
+import org.springframework.ai.chat.messages.Message;
+import org.springframework.ai.chat.messages.UserMessage;
+import org.springframework.ai.chat.model.ChatModel;
+import org.springframework.ai.chat.model.ChatResponse;
+import org.springframework.ai.chat.prompt.Prompt;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Flux;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * RAG (Retrieval-Augmented Generation) 服务
+ * 结合向量检索和大语言模型生成答案
+ */
+@Service
+public class RagService {
+
+    private static final Logger logger = LoggerFactory.getLogger(RagService.class);
+
+    @Autowired
+    private VectorSearchService vectorSearchService;
+
+    @Autowired
+    private ChatModel chatModel;
+
+    @Value("${rag.top-k:3}")
+    private int topK;
+
+    /**
+     * 流式处理用户问题（不带历史消息）
+     * 
+     * @param question 用户问题
+     * @param callback 流式回调接口
+     */
+    public void queryStream(String question, StreamCallback callback) {
+        queryStream(question, new ArrayList<>(), callback);
+    }
+
+    /**
+     * 流式处理用户问题（带历史消息）
+     * 
+     * @param question 用户问题
+     * @param history 历史消息列表，格式：[{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]
+     * @param callback 流式回调接口
+     */
+    public void queryStream(String question, List<Map<String, String>> history, StreamCallback callback) {
+        try {
+            logger.info("收到 RAG 流式查询: {}", question);
+
+            // 1. 从向量数据库检索相关文档
+            List<VectorSearchService.SearchResult> searchResults = 
+                vectorSearchService.searchSimilarDocuments(question, topK);
+
+            // 发送检索结果
+            callback.onSearchResults(searchResults);
+
+            if (searchResults.isEmpty()) {
+                logger.warn("未找到相关文档");
+                callback.onComplete("抱歉，我在知识库中没有找到相关信息来回答您的问题。", "");
+                return;
+            }
+
+            // 2. 构建上下文和提示词
+            String context = buildContext(searchResults);
+            String prompt = buildPrompt(question, context);
+
+            // 3. 流式调用大语言模型（传入历史消息）
+            generateAnswerStream(prompt, history, callback);
+
+        } catch (Exception e) {
+            logger.error("RAG 流式查询失败", e);
+            callback.onError(e);
+        }
+    }
+
+    /**
+     * 构建上下文
+     */
+    private String buildContext(List<VectorSearchService.SearchResult> searchResults) {
+        StringBuilder context = new StringBuilder();
+        
+        for (int i = 0; i < searchResults.size(); i++) {
+            VectorSearchService.SearchResult result = searchResults.get(i);
+            context.append("【参考资料 ").append(i + 1).append("】\n");
+            context.append(result.getContent()).append("\n\n");
+        }
+        
+        return context.toString();
+    }
+
+    /**
+     * 构建提示词
+     */
+    private String buildPrompt(String question, String context) {
+        return String.format(
+            "你是一个专业的AI助手。请根据以下参考资料回答用户的问题。\n\n" +
+            "参考资料：\n%s\n" +
+            "用户问题：%s\n\n" +
+            "请基于上述参考资料给出准确、详细的回答。如果参考资料中没有相关信息，请明确说明。",
+            context, question
+        );
+    }
+
+    /**
+     * 生成答案（流式）
+     * 
+     * @param prompt 当前问题的提示词
+     * @param history 历史消息列表
+     * @param callback 流式回调接口
+     */
+    private void generateAnswerStream(String prompt, List<Map<String, String>> history, StreamCallback callback) {
+        // 构建消息列表：历史消息 + 当前问题
+        List<Message> messages = new ArrayList<>();
+
+        // 添加历史消息
+        for (Map<String, String> historyMsg : history) {
+            String role = historyMsg.get("role");
+            String content = historyMsg.get("content");
+
+            if ("user".equals(role)) {
+                messages.add(new UserMessage(content));
+            } else if ("assistant".equals(role)) {
+                messages.add(new AssistantMessage(content));
+            }
+        }
+
+        // 添加当前用户问题
+        messages.add(new UserMessage(prompt));
+
+        logger.debug("发送给AI模型的消息数量: {}（包含 {} 条历史消息）",
+            messages.size(), history.size());
+
+        logger.info("开始调用AI模型流式接口...");
+
+        StringBuilder reasoningContent = new StringBuilder();
+        StringBuilder finalContent = new StringBuilder();
+
+        Flux<ChatResponse> flux = chatModel.stream(new Prompt(messages));
+
+        logger.info("开始接收AI模型流式响应...");
+
+        flux.subscribe(
+            response -> {
+                if (response.getResults() != null && !response.getResults().isEmpty()) {
+                    String content = response.getResults().get(0).getOutput().getText();
+
+                    if (content != null && !content.isEmpty()) {
+                        logger.debug("收到AI模型内容块: {}", content);
+
+                        finalContent.append(content);
+                        callback.onContentChunk(content);
+
+                        logger.debug("已调用 onContentChunk 回调");
+                    } else {
+                        logger.debug("收到空内容块，跳过");
+                    }
+                }
+            },
+            error -> {
+                logger.error("AI模型流式响应失败", error);
+                callback.onError(new Exception("AI模型流式响应失败: " + error.getMessage(), error));
+            },
+            () -> {
+                logger.info("AI模型流式响应完成，总内容长度: {}", finalContent.length());
+                callback.onComplete(finalContent.toString(), reasoningContent.toString());
+                logger.info("已调用 onComplete 回调");
+            }
+        );
+    }
+
+    /**
+     * 流式回调接口
+     */
+    public interface StreamCallback {
+        void onSearchResults(List<VectorSearchService.SearchResult> results);
+        void onReasoningChunk(String chunk);
+        void onContentChunk(String chunk);
+        void onComplete(String fullContent, String fullReasoning);
+        void onError(Exception e);
+    }
+}

src/main/java/com/superbiz/agent/service/VectorEmbeddingService.java

@@ -0,0 +1,125 @@
+package com.superbiz.agent.service;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.ai.embedding.EmbeddingModel;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * 向量嵌入服务
+ * 使用阿里云 DashScope Text Embedding API
+ */
+@Service
+public class VectorEmbeddingService {
+
+    private static final Logger logger = LoggerFactory.getLogger(VectorEmbeddingService.class);
+
+    @Autowired
+    private EmbeddingModel embeddingModel;
+
+    /**
+     * 生成向量嵌入
+     * 调用阿里云 DashScope Text Embedding API
+     * 
+     * @param content 文本内容
+     * @return 向量嵌入（浮点数列表）
+     */
+    public List<Float> generateEmbedding(String content) {
+        try {
+            if (content == null || content.trim().isEmpty()) {
+                logger.warn("内容为空，无法生成向量");
+                throw new IllegalArgumentException("内容不能为空");
+            }
+
+            logger.debug("开始生成向量嵌入, 内容长度: {} 字符", content.length());
+
+            float[] embedding = embeddingModel.embed(content);
+
+            List<Float> floatEmbedding = new ArrayList<>(embedding.length);
+            for (float v : embedding) {
+                floatEmbedding.add(v);
+            }
+
+            logger.info("成功生成向量嵌入, 内容长度: {} 字符, 向量维度: {}",
+                content.length(), floatEmbedding.size());
+
+            return floatEmbedding;
+
+        } catch (Exception e) {
+            logger.error("生成向量嵌入失败, 内容长度: {}", content != null ? content.length() : 0, e);
+            throw new RuntimeException("生成向量嵌入失败: " + e.getMessage(), e);
+        }
+    }
+
+    public List<List<Float>> generateEmbeddings(List<String> contents) {
+        try {
+            if (contents == null || contents.isEmpty()) {
+                logger.warn("内容列表为空，无法生成向量");
+                return Collections.emptyList();
+            }
+
+            logger.info("开始批量生成向量嵌入, 数量: {}", contents.size());
+
+            List<float[]> embeddings = embeddingModel.embed(contents);
+
+            List<List<Float>> result = new ArrayList<>();
+            for (float[] embedding : embeddings) {
+                List<Float> floatEmbedding = new ArrayList<>(embedding.length);
+                for (float v : embedding) {
+                    floatEmbedding.add(v);
+                }
+                result.add(floatEmbedding);
+            }
+
+            logger.info("成功批量生成向量嵌入, 数量: {}, 维度: {}",
+                result.size(),
+                result.isEmpty() ? 0 : result.get(0).size());
+
+            return result;
+
+        } catch (Exception e) {
+            logger.error("批量生成向量嵌入失败", e);
+            throw new RuntimeException("批量生成向量嵌入失败: " + e.getMessage(), e);
+        }
+    }
+
+    /**
+     * 生成查询向量
+     * 
+     * @param query 查询文本
+     * @return 向量嵌入
+     */
+    public List<Float> generateQueryVector(String query) {
+        return generateEmbedding(query);
+    }
+
+    /**
+     * 计算两个向量的余弦相似度
+     * 
+     * @param vector1 向量1
+     * @param vector2 向量2
+     * @return 余弦相似度 [-1, 1]
+     */
+    public float calculateCosineSimilarity(List<Float> vector1, List<Float> vector2) {
+        if (vector1.size() != vector2.size()) {
+            throw new IllegalArgumentException("向量维度不匹配");
+        }
+
+        float dotProduct = 0.0f;
+        float norm1 = 0.0f;
+        float norm2 = 0.0f;
+
+        for (int i = 0; i < vector1.size(); i++) {
+            dotProduct += vector1.get(i) * vector2.get(i);
+            norm1 += vector1.get(i) * vector1.get(i);
+            norm2 += vector2.get(i) * vector2.get(i);
+        }
+
+        return dotProduct / (float) (Math.sqrt(norm1) * Math.sqrt(norm2));
+    }
+}

src/main/java/com/superbiz/agent/service/VectorIndexService.java

@@ -0,0 +1,351 @@
+package com.superbiz.agent.service;
+
+import io.milvus.client.MilvusServiceClient;
+import io.milvus.grpc.MutationResult;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.LoadCollectionParam;
+import io.milvus.param.dml.DeleteParam;
+import io.milvus.param.dml.InsertParam;
+import lombok.Getter;
+import lombok.Setter;
+import com.superbiz.agent.constant.MilvusConstants;
+import com.superbiz.agent.dto.DocumentChunk;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+import java.io.File;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.LocalDateTime;
+import java.util.*;
+
+/**
+ * 向量索引服务
+ * 负责读取文件、生成向量、存储到 Milvus
+ */
+@Service
+public class VectorIndexService {
+
+    private static final Logger logger = LoggerFactory.getLogger(VectorIndexService.class);
+
+    @Autowired
+    private MilvusServiceClient milvusClient;
+
+    @Autowired
+    private VectorEmbeddingService embeddingService;
+
+    @Autowired
+    private DocumentChunkService chunkService;
+
+    @Value("${file.upload.path}")
+    private String uploadPath;
+
+    /**
+     * 索引指定目录下的所有文件
+     * 
+     * @param directoryPath 目录路径（可选，默认使用配置的上传目录）
+     * @return 索引结果  这里可以优化：定时重建目录下所有文件的索引
+     */
+    public IndexingResult indexDirectory(String directoryPath) {
+        IndexingResult result = new IndexingResult();
+        result.setStartTime(LocalDateTime.now());
+
+        try {
+            // 使用指定目录或默认上传目录
+            String targetPath = (directoryPath != null && !directoryPath.trim().isEmpty()) 
+                    ? directoryPath : uploadPath;
+                    
+            Path dirPath = Paths.get(targetPath).normalize();
+            File directory = dirPath.toFile();
+            
+            if (!directory.exists() || !directory.isDirectory()) {
+                throw new IllegalArgumentException("目录不存在或不是有效目录: " + targetPath);
+            }
+
+            result.setDirectoryPath(directory.getAbsolutePath());
+
+            // 获取所有支持的文件
+            File[] files = directory.listFiles((dir, name) -> 
+                name.endsWith(".txt") || name.endsWith(".md")
+            );
+
+            if (files == null || files.length == 0) {
+                logger.warn("目录中没有找到支持的文件: {}", targetPath);
+                result.setTotalFiles(0);
+                result.setSuccess(true);
+                result.setEndTime(LocalDateTime.now());
+                return result;
+            }
+
+            result.setTotalFiles(files.length);
+            logger.info("开始索引目录: {}, 找到 {} 个文件", targetPath, files.length);
+
+            // 遍历并索引每个文件
+            for (File file : files) {
+                try {
+                    indexSingleFile(file.getAbsolutePath());
+                    result.incrementSuccessCount();
+                    logger.info("✓ 文件索引成功: {}", file.getName());
+                } catch (Exception e) {
+                    result.incrementFailCount();
+                    result.addFailedFile(file.getAbsolutePath(), e.getMessage());
+                    logger.error("✗ 文件索引失败: {}", file.getName(), e);
+                }
+            }
+
+            result.setSuccess(result.getFailCount() == 0);
+            result.setEndTime(LocalDateTime.now());
+
+            logger.info("目录索引完成: 总数={}, 成功={}, 失败={}", 
+                result.getTotalFiles(), result.getSuccessCount(), result.getFailCount());
+
+            return result;
+
+        } catch (Exception e) {
+            logger.error("索引目录失败", e);
+            result.setSuccess(false);
+            result.setErrorMessage(e.getMessage());
+            result.setEndTime(LocalDateTime.now());
+            return result;
+        }
+    }
+
+    /**
+     * 索引单个文件
+     * 
+     * @param filePath 文件路径
+     * @throws Exception 索引失败时抛出异常
+     */
+    public void indexSingleFile(String filePath) throws Exception {
+        Path path = Paths.get(filePath).normalize();
+        File file = path.toFile();
+        
+        if (!file.exists() || !file.isFile()) {
+            throw new IllegalArgumentException("文件不存在: " + filePath);
+        }
+
+        logger.info("开始索引文件: {}", path);
+
+        // 1. 读取文件内容
+        String content = Files.readString(path);
+        logger.info("读取文件: {}, 内容长度: {} 字符", path, content.length());
+
+        // 2. 删除该文件的旧数据（如果存在）
+        deleteExistingData(path.toString());
+
+        // 3. 文档分片
+        List<DocumentChunk> chunks = chunkService.chunkDocument(content, path.toString());
+        logger.info("文档分片完成: {} -> {} 个分片", filePath, chunks.size());
+
+        // 4. 为每个分片生成向量并插入 Milvus
+        for (int i = 0; i < chunks.size(); i++) {
+            DocumentChunk chunk = chunks.get(i);
+            
+            try {
+                // 生成向量
+                List<Float> vector = embeddingService.generateEmbedding(chunk.getContent());
+
+                // 构建元数据（包含文件信息）
+                Map<String, Object> metadata = buildMetadata(path.toString(), chunk, chunks.size());
+
+                // 插入到 Milvus
+                insertToMilvus(chunk.getContent(), vector, metadata, chunk.getChunkIndex());
+                
+                logger.info("✓ 分片 {}/{} 索引成功", i + 1, chunks.size());
+
+            } catch (Exception e) {
+                logger.error("✗ 分片 {}/{} 索引失败", i + 1, chunks.size(), e);
+                throw new RuntimeException("分片索引失败: " + e.getMessage(), e);
+            }
+        }
+
+        logger.info("文件索引完成: {}, 共 {} 个分片", filePath, chunks.size());
+    }
+
+    /**
+     * 删除文件的旧数据（根据 metadata._source）
+     */
+    private void deleteExistingData(String filePath) {
+        try {
+            // 使用统一的路径分隔符（正斜杠）用于Milvus存储，避免表达式解析错误
+            // 将系统路径转换为统一格式
+            Path path = Paths.get(filePath).normalize();
+            String normalizedPath = path.toString().replace(File.separator, "/");
+            
+            // 构建删除表达式：metadata["_source"] == "xxx"
+            String expr = String.format("metadata[\"_source\"] == \"%s\"", normalizedPath);
+            
+            logger.info("准备删除旧数据，路径: {}, 表达式: {}", normalizedPath, expr);
+
+            // 确保 collection 已加载（删除操作需要集合已加载）
+            R<RpcStatus> loadResponse = milvusClient.loadCollection(
+                LoadCollectionParam.newBuilder()
+                    .withCollectionName(MilvusConstants.MILVUS_COLLECTION_NAME)
+                    .build()
+            );
+
+            // 状态码 65535 表示集合已经加载，这不是错误
+            if (loadResponse.getStatus() != 0 && loadResponse.getStatus() != 65535) {
+                logger.warn("加载 collection 失败: {}", loadResponse.getMessage());
+                return;
+            }
+
+            DeleteParam deleteParam = DeleteParam.newBuilder()
+                    .withCollectionName(MilvusConstants.MILVUS_COLLECTION_NAME)
+                    .withExpr(expr)
+                    .build();
+
+            R<MutationResult> response = milvusClient.delete(deleteParam);
+
+            if (response.getStatus() != 0) {
+                logger.warn("删除旧数据时出现警告: {}", response.getMessage());
+            } else {
+                long deletedCount = response.getData().getDeleteCnt();
+                logger.info("✓ 已删除文件的旧数据: {}, 删除记录数: {}", normalizedPath, deletedCount);
+            }
+
+        } catch (Exception e) {
+            logger.warn("删除旧数据失败（可能是首次索引）: {}", e.getMessage());
+        }
+    }
+
+    /**
+     * 构建元数据（包含文件信息）
+     */
+    private Map<String, Object> buildMetadata(String filePath, DocumentChunk chunk, int totalChunks) {
+        Map<String, Object> metadata = new HashMap<>();
+        
+        // 标准化路径：使用统一的路径分隔符（正斜杠）用于存储，确保跨平台一致性
+        Path path = Paths.get(filePath).normalize();
+        String normalizedPath = path.toString().replace(File.separator, "/");
+        
+        // 文件信息
+        Path fileName = path.getFileName();
+        String fileNameStr = fileName != null ? fileName.toString() : "";
+        String extension = "";
+        int dotIndex = fileNameStr.lastIndexOf('.');
+        if (dotIndex > 0) {
+            extension = fileNameStr.substring(dotIndex);
+        }
+        
+        metadata.put("_source", normalizedPath);
+        metadata.put("_extension", extension);
+        metadata.put("_file_name", fileNameStr);
+        
+        // 分片信息
+        metadata.put("chunkIndex", chunk.getChunkIndex());
+        metadata.put("totalChunks", totalChunks);
+        
+        // 标题信息
+        if (chunk.getTitle() != null && !chunk.getTitle().isEmpty()) {
+            metadata.put("title", chunk.getTitle());
+        }
+        
+        return metadata;
+    }
+
+    /**
+     * 插入向量到 Milvus
+     */
+    private void insertToMilvus(String content, List<Float> vector, 
+                                Map<String, Object> metadata, int chunkIndex) throws Exception {
+        try {
+            // 确保 collection 已加载
+            R<RpcStatus> loadResponse = milvusClient.loadCollection(
+                LoadCollectionParam.newBuilder()
+                    .withCollectionName(MilvusConstants.MILVUS_COLLECTION_NAME)
+                    .build()
+            );
+
+            if (loadResponse.getStatus() != 0 && loadResponse.getStatus() != 65535) {
+                throw new RuntimeException("加载 collection 失败: " + loadResponse.getMessage());
+            }
+
+            // 生成唯一 ID（使用 _source + 分片索引）
+            String source = (String) metadata.get("_source");
+            String id = UUID.nameUUIDFromBytes((source + "_" + chunkIndex).getBytes()).toString();
+
+            // 构建字段数据
+            List<InsertParam.Field> fields = new ArrayList<>();
+            
+            // ID 字段
+            fields.add(new InsertParam.Field("id", Collections.singletonList(id)));
+            
+            // content 字段
+            fields.add(new InsertParam.Field("content", Collections.singletonList(content)));
+            
+            // vector 字段
+            fields.add(new InsertParam.Field("vector", Collections.singletonList(vector)));
+            
+            // metadata 字段（JSON 对象）
+            com.google.gson.Gson gson = new com.google.gson.Gson();
+            com.google.gson.JsonObject metadataJson = gson.toJsonTree(metadata).getAsJsonObject();
+            fields.add(new InsertParam.Field("metadata", Collections.singletonList(metadataJson)));
+
+            // 构建插入参数
+            InsertParam insertParam = InsertParam.newBuilder()
+                    .withCollectionName(MilvusConstants.MILVUS_COLLECTION_NAME)
+                    .withFields(fields)
+                    .build();
+
+            // 执行插入
+            R<MutationResult> insertResponse = milvusClient.insert(insertParam);
+
+            if (insertResponse.getStatus() != 0) {
+                throw new RuntimeException("插入向量失败: " + insertResponse.getMessage());
+            }
+
+            logger.debug("向量插入成功: id={}, source={}, chunk={}", id, source, chunkIndex);
+
+        } catch (Exception e) {
+            logger.error("插入向量到 Milvus 失败", e);
+            throw e;
+        }
+    }
+
+    /**
+     * 索引结果类
+     */
+    @Getter
+    public static class IndexingResult {
+        @Setter
+        private boolean success;
+        @Setter
+        private String directoryPath;
+        @Setter
+        private int totalFiles;
+        private int successCount;
+        private int failCount;
+        @Setter
+        private LocalDateTime startTime;
+        @Setter
+        private LocalDateTime endTime;
+        @Setter
+        private String errorMessage;
+        private Map<String, String> failedFiles = new HashMap<>();
+
+        public void incrementSuccessCount() {
+            this.successCount++;
+        }
+
+        public void incrementFailCount() {
+            this.failCount++;
+        }
+
+        public long getDurationMs() {
+            if (startTime != null && endTime != null) {
+                return java.time.Duration.between(startTime, endTime).toMillis();
+            }
+            return 0;
+        }
+
+        public void addFailedFile(String filePath, String error) {
+            this.failedFiles.put(filePath, error);
+        }
+    }
+}

src/main/java/com/superbiz/agent/service/VectorSearchService.java

@@ -0,0 +1,108 @@
+package com.superbiz.agent.service;
+
+import io.milvus.client.MilvusServiceClient;
+import io.milvus.grpc.SearchResults;
+import io.milvus.param.R;
+import io.milvus.param.dml.SearchParam;
+import io.milvus.response.SearchResultsWrapper;
+import lombok.Getter;
+import lombok.Setter;
+import com.superbiz.agent.constant.MilvusConstants;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * 向量搜索服务
+ * 负责从 Milvus 中搜索相似向量
+ */
+@Service
+public class VectorSearchService {
+
+    private static final Logger logger = LoggerFactory.getLogger(VectorSearchService.class);
+
+    @Autowired
+    private MilvusServiceClient milvusClient;
+
+    @Autowired
+    private VectorEmbeddingService embeddingService;
+
+    /**
+     * 搜索相似文档
+     * 
+     * @param query 查询文本
+     * @param topK 返回最相似的K个结果
+     * @return 搜索结果列表
+     */
+    public List<SearchResult> searchSimilarDocuments(String query, int topK) {
+        try {
+            logger.info("开始搜索相似文档, 查询: {}, topK: {}", query, topK);
+
+            // 1. 将查询文本向量化
+            List<Float> queryVector = embeddingService.generateQueryVector(query);
+            logger.debug("查询向量生成成功, 维度: {}", queryVector.size());
+
+            // 2. 构建搜索参数
+            SearchParam searchParam = SearchParam.newBuilder()
+                    .withCollectionName(MilvusConstants.MILVUS_COLLECTION_NAME)
+                    .withVectorFieldName("vector")
+                    .withVectors(Collections.singletonList(queryVector))
+                    .withTopK(topK)
+                    .withMetricType(io.milvus.param.MetricType.L2)
+                    .withOutFields(List.of("id", "content", "metadata"))
+                    .withParams("{\"nprobe\":10}")
+                    .build();
+
+            // 3. 执行搜索
+            R<SearchResults> searchResponse = milvusClient.search(searchParam);
+
+            if (searchResponse.getStatus() != 0) {
+                throw new RuntimeException("向量搜索失败: " + searchResponse.getMessage());
+            }
+
+            // 4. 解析搜索结果
+            SearchResultsWrapper wrapper = new SearchResultsWrapper(searchResponse.getData().getResults());
+            List<SearchResult> results = new ArrayList<>();
+
+            for (int i = 0; i < wrapper.getRowRecords(0).size(); i++) {
+                SearchResult result = new SearchResult();
+                result.setId((String) wrapper.getIDScore(0).get(i).get("id"));
+                result.setContent((String) wrapper.getFieldData("content", 0).get(i));
+                result.setScore(wrapper.getIDScore(0).get(i).getScore());
+                
+                // 解析 metadata
+                Object metadataObj = wrapper.getFieldData("metadata", 0).get(i);
+                if (metadataObj != null) {
+                    result.setMetadata(metadataObj.toString());
+                }
+                
+                results.add(result);
+            }
+
+            logger.info("搜索完成, 找到 {} 个相似文档", results.size());
+            return results;
+
+        } catch (Exception e) {
+            logger.error("搜索相似文档失败", e);
+            throw new RuntimeException("搜索失败: " + e.getMessage(), e);
+        }
+    }
+
+    /**
+     * 搜索结果类
+     */
+    @Setter
+    @Getter
+    public static class SearchResult {
+        private String id;
+        private String content;
+        private float score;
+        private String metadata;
+
+    }
+}

src/main/java/com/superbiz/agent/service/session/SessionManager.java

@@ -0,0 +1,77 @@
+package com.superbiz.agent.service.session;
+
+import com.superbiz.agent.domain.model.SessionContext;
+import com.superbiz.agent.domain.model.ToolCall;
+
+import java.util.Optional;
+
+/**
+ * 会话管理器接口
+ * 负责会话的创建、读取、更新和删除
+ */
+public interface SessionManager {
+
+    /**
+     * 创建新会话
+     *
+     * @param sessionContext 会话上下文
+     * @param ttlSeconds     会话过期时间（秒）
+     * @return 会话ID
+     */
+    String createSession(SessionContext sessionContext, long ttlSeconds);
+
+    /**
+     * 获取会话
+     *
+     * @param sessionId 会话ID
+     * @return 会话上下文（如果存在）
+     */
+    Optional<SessionContext> getSession(String sessionId);
+
+    /**
+     * 更新会话
+     *
+     * @param sessionContext 会话上下文
+     */
+    void updateSession(SessionContext sessionContext);
+
+    /**
+     * 删除会话
+     *
+     * @param sessionId 会话ID
+     */
+    void deleteSession(String sessionId);
+
+    /**
+     * 检查会话是否存在
+     *
+     * @param sessionId 会话ID
+     * @return true 如果会话存在
+     */
+    boolean exists(String sessionId);
+
+    /**
+     * 刷新会话过期时间
+     *
+     * @param sessionId  会话ID
+     * @param ttlSeconds 新的过期时间（秒）
+     * @return true 如果刷新成功
+     */
+    boolean refreshSession(String sessionId, long ttlSeconds);
+
+    /**
+     * 添加工具调用记录到会话
+     *
+     * @param sessionId 会话ID
+     * @param toolCall  工具调用记录
+     */
+    void addToolCall(String sessionId, ToolCall toolCall);
+
+    /**
+     * 更新会话状态
+     *
+     * @param sessionId 会话ID
+     * @param status    新状态
+     */
+    void updateStatus(String sessionId, String status);
+}

src/main/java/com/superbiz/agent/service/session/impl/RedisSessionManager.java

@@ -0,0 +1,147 @@
+package com.superbiz.agent.service.session.impl;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import com.superbiz.agent.domain.model.SessionContext;
+import com.superbiz.agent.domain.model.ToolCall;
+import com.superbiz.agent.service.session.SessionManager;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.util.Optional;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Redis 会话管理器实现
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class RedisSessionManager implements SessionManager {
+
+    private static final String SESSION_KEY_PREFIX = "session:";
+
+    private final RedisTemplate<String, Object> redisTemplate;
+
+    @Override
+    public String createSession(SessionContext sessionContext, long ttlSeconds) {
+        String sessionId = sessionContext.getSessionId();
+        if (sessionId == null || sessionId.isEmpty()) {
+            throw new IllegalArgumentException("Session ID cannot be null or empty");
+        }
+
+        sessionContext.setCreatedAt(LocalDateTime.now());
+        sessionContext.setLastActiveAt(LocalDateTime.now());
+        sessionContext.setTtl(ttlSeconds);
+        sessionContext.setStatus("ACTIVE");
+
+        String key = buildKey(sessionId);
+        redisTemplate.opsForValue().set(key, sessionContext, ttlSeconds, TimeUnit.SECONDS);
+
+        log.info("创建会话成功: sessionId={}, ttl={}秒", sessionId, ttlSeconds);
+        return sessionId;
+    }
+
+    @Override
+    public Optional<SessionContext> getSession(String sessionId) {
+        String key = buildKey(sessionId);
+        Object value = redisTemplate.opsForValue().get(key);
+
+        if (value instanceof SessionContext) {
+            SessionContext context = (SessionContext) value;
+            log.debug("获取会话成功: sessionId={}", sessionId);
+            return Optional.of(context);
+        }
+
+        log.debug("会话不存在: sessionId={}", sessionId);
+        return Optional.empty();
+    }
+
+    @Override
+    public void updateSession(SessionContext sessionContext) {
+        String sessionId = sessionContext.getSessionId();
+        String key = buildKey(sessionId);
+
+        // 获取剩余 TTL
+        Long ttl = redisTemplate.getExpire(key, TimeUnit.SECONDS);
+        if (ttl == null || ttl <= 0) {
+            ttl = sessionContext.getTtl() != null ? sessionContext.getTtl() : 3600L;
+        }
+
+        sessionContext.setLastActiveAt(LocalDateTime.now());
+        redisTemplate.opsForValue().set(key, sessionContext, ttl, TimeUnit.SECONDS);
+
+        log.debug("更新会话成功: sessionId={}", sessionId);
+    }
+
+    @Override
+    public void deleteSession(String sessionId) {
+        String key = buildKey(sessionId);
+        Boolean deleted = redisTemplate.delete(key);
+
+        if (Boolean.TRUE.equals(deleted)) {
+            log.info("删除会话成功: sessionId={}", sessionId);
+        } else {
+            log.warn("删除会话失败，会话可能不存在: sessionId={}", sessionId);
+        }
+    }
+
+    @Override
+    public boolean exists(String sessionId) {
+        String key = buildKey(sessionId);
+        Boolean exists = redisTemplate.hasKey(key);
+        return Boolean.TRUE.equals(exists);
+    }
+
+    @Override
+    public boolean refreshSession(String sessionId, long ttlSeconds) {
+        String key = buildKey(sessionId);
+        Boolean refreshed = redisTemplate.expire(key, ttlSeconds, TimeUnit.SECONDS);
+
+        if (Boolean.TRUE.equals(refreshed)) {
+            log.debug("刷新会话过期时间成功: sessionId={}, newTtl={}秒", sessionId, ttlSeconds);
+            return true;
+        }
+
+        log.warn("刷新会话过期时间失败，会话可能不存在: sessionId={}", sessionId);
+        return false;
+    }
+
+    @Override
+    public void addToolCall(String sessionId, ToolCall toolCall) {
+        Optional<SessionContext> sessionOpt = getSession(sessionId);
+
+        if (sessionOpt.isPresent()) {
+            SessionContext context = sessionOpt.get();
+            context.addToolCall(toolCall);
+            updateSession(context);
+
+            log.debug("添加工具调用记录成功: sessionId={}, toolName={}", sessionId, toolCall.getToolName());
+        } else {
+            log.warn("会话不存在，无法添加工具调用记录: sessionId={}", sessionId);
+        }
+    }
+
+    @Override
+    public void updateStatus(String sessionId, String status) {
+        Optional<SessionContext> sessionOpt = getSession(sessionId);
+
+        if (sessionOpt.isPresent()) {
+            SessionContext context = sessionOpt.get();
+            context.setStatus(status);
+            updateSession(context);
+
+            log.debug("更新会话状态成功: sessionId={}, status={}", sessionId, status);
+        } else {
+            log.warn("会话不存在，无法更新状态: sessionId={}", sessionId);
+        }
+    }
+
+    /**
+     * 构建 Redis key
+     */
+    private String buildKey(String sessionId) {
+        return SESSION_KEY_PREFIX + sessionId;
+    }
+}

src/main/java/com/superbiz/agent/tool/DropCollection.java

@@ -0,0 +1,69 @@
+package com.superbiz.agent.tool;
+
+import io.milvus.client.MilvusServiceClient;
+import io.milvus.param.ConnectParam;
+import io.milvus.param.R;
+import io.milvus.param.RpcStatus;
+import io.milvus.param.collection.DropCollectionParam;
+import io.milvus.param.collection.HasCollectionParam;
+
+/**
+ * 删除 Milvus Collection 的工具类
+ * 用于重建 Collection 时清理旧数据
+ */
+public class DropCollection {
+    
+    public static void main(String[] args) {
+        MilvusServiceClient client = null;
+        
+        try {
+            // 连接到 Milvus
+            System.out.println("正在连接到 Milvus localhost:19530...");
+            client = new MilvusServiceClient(
+                ConnectParam.newBuilder()
+                    .withHost("localhost")
+                    .withPort(19530)
+                    .build()
+            );
+            System.out.println("✓ 连接成功");
+            
+            String collectionName = "biz";
+            
+            // 检查 Collection 是否存在
+            R<Boolean> hasResponse = client.hasCollection(
+                HasCollectionParam.newBuilder()
+                    .withCollectionName(collectionName)
+                    .build()
+            );
+            
+            if (hasResponse.getData()) {
+                System.out.println("发现 Collection: " + collectionName);
+                System.out.println("正在删除...");
+                
+                // 删除 Collection
+                R<RpcStatus> dropResponse = client.dropCollection(
+                    DropCollectionParam.newBuilder()
+                        .withCollectionName(collectionName)
+                        .build()
+                );
+                
+                if (dropResponse.getStatus() == 0) {
+                    System.out.println("✓ Collection 已成功删除");
+                    System.out.println("\n请重启 Spring Boot 应用，它会自动创建新的 FloatVector Collection");
+                } else {
+                    System.err.println("✗ 删除失败: " + dropResponse.getMessage());
+                }
+            } else {
+                System.out.println("Collection '" + collectionName + "' 不存在");
+            }
+            
+        } catch (Exception e) {
+            System.err.println("错误: " + e.getMessage());
+            e.printStackTrace();
+        } finally {
+            if (client != null) {
+                client.close();
+            }
+        }
+    }
+}