从零玩转系列之 MCP AI 理论+项目实战开发你的MCP Server

{
  "mcpServers": {
    "gitee": {
      "command": "npx",
      "args": [
        "-y",
        "@gitee/mcp-gitee@latest"
      ],
      "env": {
        "GITEE_API_BASE": "https://gitee.com/api/v5",
        "GITEE_ACCESS_TOKEN": "<your personal access token>"
      }
    }
  }
}

{
  "mcpServers": {
    "gitee": {
      "command": "npx",
      "args": [
        "-y",
        "@gitee/mcp-gitee@latest"
      ],
      "env": {
        "GITEE_API_BASE": "https://gitee.com/api/v5",
        "GITEE_ACCESS_TOKEN": "<your personal access token>"
      }
    }
  }
}

  "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/yangbuyi/Desktop",
        "/Users/yangbuyi/Desktop"
      ]
    },

package com.yby6.mcp.server.tencent.api.dto;

import lombok.Data;

import java.util.List;
import java.util.Map;

/**
 * 腾讯云开发者社区发布文章请求DTO
 *
 * 该DTO类用于封装发布文章到腾讯云开发者社区时所需的所有参数。
 * 包含了文章的基本信息、分类信息、标签信息、展示设置等多个维度的数据。
 * 使用Lombok的@Data注解自动生成getter、setter等方法。
 *
 * 主要功能：
 * 1. 封装文章发布所需的所有参数
 * 2. 支持Markdown到ProseMirror格式的自动转换
 * 3. 提供文章分类、标签、专栏等管理功能
 *
 * @author yby6
 * @version 1.0.0
 */
@Data
public class AddArticleRequest {
    /**
     * 文章标题
     * 必填字段，用于显示文章的主标题
     */
    private String title;

    /**
     * 文章内容（JSON格式）
     * 包含富文本编辑器的完整内容结构
     * 使用ProseMirror格式存储，支持复杂的富文本编辑功能
     */
    private String content;

    /**
     * 文章纯文本内容
     * 用于SEO和摘要展示
     * 当content为空时，会自动将plain转换为ProseMirror格式
     */
    private String plain;

    /**
     * 文章来源类型
     * 1: 原创
     * 用于标识文章的创作类型
     */
    private Integer sourceType;

    /**
     * 文章分类ID列表
     * 用于文章分类管理
     * 支持多分类，每个分类对应一个ID
     */
    private List<Integer> classifyIds;

    /**
     * 文章标签ID列表
     * 用于文章标签管理
     * 支持多标签，每个标签对应一个ID
     */
    private List<Integer> tagIds;

    /**
     * 长尾标签列表
     * 用于SEO优化
     * 支持自定义长尾关键词，提升文章搜索可见性
     */
    private List<String> longtailTag;

    /**
     * 专栏ID列表
     * 用于文章专栏管理
     * 支持将文章添加到多个专栏中
     */
    private List<Integer> columnIds;

    /**
     * 是否开启评论
     * 1: 开启
     * 0: 关闭
     * 控制文章是否允许读者评论
     */
    private Integer openComment;

    /**
     * 是否关闭文本链接
     * 1: 关闭
     * 0: 开启
     * 控制文章中的文本链接是否可点击
     */
    private Integer closeTextLink;

    /**
     * 用户摘要
     * 用于文章预览展示
     * 提供文章内容的简短描述
     */
    private String userSummary;

    /**
     * 文章封面图片URL
     * 用于文章列表和详情页的展示
     * 支持自定义封面图片
     */
    private String pic;

    /**
     * 来源详情
     * 用于记录文章来源的详细信息
     * 包含来源类型、URL等额外信息
     */
    private Map<String, Object> sourceDetail;

    /**
     * 专区名称
     * 用于指定文章所属的专区
     * 支持文章分类到特定专区
     */
    private String zoneName;

    /**
     * 草稿ID
     * 如果是编辑已有草稿，需要提供此ID
     * 用于支持文章的草稿编辑功能
     */
    private Long draftId;
    
    /**
     * 获取ProseMirror格式的内容
     * <p>
     * 该方法用于获取文章内容的ProseMirror格式。
     * 如果content为空，则自动将plain转换为ProseMirror格式。
     * 确保文章内容始终以正确的格式提供给编辑器。
     *
     * @return ProseMirror格式的内容
     */
    public String getContent() {
        return "";
    }
    
}

package com.yby6.mcp.server.tencent.api.dto;

import lombok.Data;

/**
 * 腾讯云开发者社区发布文章响应DTO
 *
 * 该DTO类用于封装发布文章到腾讯云开发者社区后的返回结果。
 * 包含了文章发布的状态信息和文章的唯一标识符。
 * 使用Lombok的@Data注解自动生成getter、setter等方法。
 *
 * 主要功能：
 * 1. 提供文章发布结果的反馈
 * 2. 返回新创建文章的ID
 * 3. 指示发布操作的成功或失败状态
 *
 * @author yby6
 * @version 1.0.0
 */
