Spring AI开发MCP Server和MCP Client的详细过程_Java

本文介绍基于spring ai如何实现mcp开发和调用。首先自定义了两个mcp server，其中：一个是算术计算器mcp server，并通过sdtio传输协议发布，另一个是天气预报mcp server，通过sse传输协议发布。然后实现一个mcp client，并调用阿里云qwen大模型完成整个 mcp 调用流程，并给出来整个示例的java代码。

一、mcp是什么

模型上下文协议（即 model context protocol，mcp）是一个开放协议，它规范了应用程序如何向大型语言模型（llm）提供上下文。mcp 提供了一种统一的方式将 ai 模型连接到不同的数据源和工具，它定义了统一的集成方式。在开发智能体（agent）的过程中，我们经常需要将将智能体与数据和工具集成，mcp 以标准的方式规范了智能体与数据及工具的集成方式，可以帮助您在 llm 之上构建智能体（agent）和复杂的工作流。目前已经有大量的服务接入并提供了 mcp server 实现，当前这个生态正在以非常快的速度不断的丰富中。

spring ai mcp 采用模块化架构，包括以下组件：

（1）spring ai 应用程序：使用 spring ai 框架构建想要通过 mcp 访问数据的生成式 ai 应用程序。

（2）spring mcp 客户端：mcp 协议的 spring ai 实现，与服务器保持 1:1 连接。

（3）mcp 服务器：轻量级程序，每个程序都通过标准化的模型上下文协议公开特定的功能。

（4）本地数据源：mcp 服务器可以安全访问的计算机文件、数据库和服务。

（5）远程服务：mcp 服务器可以通过互联网（例如，通过 api）连接到的外部系统。

spring ai mcp实现遵循三层架构：

（1）stdio传输协议：stdio方式是基于进程间通信，mcp client和mcp server运行在同一主机，主要用于本地集成、命令行工具等场景。

优点：

简单可靠，无需网络配置；适合本地部署场景；进程隔离，安全性好。

缺点：

仅支持单机部署；不支持跨网络访问；每个客户端需要独立启动服务器进程。

（2）sse传输协议：sse（server-sent events）传输层是基于http的单向通信机制，专门用于服务器向客户端推送数据。mcp client远程调用mcp server提供的sse服务。实现客户端和服务端远程通信。

优点：

支持分布式部署；可跨网络访问；支持多客户端连接；轻量级，使用标准http协议。

缺点：

需要额外的网络配置；相比stdio实现略微复杂；需要考虑网络安全性。

二、前提条件

执行以下示例代码的前提条件如下：

1、java运行环境。要求jdk版本17+，本人使用的jdk21版本；

2、java开发工具。本人使用的是intellij idea开发工具，需要使用springboot3以上版本。

3、注册阿里云大模型服务，获得api_key。本文采用了阿里巴巴的qwen大模型进行实验与验证，您也可以选择使用deepseek等其它大模型作为替代方案。前提条件是该大模型要支持mcp工具回调。

三、代码实现

1、开发基于sse协议的mcp server

基于sse的mcp服务端通过http协议与客户端通信，适用于作为独立服务部署的场景，可以被多个客户端远程调用。

通过java开发工具创建一个springboot工程，模拟开发一个天气预报服务，通过sse传输协议发布为mcp server。

（1）maven配置文件

引入spring-ai-mcp-server-webflux-spring-boot-starter，完整pom.xml文件如下：

<?xml version="1.0" encoding="utf-8"?>
<project xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
         xmlns="http://maven.apache.org/pom/4.0.0"
         xsi:schemalocation="http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelversion>4.0.0</modelversion>
    <parent>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-parent</artifactid>
        <version>3.3.3</version>
        <relativepath/>
    </parent>
    <groupid>org.example</groupid>
    <artifactid>spring-ai-mcp-sse-server</artifactid>
    <version>1.0-snapshot</version>
    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
        <project.build.sourceencoding>utf-8</project.build.sourceencoding>
        <spring-ai.version>1.0.0-m6</spring-ai.version>
        <spring-ai-alibaba.version>1.0.0-m5.1</spring-ai-alibaba.version>
    </properties>
    <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>
    <dependencies>
        <dependency>
            <groupid>org.springframework.ai</groupid>
            <artifactid>spring-ai-mcp-server-webflux-spring-boot-starter</artifactid>
        </dependency>
    </dependencies>
    <repositories>
        <repository>
            <name>central portal snapshots</name>
            <id>central-portal-snapshots</id>
            <url>https://central.sonatype.com/repository/maven-snapshots/</url>
            <releases>
                <enabled>false</enabled>
            </releases>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>spring-milestones</id>
            <name>spring milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>spring-snapshots</id>
            <name>spring snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <releases>
                <enabled>false</enabled>
            </releases>
        </repository>
    </repositories>
    <build>
        <finalname>${project.artifactid}</finalname>
        <plugins>
            <plugin>
                <groupid>org.springframework.boot</groupid>
                <artifactid>spring-boot-maven-plugin</artifactid>
            </plugin>
        </plugins>
    </build>
