<!-- Spring Boot 核心（支撐 Spring AI） -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.5</version>
    <relativePath/>
</parent>
<dependencies>
    <!-- 1. Spring AI Alibaba 核心（含 Workflow + DashScope 客戶(hù)端） -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>spring-ai-alibaba-dashscope-spring-boot-starter</artifactId>
        <version>0.1.0</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>spring-ai-alibaba-workflow-core</artifactId>
        <version>0.1.0</version>
    </dependency>
    <!-- 2. AgentScope Java 核心 -->
    <dependency>
        <groupId>io.agentscope</groupId>
        <artifactId>agentscope-core</artifactId>
        <version>0.1.0</version>
    </dependency>
    <dependency>
        <groupId>io.agentscope</groupId>
        <artifactId>agentscope-spring-boot-starter</artifactId>
        <version>0.1.0</version> <!-- 簡(jiǎn)化 Spring 集成 -->
    </dependency>
    <!-- 3. Java2AI Graph Core（可選，標(biāo)準(zhǔn)化工作流節(jié)點(diǎn)） -->
    <dependency>
        <groupId>com.java2ai</groupId>
        <artifactId>graph-core</artifactId>
        <version>1.0.0</version>
    </dependency>
    <!-- 4. 基礎(chǔ)依賴(lài) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
</dependencies>

# 1. Spring AI Alibaba 配置
spring:
  ai:
    # 阿里云 DashScope 配置（通義千問(wèn)）
    dashscope:
      api-key: ${DASHSCOPE_API_KEY:你的阿里云API密鑰}
      chat:
        options:
          model: qwen-turbo
          temperature: 0.7
    # Spring AI Workflow 配置
    workflow:
      executor:
        thread-pool-size: 8
      persistence:
        enabled: true # 開(kāi)啟工作流持久化（可選）
# 2. AgentScope 配置（復(fù)用 Spring AI 的模型密鑰）
agentscope:
  core:
    agent:
      default-context-size: 1000 # 智能體默認(rèn)上下文大小
    model:
      dashscope:
        api-key: ${spring.ai.dashscope.api-key}
        model-name: ${spring.ai.dashscope.chat.options.model}
  spring:
    integration:
      enabled: true # 開(kāi)啟 AgentScope 與 Spring 集成
# 3. Java2AI Graph Core 配置（可選）
java2ai:
  graph:
    core:
      node-package: com.yourpackage.agent.workflow.node # 工作流節(jié)點(diǎn)掃描包

package com.yourpackage.workflow;
import com.alibaba.spring.ai.workflow.annotation.Workflow;
import com.alibaba.spring.ai.workflow.annotation.WorkflowNode;
import com.alibaba.spring.ai.workflow.executor.WorkflowContext;
import org.springframework.ai.dashscope.DashScopeChatClient;
import org.springframework.stereotype.Component;
/**
 * 基于 Spring AI Alibaba 定義的病歷分析工作流
 * 節(jié)點(diǎn)1：提取病歷關(guān)鍵信息 → 節(jié)點(diǎn)2：校驗(yàn)數(shù)據(jù)完整性 → 節(jié)點(diǎn)3：生成分析報(bào)告
 */