@Data
public class AddArticleResponse {
    /**
     * 文章ID
     * 发布成功后返回的文章唯一标识
     * 用于后续对文章进行编辑、删除等操作
     * 在发布失败时可能为null
     */
    private Long articleId;

    /**
     * 发布状态
     * 0: 成功
     * 非0: 失败
     * 用于快速判断文章发布是否成功
     * 具体的错误码需要参考腾讯云开发者社区的API文档
     */
    private Integer status;
}

package com.yby6.mcp.server.tencent.api;

import com.yby6.mcp.server.tencent.api.dto.AddArticleRequest;
import com.yby6.mcp.server.tencent.api.dto.AddArticleResponse;
import retrofit2.Call;
import retrofit2.http.Body;
import retrofit2.http.Header;
import retrofit2.http.Headers;
import retrofit2.http.POST;

/**
 * 腾讯云开发者社区服务接口
 * <p>
 * 该接口定义了与腾讯云开发者社区API交互的方法。
 * 使用Retrofit框架实现HTTP请求，支持文章的发布等操作。
 * 所有请求都需要包含必要的认证信息和请求头。
 *
 * @author yby6
 * @version 1.0.0
 */
public interface ITencentService {
    
    /**
     * 发布文章到腾讯云开发者社区
     * <p>
     * 该方法通过HTTP POST请求将文章发布到腾讯云开发者社区。
     * 请求包含完整的HTTP头信息，模拟浏览器行为，确保请求能够被正确处理。
     * <p>
     * 请求头说明：
     * - accept: 指定接受的响应类型
     * - content-type: 指定请求体类型为JSON
     * - origin/referer: 指定请求来源
     * - user-agent: 指定客户端信息
     * - 其他安全相关头部
     *
     * @param cookie  用户认证Cookie，用于身份验证
     * @param request 文章发布请求，包含文章内容、标题等信息
     * @return 包含发布结果的响应对象
     */
    @POST("https://cloud.tencent.com/developer/api/article/addArticle")
    @Headers({
            "accept: application/json, text/plain, */*",
            "accept-language: zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7",
            "content-type: application/json",
            "origin: https://cloud.tencent.com",
            "priority: u=1, i",
            "referer: https://cloud.tencent.com/developer/article/write-new?draftId=213590",
            "sec-ch-ua: \"Google Chrome\";v=\"135\", \"Not-A.Brand\";v=\"8\", \"Chromium\";v=\"135\"",
            "sec-ch-ua-mobile: ?0",
            "sec-ch-ua-platform: \"Windows\"",
            "sec-fetch-dest: empty",
            "sec-fetch-mode: cors",
            "sec-fetch-site: same-origin",
            "sec-gpc: 1",
            "user-agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36"
    })
    Call<AddArticleResponse> addArticle(
            @Header("Cookie") String cookie,
            @Body AddArticleRequest request
    );
}

    /**
     * 配置腾讯云开发者社区API服务
     *
     * @return ITencentService 腾讯云开发者社区API服务接口
     */
    @Bean
    public ITencentService tencentService() {
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("https://cloud.tencent.com")
                .addConverterFactory(JacksonConverterFactory.create())
                .build();

        return retrofit.create(ITencentService.class);
    }

package com.yby6.mcp.server.tencent.test;

import com.yby6.mcp.server.tencent.api.ITencentService;
import com.yby6.mcp.server.tencent.api.dto.AddArticleRequest;
import com.yby6.mcp.server.tencent.api.dto.AddArticleResponse;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import retrofit2.Call;
import retrofit2.Response;

import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;

/**
 * 腾讯云开发者社区API测试类
 */
@Slf4j
@SpringBootTest
public class APITest {

    @Autowired
    private ITencentService tencentService;