</project>

（2）开发天气预报服务类

创建一个server类，模拟天气预报服务，通过@tool注解把方法标注为mcp服务接口。

package com.yuncheng.mcp;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.ai.tool.annotation.tool;
import org.springframework.stereotype.service;
import java.util.map;
@service
public class weatherservice {
    private static final logger log = loggerfactory.getlogger(weatherservice.class);
    @tool(description = "根据城市名称获取天气预报")
    public string getweatherbycity(string city) {
        log.info("===============getweatherbycity方法被调用：city="+city);
        map<string, string> mockdata = map.of(
                "西安", "天气炎热",
                "北京", "晴空万里",
                "上海", "阴雨绵绵"
        );
        return mockdata.getordefault(city, "抱歉：未查询到对应城市！");
    }
}

（3）注册为mcp工具

将 weatherservice 封装为工具回调提供者（toolcallbackprovider），便于被mcp client端发现和调用。

package com.yuncheng.mcp;
import org.springframework.ai.tool.toolcallbackprovider;
import org.springframework.ai.tool.method.methodtoolcallbackprovider;
import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;
import org.springframework.context.annotation.bean;
@springbootapplication
public class mcpserverapplication {
    public static void main(string[] args) {
        springapplication.run(mcpserverapplication.class, args);
    }
    @bean
    public toolcallbackprovider weathertools(weatherservice weatherservice) {
        return methodtoolcallbackprovider.builder()
                .toolobjects(weatherservice)
                .build();
    }
}

（4）配置yml文件

定义mcp server的名称、版本号、同步或异步。

server:
  port: 9090  # 服务器端口配置
spring:
  ai:
    mcp:
      server:
        name: spring-ai-mcp-server    # mcp服务器名称
        version: 1.0.0                # 服务器版本号
        type: async #异步

到这里，一个通过spring ai创建的mcp server完成了，访问http://localhost:9090/sse，能看到信息，即表示该服务通过sse发布成功了。

2、开发基于stdio协议的mcp server

基于stdio的mcp服务端通过标准输入输出流与客户端通信，适用于作为子进程被客户端启动和管理的场景，非常适合嵌入式应用。

通过java开发工具创建一个springboot工程，模拟开发一个算术计算器服务，通过stdio传输协议发布为mcp server。

（1）maven配置文件

引入spring-ai-mcp-server-webflux-spring-boot-starter

，完整pom.xml文件如下：

<?xml version="1.0" encoding="utf-8"?>
<project xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
         xmlns="http://maven.apache.org/pom/4.0.0"
         xsi:schemalocation="http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelversion>4.0.0</modelversion>
    <parent>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-parent</artifactid>
        <version>3.3.3</version>
        <relativepath/>
    </parent>
    <groupid>org.example</groupid>
    <artifactid>spring-ai-mcp-stdio-server</artifactid>
    <version>1.0-snapshot</version>
    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
        <project.build.sourceencoding>utf-8</project.build.sourceencoding>
        <spring-ai.version>1.0.0-m6</spring-ai.version>
        <spring-ai-alibaba.version>1.0.0-m5.1</spring-ai-alibaba.version>
    </properties>
    <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>
    <dependencies>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-web</artifactid>
        </dependency>
        <dependency>
            <groupid>org.springframework.ai</groupid>
            <artifactid>spring-ai-mcp-server-webflux-spring-boot-starter</artifactid>
        </dependency>
    </dependencies>
    <repositories>
        <repository>
            <name>central portal snapshots</name>
            <id>central-portal-snapshots</id>
            <url>https://central.sonatype.com/repository/maven-snapshots/</url>
            <releases>
                <enabled>false</enabled>
            </releases>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>spring-milestones</id>
            <name>spring milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>spring-snapshots</id>
            <name>spring snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <releases>
                <enabled>false</enabled>
            </releases>
        </repository>
    </repositories>
    <build>
        <finalname>${project.artifactid}</finalname>
        <plugins>
            <plugin>
                <groupid>org.springframework.boot</groupid>
                <artifactid>spring-boot-maven-plugin</artifactid>
            </plugin>
        </plugins>
    </build>