@Workflow(name = "medical-record-analysis", description = "醫(yī)療病歷分析工作流")
@Component
public class MedicalRecordAnalysisWorkflow {
    private final DashScopeChatClient dashScopeChatClient;
    public MedicalRecordAnalysisWorkflow(DashScopeChatClient dashScopeChatClient) {
        this.dashScopeChatClient = dashScopeChatClient;
    }
    /**
     * 節(jié)點(diǎn)1：提取病歷關(guān)鍵信息（大模型調(diào)用）
     */
    @WorkflowNode(name = "extract-info", order = 1, requiredParams = "medicalRecord")
    public String extractMedicalInfo(WorkflowContext context) {
        String medicalRecord = context.getParam("medicalRecord", String.class);
        String prompt = """
                提取以下病歷的關(guān)鍵信息（患者姓名、癥狀、檢查結(jié)果、診斷結(jié)論）：
                %s
                要求：結(jié)構(gòu)化輸出，簡(jiǎn)潔明了
                """.formatted(medicalRecord);
        // 調(diào)用 Spring AI Alibaba 的 DashScope 客戶(hù)端
        return dashScopeChatClient.call(prompt).getResult().getOutput().getContent();
    }
    /**
     * 節(jié)點(diǎn)2：校驗(yàn)數(shù)據(jù)完整性（工具調(diào)用）
     */
    @WorkflowNode(name = "validate-data", order = 2, dependOn = "extract-info")
    public String validateData(WorkflowContext context) {
        String extractedInfo = context.getResult("extract-info", String.class);
        // 自定義校驗(yàn)邏輯（可復(fù)用 AgentScope 工具）
        boolean isComplete = extractedInfo.contains("檢查結(jié)果") && extractedInfo.contains("診斷結(jié)論");
        return isComplete ? "數(shù)據(jù)完整" : "缺少檢查結(jié)果/診斷結(jié)論，數(shù)據(jù)不完整";
    }
    /**
     * 節(jié)點(diǎn)3：生成分析報(bào)告（結(jié)果聚合）
     */
    @WorkflowNode(name = "generate-report", order = 3, dependOn = "validate-data")
    public String generateReport(WorkflowContext context) {
        String extractedInfo = context.getResult("extract-info", String.class);
        String validateResult = context.getResult("validate-data", String.class);
        String prompt = """
                基于以下信息生成醫(yī)療分析報(bào)告：
                1. 提取的病歷信息：%s
                2. 數(shù)據(jù)校驗(yàn)結(jié)果：%s
                要求：專(zhuān)業(yè)、簡(jiǎn)潔，符合醫(yī)療規(guī)范
                """.formatted(extractedInfo, validateResult);
        return dashScopeChatClient.call(prompt).getResult().getOutput().getContent();
    }
}

package com.yourpackage.agent.tool;
import io.agentscope.core.tool.Tool;
import io.agentscope.core.tool.ToolParam;
import com.alibaba.spring.ai.workflow.executor.WorkflowExecutor;
import com.alibaba.spring.ai.workflow.model.WorkflowExecutionResult;
import org.springframework.stereotype.Component;
/**
 * AgentScope 工具：調(diào)用 Spring AI Alibaba Workflow
 */
@Component
@Tool(name = "medical_record_workflow_tool", description = "執(zhí)行醫(yī)療病歷分析工作流")
public class MedicalRecordWorkflowTool {
    private final WorkflowExecutor workflowExecutor;
    public MedicalRecordWorkflowTool(WorkflowExecutor workflowExecutor) {
        this.workflowExecutor = workflowExecutor;
    }
    /**
     * 工具執(zhí)行方法（AgentScope 調(diào)用入口）
     * @param medicalRecord 病歷文本
     * @return 工作流執(zhí)行結(jié)果（分析報(bào)告）
     */
    public String execute(
            @ToolParam(name = "medicalRecord", description = "待分析的病歷文本", required = true)
            String medicalRecord
    ) {
        // 執(zhí)行 Spring AI Workflow
        WorkflowExecutionResult result = workflowExecutor.execute(
                "medical-record-analysis", // 工作流名稱(chēng)
                param -> param.put("medicalRecord", medicalRecord)
        );
        // 返回最終節(jié)點(diǎn)結(jié)果
        return result.getNodeResult("generate-report", String.class);
    }
}

package com.yourpackage.agent;
import io.agentscope.core.agent.ReActAgent;
import io.agentscope.core.model.dashscope.DashScopeChatModel;
import io.agentscope.core.tool.Toolkit;
import io.agentscope.spring.annotation.Agent;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
/**
 * AgentScope 智能體：集成 Spring AI Workflow 工具
 */
