AI修炼记2-MCP - 技术栈

文章目录

[一. 环境配置](#一. 环境配置)
[二. MCP 简单介绍](#二. MCP 简单介绍)
- [1. MCP是什么?](#1. MCP是什么?)
- [2. 为什么要使用MCP?](#2. 为什么要使用MCP?)
- [3. MCP架构](#3. MCP架构)
- [4. MCP Java SDK 的传输方式](#4. MCP Java SDK 的传输方式)
[三. 第三方MCP服务器的引入与使用](#三. 第三方MCP服务器的引入与使用)
- [1. cursor 调用MCP 流程](#1. cursor 调用MCP 流程)
- [2. 使用 spring AI 调用流程](#2. 使用 spring AI 调用流程)
- - [(1) 添加依赖](#(1) 添加依赖)
  - [(2) 配置yml](#(2) 配置yml)
  - [(3) 配置mcp-servers.json文件](#(3) 配置mcp-servers.json文件)
  - [(4) 通过Http调用大模型](#(4) 通过Http调用大模型)
  - [(5) 调用效果图](#(5) 调用效果图)
[四. 自定义MCP服务器端](#四. 自定义MCP服务器端)
- [1. 自定义stdio传输方式的mcp](#1. 自定义stdio传输方式的mcp)
- - [(1) 引入依赖与打包插件](#(1) 引入依赖与打包插件)
  - [(2) 配置yml](#(2) 配置yml)
  - [(3) 定义工具](#(3) 定义工具)
  - [(4) 暴露工具, 交给Spring进行自动创建与注入](#(4) 暴露工具, 交给Spring进行自动创建与注入)
  - [(5) 进行打包](#(5) 进行打包)
  - [(6) Spring AI 调用](#(6) Spring AI 调用)
- [2. 自定义sse传输方式的mcp](#2. 自定义sse传输方式的mcp)
- - [(1) 引入依赖](#(1) 引入依赖)
  - [(2) 配置yml](#(2) 配置yml)
  - [(3) 启动服务, 验证 mcp-sse 服务器是否能成功连接](#(3) 启动服务, 验证 mcp-sse 服务器是否能成功连接)
  - [(4) Spring AI 调用](#(4) Spring AI 调用)

一. 环境配置

1. 因为大多的MCP是用Python和TypeScript 开发的, 并且大多使用uv或者npx启动, 因此配置环境为第一步

2. 去 nodejs官网下载TLS(长期支持)版本, 会自带npx命令行工具, 下载过程中要注意勾选 Add to PATH, 添加到环境变量
3. 去 Python官网下载Stable Releases版本, 安装过程中要勾选 Add to PATH 和安装pip(包管理工具)选项, 安装好后, 打开cmd 输入 pip inntall uv 来下载 uv 这个命令行工具

二. MCP 简单介绍

摘抄自 MCP中文文档, 这里只是对于MCP简单介绍, 重点我觉得是还是后面对于MCP的如何应用和如何开发

1. MCP是什么?

MCP (模型上下文协议) 是一个用于将 AI 应用程序连接到外部系统的开源标准, 可以将 MCP 想象成 AI 应用程序的 USB-C 接口。正如 USB-C 提供了一种连接电子设备的标准化方式，MCP 提供了一种将 AI 应用程序连接到外部系统的标准化方式

说人话就是将AI需要的ToolCalling(工具), 资源, 提示词, 按照MCP协议封装了起来, 对外暴露了统一的接口, AI大模型也根据这个协议去随时调用

2. 为什么要使用MCP?

开发者：在构建 AI 应用程序或智能体，或与其进行集成时，MCP 可以减少开发时间和复杂度, 不用为多个AI再重复开发插件, 只开发一个MCP服务器, MCP客户端就可以调用
AI 应用程序或智能体：MCP 提供了对数据源、工具和应用生态系统的访问，这将增强其能力并改善最终用户体验, 能快速集成大量工具
对于用户：MCP 催生出更强大的 AI 应用程序或智能体, 使用它们时更加省时省力

3. MCP架构

摘抄自 MCP架构

MCP 采用客户端-服务端架构，其中 MCP 宿主（Host）------ 如 Claude Code 或 Claude Desktop 等 AI 应用 ------ 会建立与一个或多个 MCP 服务端的连接。MCP 宿主通过为每个 MCP 服务端创建一个 MCP 客户端来实现这一点。每个 MCP 客户端与其对应的 MCP 服务端保持专用连接。

主机/宿主(Hosts):

管理和创建多个客户端实例, 控制权限和生命周期

分析和协调AI大模型的采样与生成
客户端(Clients)

每个客户端由宿主创建，并维护一个隔离的服务器连接

为每个MCP服务器都建立一个会话状态

处理协议协商和能力交换, 双向路由协议消息

维护服务器之间的安全边界
客户端(Server)

为 MCP 客户端提供上下文的程序

封装了工具, 提示词, 资源

4. MCP Java SDK 的传输方式

MCP Java SDK的客户端与服务器之间有三种传输方式:

Stdio: 通过标准输入/输出实现的在两个进程间通信, 高效且直接
SSE: 基于 Java HttpClient 来发起Http请求, 同时接收服务器端发送回来的事件流(SSE)
WebFlux SSE: 基于 WebFlux 的非阻塞响应式编程模型, 来处理事件流(SSE)

三. 第三方MCP服务器的引入与使用

前提是要配置好环境, 第三方MCP大部分都要使用npx或者uvx命令行工具来调用
这里我提供几个好用的MCP社区
MCP Flow -> 目前我感觉最好用的
MCP.SO
MCP-server

1. cursor 调用MCP 流程

1. 打开 cursor 的 mcp 设置

2. 去 MCP 服务器社区复制stdio或者sse的配置项, 这里选择stdio, 因为使用起来较为方便

3. 添加到 mcp.json 文件中, 这里我选取了两个mcp服务器, 一个用来操作浏览器, 一个用来抓取目标内容, 并转化输出格式

java 复制代码

{
  "mcpServers": {
    "Playwright": {
      "command": "npx -y @playwright/mcp@latest",
      "env": {},
      "args": []
    },
    "fetch": {
      "command": "uvx",
      "args": ["mcp-server-fetch"]
    }
  }
}

4. 最后查看工具是否添加成功

5. 使用mcp的效果图

2. 使用 spring AI 调用流程

这里 Spring AI 就相当于架构中的Host(主机/宿主), 参考文档 Spring AI

(1) 添加依赖

模型使用的是DashScopeModel(阿里百炼平台集成的模型)
我们通过web服务来调用模型

java 复制代码

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

        <!--非阻塞流式调用的依赖, 使用Alibaba需要引入的依赖, 不引入的话调用时会报错-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webflux</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud.ai</groupId>
            <artifactId>spring-ai-alibaba-starter-dashscope</artifactId>
        </dependency>
        <!--    mcp依赖    -->
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-starter-mcp-client</artifactId>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.alibaba.cloud.ai</groupId>
                <artifactId>spring-ai-alibaba-bom</artifactId>
                <version>1.0.0.2</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

(2) 配置yml

java 复制代码

spring:
  ai:
    dashscope:
      api-key: ${DASHSCOPE_API_KEY}
    mcp:
      client:
        stdio:
          servers-configuration: classpath:/mcp/mcp-servers.json
          # 将所有mcp服务配置到本地的一个JSON文件当中, 更方便与简洁


# 配置日志格式 和 模型的日志级别
logging:
  pattern:
    console: '%d{HH:mm:ss.SSS} %c %M %L [%thread] %m%n'
    file: '%d{HH:mm:ss.SSS} %c %M %L [%thread] %m%n'
  level:
    io:
      modelcontextprotocol:
        client: DEBUG
        spec: DEBUG

(3) 配置mcp-servers.json文件

java 复制代码

{
  "mcpServers": {
    "playwright": {
      "command": "npx.cmd",
      "args": [
        "@playwright/mcp@latest"
      ]
    },
    "fetch": {
      "command": "uvx",
      "args": ["mcp-server-fetch"]
    }
  }
}

(4) 通过Http调用大模型

java 复制代码

package com.ran.mcp.controller;

import com.alibaba.cloud.ai.dashscope.chat.DashScopeChatModel;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.tool.ToolCallbackProvider;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: ran
 * Date: 2026-04-24
 * Time: 18:09
 */
@RestController
@RequestMapping("/chat")
public class ChatController {

    private ChatClient chatClient;

    // ToolCallbackProvider 把所有工具获取到
    public ChatController(DashScopeChatModel chatModel, ToolCallbackProvider toolCallbackProvider) {
        this.chatClient = ChatClient
                .builder(chatModel)
                .defaultToolCallbacks(toolCallbackProvider)
                .build();
    }

    @RequestMapping("/generate")
    public String generate(String msg) {
        return chatClient.prompt()
                .user(msg)
                .call()
                .content();
    }
}

(5) 调用效果图

四. 自定义MCP服务器端

1. 自定义stdio传输方式的mcp

stdio与sse方式的mcp定义很相似, 只在引入的依赖和进行配置有所不同, 下面是服务器配置的各个参数

(1) 引入依赖与打包插件

java 复制代码

    <dependencies>
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-starter-mcp-server</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

(2) 配置yml

java 复制代码

spring:
  ai:
    mcp:
      server:
        name: user-info
        version: 0.0.1
  main:
    web-application-type: none
    banner-mode: off

(3) 定义工具

java 复制代码

package com.ran.mcp.server;

import com.ran.mcp.entity.UserInfo;
import org.springframework.ai.tool.annotation.Tool;
import org.springframework.ai.tool.annotation.ToolParam;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.Map;

@Service
public class UserService {

    static Map<String, UserInfo> userInfoMap = new HashMap<>();
    static {
        userInfoMap.put("zhangsan", new UserInfo("zhangsan", 12, "男"));
        userInfoMap.put("wangwu", new UserInfo("wangwu", 18, "女"));
        userInfoMap.put("lisi", new UserInfo("lisi", 17, "男"));
    }

    @Tool(description = "根据用户姓名, 返回用户详细信息")
    public String getUserInfo(@ToolParam(description = "用户的姓名") String name) {
        if (userInfoMap.containsKey(name)) {
            return userInfoMap.get(name).toString();
        }
        return "用户不存在";
    }
}

(4) 暴露工具, 交给Spring进行自动创建与注入

java 复制代码

@Configuration
public class ToolConfig {
    @Bean
    public ToolCallbackProvider getUserInfo(UserService userService) {
        return MethodToolCallbackProvider.builder()
                .toolObjects(userService) // 根据哪个对象来提供工具
                .build();
    }
}

(5) 进行打包

将服务打成jar包后, 可以通过java -jar 命令在本地启动服务程序

(6) Spring AI 调用

1. 配置mcp-servers.json文件, 添加 user-info mcp服务器

java 复制代码

"user-info": {
      "command": "java",
      "args": [
        "-Dspring.ai.mcp.server.stdio=true",
        "-Dlogging.pattern.console=",
        "-jar",
        "D:\\study\\code\\2025-java\\Spring-AI-2\\mcp-stdio-server-demo\\target\\mcp-stdio-server-demo-1.0-SNAPSHOT.jar"
      ]
    }

2. 调用效果图

2. 自定义sse传输方式的mcp

(1) 引入依赖

java 复制代码

        <!--    sse切换为webmvc或者webflux依赖    -->
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-starter-mcp-server-webmvc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

(2) 配置yml

这里我们需要启动服务器程序, 不再使用打jar包的形式, 因此, 在本机测试时, server端口号必须与Client不冲突

java 复制代码

server:
  port: 8088

spring:
  ai:
    mcp:
      server:
        name: user-info
        version: 0.0.1

(3) 启动服务, 验证 mcp-sse 服务器是否能成功连接

(4) Spring AI 调用

1. yml配置文件需要改变

java 复制代码

spring:
  ai:
    dashscope:
      api-key: ${DASHSCOPE_API_KEY}
    mcp:
      client:
        sse:
          connections:
            user-info:
              url: "http://127.0.0.1:8088/sse"

2. 效果图