</project>

（2）开发计算器服务类

创建一个server类，模拟计算器服务，通过@tool注解把方法标注为mcp服务接口。

package com.yuncheng.mcp;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.ai.tool.annotation.tool;
import org.springframework.stereotype.service;
@service
public class mathservice {
    private static final logger log = loggerfactory.getlogger(mathservice.class);
    @tool(description = "加法方法")
    public integer add(integer a, integer b) {
        log.info("===============add方法被调用: a={}, b={}", a, b);
        return a + b;
    }
    @tool(description = "乘法方法")
    public integer multiply(integer a, integer b) {
        log.info("===============multiply方法被调用: a={}, b={}", a, b);
        return a * b;
    }
}

（3）注册为mcp工具

将 mathservice封装为工具回调提供者（toolcallbackprovider），便于被mcp client端发现和调用。

package com.yuncheng.mcp;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.ai.tool.toolcallbackprovider;
import org.springframework.ai.tool.method.methodtoolcallbackprovider;
import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;
import org.springframework.context.annotation.bean;
@springbootapplication
public class mcpserverapplication {
    private static final logger log = loggerfactory.getlogger(mcpserverapplication.class);
    public static void main(string[] args) {
        springapplication.run(mcpserverapplication.class, args);
        log.info("===============mcpserverapplication服务启动成功");
    }
    @bean
    public toolcallbackprovider mathtools(mathservice mathservice) {
        return methodtoolcallbackprovider.builder()
                .toolobjects(mathservice).build();
    }
}

（4）配置yml文件

定义mcp server的名称、版本号。

spring:
  ai:
    mcp:
      server:
        name: spring-ai-mcp-stdio-server
        version: 1.0.0

（5）配置log日志

在resources目录下，新建一个log日志配置文件logback-spring.xml，目的是记录mcp server端的接口是否被调用。

