8 mcp local

@Service
public class S3McpServerTools {

    // 测试工具方法：返回简单信息
    @Tool(name = "queryInfo", description = "测试工具，返回欢迎信息")
    public String queryInfo() throws Exception {
        // 返回固定的欢迎消息
        return "我的第一个MCP Server!!";
    }

    // OSS桶创建工具
    @Tool(name = "CreateBucket", description = "创建新的OSS存储桶")
    public McpResult<String> createBucket(
            @ToolParam(description = "要创建的存储桶名称") String bucket) {

        // 校验桶名称不能为空
        if (bucket == null || bucket.isEmpty()) {
            throw new IllegalArgumentException("桶名称不能为空");
        }

        // 获取OSS客户端实例
        OSS ossClient = getOSSClient();

        // 创建桶请求对象
        CreateBucketRequest createBucketRequest = new CreateBucketRequest(bucket);

        // 执行创建桶操作
        ossClient.createBucket(createBucketRequest);

        // 返回成功结果
        return McpResult.success("桶创建成功");
    }
}

@Component
public class S3McpToolCallback {

    // 注册OSS工具到Spring上下文
    @Bean
    public ToolCallbackProvider obsTools(S3McpServerTools s3McpServerTools) {
        // 使用构建器模式创建工具回调提供者
        return MethodToolCallbackProvider.builder()
                // 添加工具对象
                .toolObjects(s3McpServerTools)
                // 构建最终实例
                .build();
    }

    // 获取OSS客户端的方法
    private OSS getOSSClient() {
        // 从配置读取访问密钥
        String accessKey = env.getProperty("oss.access-key");
        String secretKey = env.getProperty("oss.secret-key");
        String endpoint = env.getProperty("oss.endpoint");

        // 创建OSS客户端配置
        ClientBuilderConfiguration config = new ClientBuilderConfiguration();
        config.setConnectionTimeout(30000);
        config.setSocketTimeout(60000);

        // 构建OSS客户端实例
        return new OSSClientBuilder().build(endpoint, accessKey, secretKey, config);
    }
}

@RestController
public class AiController {

    // 默认提示语
    private static final String DEFAULT_PROMPT = "查询存储桶信息";

    // Chat客户端实例
    private final ChatClient chatClient;

    // 工具回调提供者
    private final ToolCallbackProvider tools;

    // 构造函数依赖注入
    public AiController(ChatClient.Builder chatClient, ToolCallbackProvider tools) {
        this.chatClient = chatClient
                // 添加聊天记忆顾问
                .defaultAdvisors(new MessageChatMemoryAdvisor(new InMemoryChatMemory()))
                // 添加简单日志顾问
                .defaultAdvisors(new SimpleLoggerAdvisor())
                // 构建最终实例
                .build();
        this.tools = tools;
    }

    // SSE流式聊天接口
    @GetMapping(value = "/chat/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<String> streamChat() {
        return chatClient.prompt()
                // 系统提示设置
                .system(s -> s.param("current_date", LocalDate.now().toString()))
                // 用户输入
                .user(DEFAULT_PROMPT)
                // 绑定工具
                .tools(tools)
                // 流式调用
                .stream()
                // 获取内容
                .content();
    }
}

@Service
public class S3OssMcpServerTools {

    private static final Logger logger = LoggerFactory.getLogger(S3OssMcpServerTools.class);

    // 创建统计项JSON对象
    private JSONObject createStatItem(String label, Object value) {
        // 创建新的JSON对象
        JSONObject item = new JSONObject();
        // 设置标签
        item.put("label", label);
        // 设置值
        item.put("value", value);
        return item;
    }

    // 获取存储桶列表
    @Tool(name = "ListBuckets", description = "查询所有存储桶列表")
    public McpResult<String> listBuckets() {
        // 获取OSS客户端
        OSS ossClient = getOSSClient();

        // 获取存储桶列表
        List<Bucket> buckets = ossClient.listBuckets();

        // 转换为JSON字符串
        String jsonString = JSON.toJSONString(buckets);

        // 返回成功结果
        return McpResult.success(jsonString);
    }

    // 删除存储桶
    @Tool(name = "DeleteBucket", description = "删除指定存储桶")
    public McpResult<String> deleteBucket(
            @ToolParam(description = "要删除的存储桶名称") String bucketName) {

        // 校验桶名称
        if (StringUtils.isEmpty(bucketName)) {
            throw new IllegalArgumentException("桶名称不能为空");
        }

        // 获取OSS客户端
        OSS ossClient = getOSSClient();

        // 执行删除操作
        ossClient.deleteBucket(bucketName);

        // 返回成功消息
        return McpResult.success("存储桶删除成功");
    }