    /**
     * 测试添加文章接口
     */
    @Test
    public void testAddArticle() {
        // 构建请求参数
        AddArticleRequest request = AddArticleRequest.builder()
                .title("测试文章标题")
                .content("{\"type\":\"doc\",\"content\":[{\"type\":\"paragraph\",\"attrs\":{\"id\":\"test-id\"},\"content\":[{\"type\":\"text\",\"text\":\"测试内容\"}]}]}")
                .plain("测试内容")
                .sourceType(1)
                .classifyIds(Arrays.asList(2))
                .tagIds(Arrays.asList(18126))
                .longtailTag(Arrays.asList("mcp"))
                .columnIds(Arrays.asList(101806))
                .openComment(1)
                .closeTextLink(0)
                .userSummary("测试摘要")
                .pic("")
                .sourceDetail(new HashMap<>())
                .zoneName("")
                .draftId(0L)
                .build();

        // 这里需要替换为实际的Cookie
        String cookie = "qcommunity_identify_id=V6pvjxmW1JPuCEMovMUTz; qcloud_uid=VaIEoNdiKsUA; web_uid=ae70b69c-f87e-41c8-adfc-06efafb5678d; loginType=wx; lastLoginIdentity=51605f0971933755e7f8a53c030a98bc; qcommunity_session=8f9a94888dd80c7cba9f04103107b4821b78caacdbdc8a2ef693787a26905024; hy_user=UxVHgDrfj6lr9DCS; hy_token=v7nHUfmj1QeqIBGE0PdzJE3F2MFlLqxXGRlSMnkuFp6vk8Ndj5K0IapEp/t/E5rt; hy_source=web; language=zh; _ga=GA1.2.273799001.1746384291; qcstats_seo_keywords=%E5%93%81%E7%89%8C%E8%AF%8D-%E5%93%81%E7%89%8C%E8%AF%8D-%E8%85%BE%E8%AE%AF%E4%BA%91; _gcl_au=1.1.1073535231.1746384292; qcloud_from=qcloud.outside.yuque-1746547699994; trafficParams=***%24%3Btimestamp%3D1746547700395%3Bfrom_type%3Dserver%3Btrack%3D557760a9-1a5b-40a5-a2fb-7be7d1fe46d0%3B%24***; ewpUid=a3134f73-11f8-48ef-a865-7a91c897b948; qcmainCSRFToken=YGV3LRdgdrsF; qcloud_visitId=94096bdf035e23553f3d171dfa6cd886; sensorsdata2015jssdkcross=%7B%22distinct_id%22%3A%22100005325524%22%2C%22first_id%22%3A%221969c9d82841f57-06185ef48d4f27-1a525636-2104200-1969c9d82852679%22%2C%22props%22%3A%7B%22%24latest_traffic_source_type%22%3A%22%E7%9B%B4%E6%8E%A5%E6%B5%81%E9%87%8F%22%7D%2C%22identities%22%3A%22eyIkaWRlbnRpdHlfY29va2llX2lkIjoiMTk2OWM5ZDgyODQxZjU3LTA2MTg1ZWY0OGQ0ZjI3LTFhNTI1NjM2LTIxMDQyMDAtMTk2OWM5ZDgyODUyNjc5IiwiJGlkZW50aXR5X2xvZ2luX2lkIjoiMTAwMDA1MzI1NTI0In0%3D%22%2C%22history_login_id%22%3A%7B%22name%22%3A%22%24identity_login_id%22%2C%22value%22%3A%22100005325524%22%7D%2C%22%24device_id%22%3A%221969c9d82841f57-06185ef48d4f27-1a525636-2104200-1969c9d82852679%22%7D; _gat=1; uin=o100005325524; nick=1692700664; intl=1";

        try {
            // 调用API
            Call<AddArticleResponse> call = tencentService.addArticle(cookie, request);
            Response<AddArticleResponse> response = call.execute();

            if (response.isSuccessful()) {
                AddArticleResponse result = response.body();
                log.info("添加文章成功，文章ID: {}, 状态: {}", result.getArticleId(), result.getStatus());
            } else {
                log.error("添加文章失败，错误码: {}, 错误信息: {}", response.code(), response.errorBody().string());
            }
        } catch (IOException e) {
            log.error("调用添加文章接口异常", e);
        }
    }
}

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <spring-ai.version>1.0.0-M6</spring-ai.version>
        <spring-boot.version>3.4.5</spring-boot.version>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <file.encoding>UTF-8</file.encoding>
    </properties>


    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-mcp-server-spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.28</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>com.squareup.retrofit2</groupId>
            <artifactId>retrofit</artifactId>
            <version>2.9.0</version>
        </dependency>

        <dependency>
            <groupId>com.squareup.retrofit2</groupId>
            <artifactId>converter-jackson</artifactId>
            <version>2.9.0</version>
        </dependency>

        <dependency>
            <groupId>com.squareup.retrofit2</groupId>
            <artifactId>adapter-rxjava2</artifactId>
            <version>2.9.0</version>
        </dependency>

        <dependency>
            <groupId>com.vladsch.flexmark</groupId>
            <artifactId>flexmark-all</artifactId>
            <version>0.64.8</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- CommonMark 核心库 -->
        <dependency>
            <groupId>org.commonmark</groupId>
            <artifactId>commonmark</artifactId>
            <version>0.21.0</version>
        </dependency>

        <!-- Jackson 用于 JSON 处理 -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.15.2</version>
        </dependency>

    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.ai</groupId>
                <artifactId>spring-ai-bom</artifactId>
                <version>${spring-ai.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.13.0</version>
                <configuration>
                    <source>${maven.compiler.source}</source>
                    <target>${maven.compiler.target}</target>
                    <annotationProcessorPaths>
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                            <version>${lombok.version}</version>
                        </path>
                    </annotationProcessorPaths>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

/**
 * WeatherService
 *
 * @author yangs
 * @date 2025/05/09
 */
@Service
public class WeatherService {
    @Tool(description = "Get weather forecast for a specific latitude/longitude")
    public String getWeatherForecastByLocation(
        double latitude,   // Latitude coordinate
        double longitude   // Longitude coordinate
    ) {
        // Implementation
        return "";
    }

    @Tool(description = "Get weather alerts for a US state")
    public String getAlerts(
        String state  // Two-letter US state code (e.g., CA, NY)
    ) {
        return "";
    }
}

spring:
  application:
    name: tencent-send-article-mcp-server
  main:
    web-application-type: none
    banner-mode: off
  ai:
    mcp:
      server:
        stdio: true
        name: tencent-send-article-mcp-mcpService
        version: 1.0.0

    @Bean
    public ToolCallbackProvider weatherServiceTools(WeatherService weatherService) {
        return MethodToolCallbackProvider
                .builder()
                .toolObjects(weatherService)
                .build();
    }

spring:
  application:
    name: tencent-send-article-mcp-server

  ai:
    mcp:
      server:
        name: ${spring.application.name}
        version: 1.0.0

  main:
    banner-mode: off
    web-application-type: none


logging:
  pattern:
    console:
  file:
    name: data/log/${spring.application.name}.log

server:
  servlet:
    encoding:
      charset: UTF-8
      force: true
      enabled: true

package com.yby6.mcp.server.tencent.mcpService.tools;


import com.yby6.mcp.server.tencent.api.ITencentService;
import com.yby6.mcp.server.tencent.api.dto.AddArticleRequest;
import com.yby6.mcp.server.tencent.api.dto.AddArticleResponse;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.tool.annotation.Tool;
import org.springframework.stereotype.Service;
import retrofit2.Call;
import retrofit2.Response;

import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;

/**
 * 腾讯云开发者社区文章服务
 * <p>
 * 该服务类负责处理与腾讯云开发者社区文章相关的业务逻辑，
 * 包括文章的发布、更新等操作。作为领域服务层的一部分，
 * 它通过端口适配器模式与基础设施层进行交互。
 *
 * @author yby6
 * @version 1.0.0
 */
@Slf4j
@Service
public class TencentArticleToolsService {

    @Resource
    private ITencentService tencentService;

    public void saveArticle(String val) {
        AddArticleRequest request = AddArticleRequest.builder()
                .title("测试文章标题")
                .content("{\"type\":\"doc\",\"content\":[{\"type\":\"paragraph\",\"attrs\":{\"id\":\"test-id\"},\"content\":[{\"type\":\"text\",\"text\":\"测试内容\"}]}]}")
                .plain("测试内容")
                .sourceType(1)
                .classifyIds(Arrays.asList(2))
                .tagIds(Arrays.asList(18126))
                .longtailTag(Arrays.asList("mcp"))
                .columnIds(Arrays.asList(101806))
                .openComment(1)
                .closeTextLink(0)
                .userSummary("测试摘要")
                .pic("")
                .sourceDetail(new HashMap<>())
                .zoneName("")
                .draftId(0L)
                .build();

        // 这里需要替换为实际的Cookie
        String cookie = "qcommunity_identify_id=V6pvjxmW1JPuCEMovMUTz; qcloud_uid=VaIEoNdiKsUA; web_uid=ae70b69c-f87e-41c8-adfc-06efafb5678d; loginType=wx; lastLoginIdentity=51";

        try {
            // 调用API
            Call<AddArticleResponse> call = tencentService.addArticle(cookie, request);
            Response<AddArticleResponse> response = call.execute();

            if (response.isSuccessful()) {
                AddArticleResponse result = response.body();
                log.info("添加文章成功，文章ID: {}, 状态: {}", result.getArticleId(), result.getStatus());
            } else {
                log.error("添加文章失败，错误码: {}, 错误信息: {}", response.code(), response.errorBody().string());
            }
        } catch (IOException e) {
            log.error("调用添加文章接口异常", e);
        }

    }
}

@Tool(description = "发布文章到腾讯云开发者社区")

package com.yby6.mcp.server.tencent;

import com.yby6.mcp.server.tencent.mcpService.utils.MarkdownToProseMirrorConverter;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 * Markdown转ProseMirror格式转换器测试类
 * <p>
 * 该测试类用于验证MarkdownToProseMirrorConverter的功能是否正常。
 * 包含了多种Markdown语法的测试用例，确保转换结果符合ProseMirror格式要求。
 *
 * @author yby6
 * @version 1.0.0
 */
@SpringBootTest
public class MarkdownConverterTest {

    @Autowired
    private MarkdownToProseMirrorConverter converter;

    /**
     * 测试基本的Markdown转换功能
     * <p>
     * 验证各种Markdown语法元素是否能正确转换为ProseMirror格式
     */
    @Test
    public void testMarkdownConversion() {
        // 准备测试用的Markdown文本，包含多种Markdown语法
        String markdown = "# 标题1\n\n" +
                "这是一个**粗体**和*斜体*的测试。\n\n" +
                "## 标题2\n\n" +
                "- 无序列表项1\n" +
                "- 无序列表项2\n\n" +
                "1. 有序列表项1\n" +
                "2. 有序列表项2\n\n" +
                "> 这是一个引用\n\n" +
                "```java\n" +
                "// 这是一段Java代码\n" +
                "public class Test {\n" +
                "    public static void main(String[] args) {\n" +
                "        System.out.println(\"Hello, World!\");\n" +
                "    }\n" +
                "}\n" +
                "```\n\n" +
                "[这是一个链接](https://www.example.com)\n\n" +
                "---\n\n" +
                "这是最后一段。";

        // 执行转换
        String proseMirror = converter.convert(markdown);

        // 验证结果
        assertNotNull(proseMirror, "转换结果不应为null");
        assertTrue(proseMirror.contains("\"type\":\"doc\""), "转换结果应包含文档类型");
        assertTrue(proseMirror.contains("\"type\":\"heading\""), "转换结果应包含标题");
        assertTrue(proseMirror.contains("\"type\":\"paragraph\""), "转换结果应包含段落");
        assertTrue(proseMirror.contains("\"type\":\"bold\""), "转换结果应包含粗体");
        assertTrue(proseMirror.contains("\"type\":\"italic\""), "转换结果应包含斜体");
        assertTrue(proseMirror.contains("\"type\":\"bullet_list\""), "转换结果应包含无序列表");
        assertTrue(proseMirror.contains("\"type\":\"ordered_list\""), "转换结果应包含有序列表");
        assertTrue(proseMirror.contains("\"type\":\"blockquote\""), "转换结果应包含引用");
        assertTrue(proseMirror.contains("\"type\":\"code_block\""), "转换结果应包含代码块");
        assertTrue(proseMirror.contains("\"type\":\"link\""), "转换结果应包含链接");
        assertTrue(proseMirror.contains("\"type\":\"horizontal_rule\""), "转换结果应包含分隔线");

        // 输出转换结果，方便查看
        System.out.println("Markdown转换为ProseMirror格式的结果：");
        System.out.println(proseMirror);
    }

    /**
     * 测试空Markdown内容的处理
     * <p>
     * 验证转换器对空内容的处理是否正确
     */
    @Test
    public void testEmptyMarkdown() {
        String proseMirror = converter.convert("");
        assertNotNull(proseMirror, "空Markdown转换结果不应为null");
        assertTrue(proseMirror.contains("\"type\":\"doc\""), "空Markdown转换结果应包含文档类型");
        assertTrue(proseMirror.contains("\"type\":\"paragraph\""), "空Markdown转换结果应包含空段落");
    }

    /**
     * 测试复杂嵌套结构的Markdown转换
     * <p>
     * 验证转换器对嵌套结构的处理是否正确
     */
    @Test
    public void testComplexMarkdown() {
        // 准备测试用的复杂Markdown文本，包含嵌套结构
        String markdown = "# 复杂结构测试\n\n" +
                "- 列表项1\n" +
                "  - 嵌套列表项1.1\n" +
                "  - 嵌套列表项1.2\n" +
                "    - 深度嵌套列表项1.2.1\n" +
                "- 列表项2\n\n" +
                "> 引用1\n" +
                "> \n" +
                "> > 嵌套引用\n" +
                "> \n" +
                "> 引用2\n\n" +
                "```\n" +
                "代码块中的**Markdown语法**不应被解析\n" +
                "```\n";

        // 执行转换
        String proseMirror = converter.convert(markdown);

        // 验证结果
        assertNotNull(proseMirror, "复杂Markdown转换结果不应为null");
        assertTrue(proseMirror.contains("\"type\":\"doc\""), "复杂Markdown转换结果应包含文档类型");
        assertTrue(proseMirror.contains("\"type\":\"bullet_list\""), "复杂Markdown转换结果应包含无序列表");
        assertTrue(proseMirror.contains("\"type\":\"blockquote\""), "复杂Markdown转换结果应包含引用");
        assertTrue(proseMirror.contains("\"type\":\"code_block\""), "复杂Markdown转换结果应包含代码块");

        // 输出转换结果，方便查看
        System.out.println("复杂Markdown转换为ProseMirror格式的结果：");
        System.out.println(proseMirror);
    }
}

    /**
     * 获取ProseMirror格式的内容
     * <p>
     * 该方法用于获取文章内容的ProseMirror格式。
     * 如果content为空，则自动将plain转换为ProseMirror格式。
     * 确保文章内容始终以正确的格式提供给编辑器。
     *
     * @return ProseMirror格式的内容
     */
    public String getContent() {
        MarkdownToProseMirrorConverter converter = new MarkdownToProseMirrorConverter();
        return converter.convert(plain);
    }

package com.yby6.mcp.server.tencent.mcpService.model;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyDescription;
import lombok.Data;

/**
 * 文章功能请求模型
 * <p>
 * 该模型类用于封装文章发布功能所需的请求参数。
 * 使用Jackson注解进行JSON序列化配置，确保必填字段的验证。
 * 使用Lombok的@Data注解自动生成getter、setter等方法。
 * <p>
 * 主要功能：
 * 1. 定义文章发布所需的基本信息
 * 2. 提供JSON序列化配置
 * 3. 支持必填字段验证
 *
 * @author Yang Shuai
 * @version 1.0.0
 * @since 2025/05/10
 */
@Data
@JsonInclude(JsonInclude.Include.NON_NULL)
public class ArticleFunctionRequest {

    /**
     * 文章标题
     *
     * 必填字段，用于显示文章的主标题。
     * 在JSON序列化时使用"title"作为字段名。
     */
    @JsonProperty(required = true, value = "title")
    @JsonPropertyDescription("文章标题")
    private String title;

    /**
     * 文章内容
     *
     * 必填字段，使用Markdown格式存储文章内容。
     * 在JSON序列化时使用"markdowncontent"作为字段名。
     * 支持富文本格式，包括标题、列表、代码块等。
     */
    @JsonProperty(required = true, value = "markdowncontent")
    @JsonPropertyDescription("文章内容")
    private String markdowncontent;

    /**
     * 文章摘要
     *
     * 必填字段，用于提供文章内容的简短描述。
     * 在JSON序列化时使用"userSummary"作为字段名。
     * 通常用于文章列表展示和SEO优化。
     */
    @JsonProperty(required = true, value = "userSummary")
    @JsonPropertyDescription("文章摘要")
    private String userSummary;
}

package com.yby6.mcp.server.tencent.mcpService.model;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyDescription;
import lombok.Data;

/**
 * 文章功能响应模型
 * <p>
 * 该模型类用于封装文章发布功能的结果响应。
 * 使用Jackson注解进行JSON序列化配置，确保必填字段的验证。
 * 使用Lombok的@Data注解自动生成getter、setter等方法。
 * <p>
 * 主要功能：
 * 1. 提供文章发布结果的反馈信息
 * 2. 包含文章的唯一标识和访问链接
 * 3. 指示发布操作的成功或失败状态
 *
 * @author Yang Shuai
 * @version 1.0.0
 * @since 2025/05/10
 */
@Data
@JsonInclude(JsonInclude.Include.NON_NULL)
public class ArticleFunctionResponse {
    
    /**
     * 文章ID
     * <p>
     * 必填字段，发布成功后返回的文章唯一标识。
     * 在JSON序列化时使用"articleId"作为字段名。
     * 用于后续对文章进行编辑、删除等操作。
     * 在发布失败时可能为null。
     */
    @JsonProperty(required = true, value = "articleId")
    @JsonPropertyDescription("articleId")
    private Long articleId;
    
    /**
     * 发布状态
     * <p>
     * 必填字段，用于指示文章发布的结果。
     * 在JSON序列化时使用"status"作为字段名。
     * 状态码说明：
     * - 0: 发布成功
     * - 非0: 发布失败，具体错误码需要参考API文档
     */
    @JsonProperty(required = true, value = "status")
    @JsonPropertyDescription("status")
    private Integer status;
    
    /**
     * 文章链接
     * <p>
     * 必填字段，发布成功后返回的文章访问URL。
     * 在JSON序列化时使用"url"作为字段名。
     * 用于直接访问已发布的文章。
     * 在发布失败时可能为null。
     */
    @JsonProperty(required = true, value = "url")
    @JsonPropertyDescription("url")
    private String url;
    
    /**
     * 工具版权信息
     */
    @JsonProperty(required = true, value = "copyright")
    @JsonPropertyDescription("copyright")
    private String copyright;
}

package com.yby6.mcp.server.tencent.mcpService.config.properties;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * 腾讯云API配置属性类
 * <p>
 * 该配置类用于管理腾讯云开发者社区API的配置属性。
 * 使用Spring Boot的配置属性机制，从配置文件中读取相关配置。
 * 配置前缀为"tencent.api"。
 * <p>
 * 主要功能：
 * 1. 管理API认证信息（Cookie）
 * 2. 管理文章分类信息
 * 3. 提供配置属性的访问方法
 *
 * @author yby6
 * @version 1.0.0
 */
@ConfigurationProperties(prefix = "tencent.api")
@Component
public class TencentApiProperties {

    /**
     * 认证Cookie
     * <p>
     * 用于腾讯云开发者社区API的身份验证。
     * 在配置文件中通过tencent.api.cookie属性设置。
     * 该值在应用启动时会被验证，不能为空。
     */
    private String cookie;

    /**
     * 获取认证Cookie
     *
     * @return 认证Cookie字符串
     */
    public String getCookie() {
        return cookie;
    }

    /**
     * 设置认证Cookie
     *
     * @param cookie 认证Cookie字符串
     */
    public void setCookie(String cookie) {
        this.cookie = cookie;
    }
}

public class TencentArticleToolService implements ToolServiceMarker {
    
    @Resource
    private ITencentService iTencentService;
    
    @Resource
    private TencentApiProperties tencentApiProperties;

    Call<AddArticleResponse> call = iTencentService.addArticle(tencentApiProperties.getCookie(), addArticleRequest);
  

package com.yby6.mcp.server.tencent.mcpService.tools;

import com.alibaba.fastjson.JSON;
import com.yby6.mcp.server.tencent.api.ITencentService;
import com.yby6.mcp.server.tencent.api.dto.AddArticleRequest;
import com.yby6.mcp.server.tencent.api.dto.AddArticleResponse;
import com.yby6.mcp.server.tencent.mcpService.config.properties.TencentApiProperties;
import com.yby6.mcp.server.tencent.mcpService.model.ArticleFunctionRequest;
import com.yby6.mcp.server.tencent.mcpService.model.ArticleFunctionResponse;
import com.yby6.mcp.server.tencent.mcpService.ToolServiceMarker;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.tool.annotation.Tool;
import org.springframework.stereotype.Service;
import retrofit2.Call;
import retrofit2.Response;

import java.io.IOException;
import java.util.HashMap;
import java.util.List;

/**
 * 腾讯云开发者社区文章服务
 * <p>
 * 该服务类负责处理与腾讯云开发者社区文章相关的业务逻辑，
 * 包括文章的发布、更新等操作。作为领域服务层的一部分，
 * 它通过端口适配器模式与基础设施层进行交互。
 *
 * @author yby6
 * @version 1.0.0
 */
@Slf4j
@Service
public class TencentArticleToolService {

    @Resource
    private ITencentService iTencentService;

    @Resource
    private TencentApiProperties tencentApiProperties;

    /**
     * 发布文章到腾讯云开发者社区
     * <p>
     * 该方法是一个MCP工具方法，用于将文章发布到腾讯云开发者社区。
     * 主要功能：
     * 1. 接收文章发布请求
     * 2. 记录请求参数日志
     * 3. 通过端口适配器调用实际的文章发布服务
     * 4. 处理异常情况并返回响应
     *
     * @param request 文章发布请求，包含文章标题、内容等信息
     * @return 文章发布响应，包含发布结果信息
     * @throws IOException 当发布过程中发生IO异常时抛出
     */
    @Tool(description = "发布文章到腾讯云开发者社区")
    public ArticleFunctionResponse saveArticle(ArticleFunctionRequest request) {
        try {
            log.info("腾讯云开发者社区发帖参数：{}", JSON.toJSONString(request));
            log.info("接收到的参数: {}", request.toString());

            AddArticleRequest addArticleRequest = new AddArticleRequest();
            addArticleRequest.setTitle(request.getTitle());
            addArticleRequest.setPlain(request.getMarkdowncontent());
            addArticleRequest.setContent(addArticleRequest.getContent());
            addArticleRequest.setSourceType(1);  // 设置为原创
            addArticleRequest.setClassifyIds(List.of(2));  // 设置文章分类
            addArticleRequest.setTagIds(List.of(18126));  // 设置文章标签
            addArticleRequest.setLongtailTag(List.of("mcp"));  // 设置长尾标签
            addArticleRequest.setColumnIds(List.of(101806));  // 设置专栏ID
            addArticleRequest.setOpenComment(1);  // 开启评论
            addArticleRequest.setCloseTextLink(0);  // 允许文本链接
            addArticleRequest.setUserSummary(request.getUserSummary());
            addArticleRequest.setPic("");  // 设置封面图片
            addArticleRequest.setSourceDetail(new HashMap<>());  // 设置来源详情
            addArticleRequest.setZoneName("");  // 设置专区名称

            // 执行API调用
            Call<AddArticleResponse> call = iTencentService.addArticle(tencentApiProperties.getCookie(), addArticleRequest);
            Response<AddArticleResponse> response = call.execute();

            // 记录请求和响应日志
            log.info("\n\n请求腾讯云开发者社区发布文章\n req:{} \nres:{}", JSON.toJSONString(addArticleRequest), JSON.toJSONString(response));

            // 构建返回对象
            ArticleFunctionResponse articleFunctionResponse = new ArticleFunctionResponse();
            articleFunctionResponse.setStatus(-1);
            articleFunctionResponse.setArticleId(null);
            articleFunctionResponse.setUrl(null);
            articleFunctionResponse.setCopyright(getCopyright());

            if (response.isSuccessful()) {
                log.info("腾讯云开发者社区发布文章成功: {}", JSON.toJSONString(response.body()));

                // 处理成功响应
                AddArticleResponse articleResponseDTO = response.body();
                if (null == articleResponseDTO) return null;

                articleFunctionResponse.setStatus(articleResponseDTO.getStatus());
                articleFunctionResponse.setArticleId(articleResponseDTO.getArticleId());
                articleFunctionResponse.setUrl("https://cloud.tencent.com/developer/article/" + articleResponseDTO.getArticleId());

                return articleFunctionResponse;
            }
            log.error("腾讯云开发者社区发布文章失败: {}", JSON.toJSONString(response));
            return articleFunctionResponse;
        } catch (Exception e) {
            log.error("腾讯云开发者社区发帖失败 ", e);
        }
        return null;
    }
}

  "tencent-send-article-mcp-server": {
    "command": "你的JDK17以上: /graalvm-jdk-17.0.11/Contents/Home/bin/java",
    "args": [
      "-Dfile.encoding=UTF-8",
      "-jar",
      "你的jar包地址: tencent-send-article-mcp-server/1.0.0/tencent-send-article-mcp-server-1.0.0.jar"
    ]
  }

AP_APP_ID=APPID
AP_APP_KEY=私钥
AP_PUB_KEY=支付宝公钥
AP_RETURN_URL=https://www.baidu.com/s?wd=%E6%94%AF%E4%BB%98%E6%88%90%E5%8A%9F%E5%95%A6
AP_NOTIFY_URL=https://your-own-server
AP_ENCRYPTION_ALGO=RSA2
AP_CURRENT_ENV=sandbox
AP_SELECT_TOOLS=all
AP_LOG_ENABLED=true

-Dfile.encoding=UTF-8
-jar
你的jar绝对路径
--tencent.api.cookie=你的Cookie

你是云边小卖部的一位专业的AI文章创作者, 我的名字叫云云,你可以叫我小云哦~，能够根据用户指定的主题和字数要求，生成高质量、原创性的文章。请以温柔、亲切且专业的语气与用户交流，详细说明服务流程和计费方式，鼓励用户付费体验。

服务说明：  
1. 体验机制：每位新用户可免费体验一次AI文章创作服务。  
2. 付费规则：免费体验后，需充值后方可继续使用。计费标准为：100字约等于50元（即每字0.5元），字数越多费用越高。  
3. 充值流程：请先充值1元及以上，充值成功后，每次生成文章将按实际字数自动扣费。  
4. 如果用户余额不足，请提醒用户充值，并根据当前时间和用户主题生成唯一订单号，金额参考付费规则，订单标题为“AI文章创作服务by杨不易的小店”，并生成支付链接，引导用户完成支付。  
4. 退款政策：如有剩余余额，用户可随时申请退款，已扣除的部分不予退还。  
5. 订单生成：当用户同意充值时，请根据当前时间和用户主题生成唯一订单号，金额参考付费规则，订单标题为“AI文章创作服务by杨不易的小店”，并生成支付链接，引导用户完成支付。  
6. 支付后，方可为用户生成所需文章内容。
7. 一定是支付后才继续执行用户说的操作, 否则不能生成文章!
8. 文章生成完毕后, 询问是否发布到腾讯云开发者社区, 如果同意那么就发布文章到腾讯云开发者社区,调用发布文章工具.

交互要求：  
- 主动询问用户的创作主题和期望字数。  
- 一定是支付后才继续执行用户说的操作, 否则不能生成文章!
- 明确告知用户所需费用，并引导其充值。  
- 充值前仅提供一次免费体验，充值后再提供后续服务。  
- 语言表达需温柔、鼓励、专业，提升用户信任感和付费意愿。

请严格按照以上服务流程与用户互动，确保计费、充值、退款等机制公开透明，提升用户体验与满意度。

我是第一次诶, 我想要编写一个 Java 对接Redis 实现分布式锁的文章, 字数2000字 可以吗?