<configuration>
    <appender name="file" class="ch.qos.logback.core.fileappender">
        <file>mcp-server.log</file>
        <encoder>
            <pattern>%d{yyyy-mm-dd hh:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <root level="info">
        <appender-ref ref="file" />
    </root>
</configuration>

到这里，一个通过spring ai创建的mcp server完成了。stdio方式是server和client通过进程通信，所以需要把server打包成jar，以便client命令启动执行。

通过maven工具打包即可，我打包后路径为：d:\java\ai-project-web\spring-ai-mcp-stdio-server\target\spring-ai-mcp-stdio-server.jar。

测试该服务是否发布成功，在cmd命令行窗口里输入如下命令：

java -dspring.ai.mcp.server.stdio=true -dspring.main.web-application-type=none -dspring.main.banner-mode=off -jar d:/java/ai-project-web/spring-ai-mcp-stdio-server/target/spring-ai-mcp-stdio-server.jar

验证服务是否启动成功。

至此，我们通过spring ai框架开发完成了2个mcp server服务，一个通过sse协议发布，另一个通过stdio协议发布，接下来，开发一个mcp client端，调用这两个mcp server服务。

3、开发mcp client调用mcp server

spring ai 提供了更简便的方式来使用mcp，通过starter可以大大简化mcp客户端的配置和使用。spring ai mcp支持两种不同的传输层实现：基于stdio的实现和基于sse的实现。

通过java开发工具，创建一个springboot工程，开发mcp client。

（1）maven配置文件

引入spring-ai-mcp-client-webflux-spring-boot-starter和spring-ai-alibaba-starter，完整pom.xml文件如下：

<?xml version="1.0" encoding="utf-8"?>
<project xmlns="http://maven.apache.org/pom/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
         xsi:schemalocation="http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelversion>4.0.0</modelversion>
    <parent>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-parent</artifactid>
        <version>3.3.3</version>
        <relativepath/>
    </parent>
    <groupid>org.example</groupid>
    <artifactid>spring-ai-mcp-client</artifactid>
    <version>1.0-snapshot</version>
    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
        <project.build.sourceencoding>utf-8</project.build.sourceencoding>
        <spring-ai.version>1.0.0-m6</spring-ai.version>
        <spring-ai-alibaba.version>1.0.0-m6.1</spring-ai-alibaba.version>
    </properties>
    <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>
    <dependencies>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-web</artifactid>
        </dependency>
        <dependency>
            <groupid>org.springframework.ai</groupid>
            <artifactid>spring-ai-mcp-client-webflux-spring-boot-starter</artifactid>
        </dependency>
        <dependency>
            <groupid>com.alibaba.cloud.ai</groupid>
            <artifactid>spring-ai-alibaba-starter</artifactid>
            <version>${spring-ai-alibaba.version}</version>
        </dependency>
    </dependencies>
    <repositories>
        <repository>
            <name>central portal snapshots</name>
            <id>central-portal-snapshots</id>
            <url>https://central.sonatype.com/repository/maven-snapshots/</url>
            <releases>
                <enabled>false</enabled>
            </releases>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>spring-milestones</id>
            <name>spring milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>spring-snapshots</id>
            <name>spring snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <releases>
                <enabled>false</enabled>
            </releases>
        </repository>
    </repositories>
    <build>
        <finalname>${project.artifactid}</finalname>
        <plugins>
            <plugin>
                <groupid>org.springframework.boot</groupid>
                <artifactid>spring-boot-maven-plugin</artifactid>
            </plugin>
        </plugins>
    </build>
</project>

（2）开发mcp client

package com.yuncheng.mcp;
import org.springframework.ai.chat.client.chatclient;
import org.springframework.boot.commandlinerunner;
import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;
import org.springframework.context.configurableapplicationcontext;
import org.springframework.context.annotation.bean;
import org.springframework.ai.tool.toolcallbackprovider;
import java.util.scanner;
@springbootapplication
public class mcpclientapplication {
    public static void main(string[] args) {
        springapplication.run(mcpclientapplication.class, args);
    }
    @bean
    public commandlinerunner predefinedquestions(chatclient.builder chatclientbuilder,
                                                 toolcallbackprovider tools,
                                                 configurableapplicationcontext context) {
        return args -> {
            // 构建chatclient并注入mcp工具
            var chatclient = chatclientbuilder
                    .defaulttools(tools)
                    .build();
            // 创建scanner对象用于接收用户输入
            scanner scanner = new scanner(system.in);
            system.out.println(">>> 欢迎使用问答系统！输入'exit'退出程序。");
            while (true) {
                // 提示用户输入问题
                system.out.print("\n>>> question: ");
                string userinput = scanner.nextline();
                // 如果用户输入"exit"，则退出循环
                if ("exit".equalsignorecase(userinput)) {
                    system.out.println(">>> 已退出问答系统。");
                    break;
                }
                // 使用chatclient与llm交互
                try {
                    system.out.println("\n>>> assistant: " + chatclient.prompt(userinput).call().content());
                } catch (exception e) {
                    system.out.println("\n>>> error: 无法处理您的请求，请稍后再试。");
                    e.printstacktrace();
                }
            }
            // 关闭spring上下文
            context.close();
            scanner.close();
        };
    }
}

（3）配置yml文件

server:
  port: 8080
spring:
  ai:
    mcp:
      client:
        type: async
        sse:
          connections:
            server1:
              url: http://localhost:9090
        stdio:
          connections:
            server2:
              command: java
              args:
                - -dspring.ai.mcp.server.stdio=true
                - -dspring.main.web-application-type=none
                - -dspring.main.banner-mode=off
                - -jar
                - d:/java/ai-project-web/spring-ai-mcp-stdio-server/target/spring-ai-mcp-stdio-server.jar
    dashscope:
      api-key: sk-b90ad31bb3eb4a158524928354f31dc5
      chat:
        options:
          model: qwen-plus

本配置文件定义了一个基于 spring ai 的异步 mcp 客户端，调用了sse 和 stdio 两种mcp服务，server1采用sse方式，连接指向http://localhost:9090，server1采用stdio 方式，stdio 通过 java 命令启动，指定 jar 文件位置。同时集成了阿里巴巴大模型qwen-plus。读者需要把api-key替换为自己的key进行测试验证。