    // 获取存储桶统计信息
    @Tool(name = "getBucketStorage", description = "获取存储桶容量统计")
    public McpResult<JSONArray> getBucketStorage(
            @ToolParam(description = "存储桶名称") String bucketName) {

        // 校验桶名称
        if (StringUtils.isEmpty(bucketName)) {
            throw new IllegalArgumentException("桶名称不能为空");
        }

        // 获取OSS客户端
        OSS ossClient = getOSSClient();

        // 获取存储桶统计信息
        BucketStat stat = ossClient.getBucketStat(bucketName);

        // 创建结果数组
        JSONArray bucketStatList = new JSONArray();

        // 添加各项统计指标
        bucketStatList.add(createStatItem("总存储大小", stat.getStorageSize()));
        bucketStatList.add(createStatItem("对象数量", stat.getObjectCount()));
        bucketStatList.add(createStatItem("标准存储大小", stat.getStandardStorage()));
        bucketStatList.add(createStatItem("低频访问存储", stat.getInfrequentAccessStorage()));
        bucketStatList.add(createStatItem("归档存储", stat.getArchiveStorage()));

        // 返回成功结果
        return McpResult.success(bucketStatList);
    }

    // 上传对象文件
    @Tool(name = "uploadObject", description = "上传文件到OSS")
    public McpResult<String> uploadObject(
            @ToolParam(description = "目标存储桶") String bucket,
            @ToolParam(description = "文件绝对路径") String path,
            @ToolParam(description = "对象名称") String name) {

        // 参数校验
        if (StringUtils.isEmpty(bucket)) {
            throw new IllegalArgumentException("存储桶名称不能为空");
        }
        if (StringUtils.isEmpty(path)) {
            throw new IllegalArgumentException("文件路径不能为空");
        }
        if (StringUtils.isEmpty(name)) {
            throw new IllegalArgumentException("对象名称不能为空");
        }

        // 创建文件对象
        File file = new File(path);
        if (!file.exists()) {
            throw new IllegalArgumentException("文件不存在: " + path);
        }

        // 获取OSS客户端
        OSS ossClient = getOSSClient();

        try (InputStream inputStream = new FileInputStream(file)) {
            // 创建元数据对象
            ObjectMetadata metadata = new ObjectMetadata();
            metadata.setContentLength(file.length());
            metadata.setContentType("application/octet-stream");

            // 执行上传
            ossClient.putObject(bucket, name, inputStream, metadata);

            // 返回成功消息
            return McpResult.success("文件上传成功");
        } catch (IOException e) {
            logger.error("文件上传IO异常", e);
            return McpResult.error("文件上传失败: " + e.getMessage());
        }
    }
}

// 创建测试桶
mcpTools.createBucket("test-bucket-001");

// 验证桶存在
List<String> buckets = mcpTools.listBuckets();
assertTrue(buckets.contains("test-bucket-001"));

// 删除测试桶
mcpTools.deleteBucket("test-bucket-001");

// 验证桶已删除
buckets = mcpTools.listBuckets();
assertFalse(buckets.contains("test-bucket-001"));

@Tool(name = "ListObjectsPaged", description = "分页列出对象")
public McpResult<JSONObject> listObjectsPaged(
        @ToolParam(description = "桶名称") String bucket,
        @ToolParam(description = "分页大小") int pageSize,
        @ToolParam(description = "分页标记") String marker) {

    // 创建OSS客户端
    OSS ossClient = getOSSClient();

    // 创建列表请求
    ListObjectsRequest request = new ListObjectsRequest(bucket);
    request.setMaxKeys(pageSize);
    request.setMarker(marker);

    // 执行列表操作
    ObjectListing listing = ossClient.listObjects(request);

    // 准备结果对象
    JSONObject result = new JSONObject();

    // 获取对象列表
    List<String> objects = listing.getObjectSummaries().stream()
            .map(OSSObjectSummary::getKey)
            .collect(Collectors.toList());

    // 设置返回数据
    result.put("objects", objects);
    result.put("nextMarker", listing.getNextMarker());
    result.put("isTruncated", listing.isTruncated());

    return McpResult.success(result);
}

// 工具方法执行前的权限检查
private void checkPermission(String toolName, String userToken) {
    // 从JWT中解析用户权限
    UserInfo user = jwtUtil.parseToken(userToken);

    // 获取工具所需权限
    String requiredRole = toolPermissions.get(toolName);

    // 检查用户是否具备权限
    if (!user.getRoles().contains(requiredRole)) {
        throw new SecurityException("用户无权限执行此操作");
    }
}

// 带权限检查的工具方法
@Tool(name = "DeleteBucket", description = "删除存储桶")
public McpResult<String> deleteBucket(
        @ToolParam(description = "桶名称") String bucket,
        @ToolParam(description = "用户凭证") String authToken) {

    // 执行权限检查
    checkPermission("DeleteBucket", authToken);

    // 原有业务逻辑...
}