@Agent
public class MedicalAnalysisAgent {
    @Autowired
    private MedicalRecordWorkflowTool medicalRecordWorkflowTool;
    @Autowired
    private DashScopeChatModel dashScopeChatModel;
    /**
     * 創(chuàng)建 ReAct 智能體（核心）
     */
    @Bean
    public ReActAgent createMedicalAnalysisAgent() {
        // 1. 初始化工具包，注冊(cè) Workflow 工具
        Toolkit toolkit = Toolkit.createDefault();
        toolkit.registration()
                .tool(medicalRecordWorkflowTool::execute)
                .group("workflow_tools")
                .apply();
        // 2. 構(gòu)建 ReAct 智能體
        return ReActAgent.builder()
                .id("medical-analysis-agent")
                .name("MedicalAnalysisAgent")
                .model(dashScopeChatModel) // 復(fù)用 Spring AI 的 DashScope 模型
                .toolkit(toolkit) // 注冊(cè) Workflow 工具
                .sysPrompt("""
                        你是醫(yī)療病歷分析智能體，用戶(hù)輸入病歷文本后，必須調(diào)用「medical_record_workflow_tool」工具執(zhí)行分析，
                        并返回最終的分析報(bào)告，禁止直接生成結(jié)果。
                        """)
                .build();
    }
}

package com.yourpackage.controller;
import io.agentscope.core.agent.ReActAgent;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
 * 業(yè)務(wù)入口：病歷分析接口
 */
@RestController
@RequestMapping("/api/agent")
public class MedicalAgentController {
    private final ReActAgent medicalAnalysisAgent;
    public MedicalAgentController(ReActAgent medicalAnalysisAgent) {
        this.medicalAnalysisAgent = medicalAnalysisAgent;
    }
    /**
     * 智能體 + 工作流 執(zhí)行接口
     */
    @PostMapping("/analyze-medical-record")
    public ResponseEntity<String> analyzeMedicalRecord(@RequestBody String medicalRecord) {
        // 1. 智能體處理用戶(hù)請(qǐng)求（自動(dòng)決策調(diào)用 Workflow 工具）
        String response = medicalAnalysisAgent.chat("分析以下病歷：" + medicalRecord).getTextContent();
        // 2. 返回結(jié)果
        return ResponseEntity.ok(response);
    }
}

// 改造 Workflow 工具為異步執(zhí)行
public CompletableFuture<String> executeAsync(String medicalRecord) {
    return CompletableFuture.supplyAsync(() -> {
        WorkflowExecutionResult result = workflowExecutor.execute(
                "medical-record-analysis",
                param -> param.put("medicalRecord", medicalRecord)
        );
        return result.getNodeResult("generate-report", String.class);
    });
}
// AgentScope 智能體調(diào)用異步工具
toolkit.registration()
        .tool(medicalRecordWorkflowTool::executeAsync)
        .async(true) // 標(biāo)記為異步工具
        .apply();

// Workflow 工具中注入 Agent 上下文
public String execute(String medicalRecord, @RequestAttribute("agentContext") Map<String, Object> agentContext) {
    WorkflowExecutionResult result = workflowExecutor.execute(
            "medical-record-analysis",
            param -> {
                param.put("medicalRecord", medicalRecord);
                param.put("agentContext", agentContext); // 傳遞 Agent 上下文
            }
    );
    // 將 Workflow 結(jié)果同步回 Agent 上下文
    agentContext.put("workflowResult", result.getNodeResult("generate-report", String.class));
    return result.getNodeResult("generate-report", String.class);
}

public String execute(String medicalRecord) {
    try {
        WorkflowExecutionResult result = workflowExecutor.execute(
                "medical-record-analysis",
                param -> param.put("medicalRecord", medicalRecord)
        );
        return result.getNodeResult("generate-report", String.class);
    } catch (Exception e) {
        // 兜底邏輯：AgentScope 智能體降級(jí)處理
        return "病歷分析失?。? + e.getMessage() + "，已觸發(fā)人工審核流程";
    }
}

# application.yml 新增
management:
  endpoints:
    web:
      exposure:
        include: health, metrics, workflows, agents
  metrics:
    enable: true
  endpoint:
    workflows:
      enabled: true # 暴露 Workflow 執(zhí)行指標(biāo)
    agents:
      enabled: true # 暴露 AgentScope 智能體指標(biāo)