Spring AI 实现 MCP 多通道提供者实践指南

Spring AI 实现 MCP 多通道提供者实践指南

1. 引言

随着人工智能技术的迅速发展，大语言模型(LLM)已经成为众多应用的核心组件。在实际应用中，开发者需要一种灵活的方式来与这些模型进行通信和集成。Spring AI框架提供了多通道提供者(MCP)机制，使开发者能够以统一的方式与不同的AI模型服务进行交互。本文将深入探讨MCP的概念、Spring AI的实现以及SSE和STDIO两种通信方式的区别与应用。

2. MCP简介

MCP(Multi-Channel Provider)多通道提供者是一种设计模式和架构概念，用于管理与AI服务提供商之间的通信。在与大型语言模型交互的场景中，MCP扮演着重要角色，它允许应用程序：

• 统一访问不同的AI服务提供商(如OpenAI、Anthropic、本地部署的模型等)
• 灵活切换不同的通信协议和方式
• 处理流式响应和标准输入输出
• 管理模型的上下文和状态

MCP的核心价值在于提供了一个抽象层，使应用程序代码不必关心底层实现细节，从而可以专注于业务逻辑的实现。

3. Spring AI简介

Spring AI是Spring生态系统的一部分，专注于简化AI功能的集成，特别是大语言模型(LLM)的应用开发。它提供了以下核心功能：

• 统一的API接口，用于与各种AI服务提供商交互
• 丰富的模型支持，包括OpenAI、Anthropic Claude、本地Ollama等
• 内置的提示管理和模板系统
• 向量存储集成，支持语义搜索和RAG(检索增强生成)应用
• 简单易用的配置机制，便于集成到Spring Boot应用中

Spring AI的设计理念遵循了Spring框架的一贯风格：约定优于配置，简单易用，同时保持高度的可扩展性。

4. MCP中SSE和STDIO的区别

在Spring AI的MCP实现中，SSE和STDIO是两种主要的通信方式，它们各自适用于不同的场景，下面我们来详细分析两者的区别。

4.1 SSE(Server-Sent Events)详解

SSE是一种服务器推送技术，允许服务器向客户端推送实时更新。在MCP中，SSE主要用于流式返回AI模型生成的内容。

SSE的主要特点：

1. 单向通信：服务器向客户端发送数据，客户端不能通过SSE向服务器发送数据
2. 实时性：支持服务器实时推送数据到客户端
3. 自动重连：客户端断开连接后会自动尝试重新连接
4. 基于HTTP：使用标准HTTP协议，易于穿越防火墙
5. 轻量级：相比WebSocket更加轻量，适合单向通信场景

在AI模型交互中的应用：

• 流式返回模型生成的文本，实现打字机效果
• 提供实时反馈，如生成进度、中间结果等
• 减少首字节时间(TTFB)，提升用户体验

SSE的HTTP格式示例：

HTTP/1.1 200 OK
Content-Type: text/event-stream
Cache-Control: no-cache
Connection: keep-alive

data: {"content":"这是第一部分内容"}

data: {"content":"这是第二部分内容"}

data: {"content":"这是最后一部分内容"}

data: [DONE]

4.2 STDIO(Standard Input/Output)详解

STDIO是指标准输入输出流，是一种最基本的程序通信机制。在MCP中，STDIO主要用于与本地部署的模型或通过命令行工具访问的模型进行交互。

STDIO的主要特点：

1. 双向通信：程序可以通过标准输入接收数据，通过标准输出发送数据
2. 进程间通信：通常用于父子进程之间的通信
3. 无网络依赖：不依赖网络协议，适合本地应用场景
4. 命令行友好：与命令行工具天然集成
5. 低开销：通信开销小，适合高性能场景

在AI模型交互中的应用：

• 与本地部署的模型进行交互，如Ollama、LLaMA.cpp等
• 通过命令行工具访问AI模型服务
• 构建管道式AI处理流程

STDIO通信流程示例：

应用程序 -> 标准输入 -> AI模型进程 -> 标准输出 -> 应用程序

4.3 SSE和STDIO的对比

| 特性 | SSE | STDIO |

|------|-----|-------|

| 通信方向 | 单向(服务器到客户端) | 双向 |

| 应用场景 | 网络API通信 | 本地进程通信 |

| 网络依赖 | 依赖HTTP | 不依赖网络 |

| 实现复杂度 | 中等 | 简单 |

| 扩展性 | 支持多客户端 | 一对一通信 |

| 错误恢复 | 自动重连机制 | 需手动处理 |

| 性能开销 | 较高(HTTP开销) | 较低 |

| 部署要求 | 需要网络服务 | 本地即可 |

5. Spring AI实现SSE和STDIO的代码示例

5.1 SSE实现示例

以下是使用Spring AI实现SSE流式响应的完整示例：

5.1.1 Maven依赖配置

<dependencies>
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
        <version>0.8.1</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webflux</artifactId>
    </dependency>
</dependencies>

5.1.2 配置文件

spring.ai.openai.api-key=您的OpenAI-API-Key
spring.ai.openai.base-url=https://api.openai.com
spring.ai.openai.chat.options.model=gpt-3.5-turbo

5.1.3 控制器实现

import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.StreamingChatClient;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.prompt.SystemPromptTemplate;
import org.springframework.ai.chat.prompt.UserMessage;
import org.springframework.ai.openai.OpenAiChatClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;

@RestController
@RequestMapping("/ai")
public class ChatController {

    private final StreamingChatClient streamingChatClient;
    
    @Autowired
    public ChatController(StreamingChatClient streamingChatClient) {
        this.streamingChatClient = streamingChatClient;
    }
    
    @PostMapping(value = "/chat/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<String> chatStream(@RequestBody String message) {
        // 创建系统提示
        String systemPromptText = "你是一个有帮助的AI助手。请用中文回答问题。";
        SystemPromptTemplate systemPrompt = new SystemPromptTemplate(systemPromptText);
        
        // 创建用户消息
        UserMessage userMessage = new UserMessage(message);
        
        // 创建完整提示
        Prompt prompt = new Prompt(systemPrompt.createMessage(), userMessage);
        
        // 使用流式客户端生成响应
        return streamingChatClient.stream(prompt)
                .map(response -> {
                    String content = response.getResult().getOutput().getContent();
                    return "data: " + content + "\n\n";
                });
    }
}

5.1.4 前端实现

<!DOCTYPE html>
<html>
<head>
    <title>AI聊天示例</title>
    <style>
        #chatbox {
            width: 500px;
            height: 300px;
            border: 1px solid #ccc;
            overflow-y: auto;
            padding: 10px;
            margin-bottom: 10px;
        }
    </style>
</head>
<body>
    <h1>AI聊天</h1>
    <div id="chatbox"></div>
    <input type="text" id="message" placeholder="输入你的问题..." style="width: 400px;">
    <button onclick="sendMessage()">发送</button>

    <script>
        const chatbox = document.getElementById('chatbox');
        const messageInput = document.getElementById('message');

        function sendMessage() {
            const message = messageInput.value;
            if (!message) return;

            // 添加用户消息到聊天框
            chatbox.innerHTML += `<p><strong>你:</strong> ${message}</p>`;
            messageInput.value = '';

            // 添加AI响应占位符
            const aiResponseElement = document.createElement('p');
            aiResponseElement.innerHTML = '<strong>AI:</strong> ';
            chatbox.appendChild(aiResponseElement);
            chatbox.scrollTop = chatbox.scrollHeight;

            // 创建EventSource连接
            const eventSource = new EventSource(`/ai/chat/stream?message=${encodeURIComponent(message)}`);
            
            // 监听消息事件
            eventSource.onmessage = function(event) {
                const data = event.data;
                if (data === '[DONE]') {
                    eventSource.close();
                    return;
                }
                
                // 更新AI响应
                aiResponseElement.innerHTML = `<strong>AI:</strong> ${data}`;
                chatbox.scrollTop = chatbox.scrollHeight;
            };

            // 监听错误
            eventSource.onerror = function() {
                eventSource.close();
                aiResponseElement.innerHTML += ' [连接已关闭]';
            };
        }
    </script>
</body>
</html>

5.2 STDIO实现示例

以下是使用Spring AI通过STDIO与本地模型交互的示例：

5.2.1 Maven依赖配置

<dependencies>
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-ollama-spring-boot-starter</artifactId>
        <version>0.8.1</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

5.2.2 配置文件

spring.ai.ollama.base-url=http://localhost:11434
spring.ai.ollama.chat.options.model=llama2

5.2.3 自定义STDIO实现类

import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.ChatResponse;
import org.springframework.ai.chat.StreamingChatClient;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.stereotype.Service;

import java.io.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Service
public class StdioChatClient implements ChatClient {

    private final ExecutorService executorService = Executors.newCachedThreadPool();
    private final String modelCommand;
    
    public StdioChatClient() {
        // 本地模型执行命令，这里以LLaMA.cpp为例
        this.modelCommand = "/path/to/llama/main -m /path/to/model.bin --interactive --ctx_size 2048";
    }
    
    @Override
    public ChatResponse call(Prompt prompt) {
        try {
            // 启动模型进程
            ProcessBuilder processBuilder = new ProcessBuilder();
            processBuilder.command("bash", "-c", modelCommand);
            Process process = processBuilder.start();
            
            // 获取标准输入/输出流
            BufferedWriter writer = new BufferedWriter(
                    new OutputStreamWriter(process.getOutputStream()));
            BufferedReader reader = new BufferedReader(
                    new InputStreamReader(process.getInputStream()));
            
            // 向模型发送提示
            String promptText = prompt.getContents().stream()
                    .map(message -> message.getContent())
                    .reduce("", (a, b) -> a + "\n" + b);
            
            writer.write(promptText);
            writer.newLine();
            writer.flush();
            
            // 读取模型响应
            StringBuilder response = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                // 检测响应结束标记
                if (line.contains("<end_of_response>")) {
                    break;
                }
                response.append(line).append("\n");
            }
            
            // 关闭进程
            writer.close();
            process.destroy();
            
            // 创建响应对象
            return ChatResponse.of(response.toString());
            
        } catch (IOException e) {
            throw new RuntimeException("STDIO通信失败", e);
        }
    }
}

5.2.4 控制器实现

import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.ChatResponse;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.prompt.UserMessage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/ai")
public class StdioChatController {

    private final StdioChatClient stdioChatClient;
    
    @Autowired
    public StdioChatController(StdioChatClient stdioChatClient) {
        this.stdioChatClient = stdioChatClient;
    }
    
    @PostMapping("/chat/stdio")
    public String chat(@RequestBody String message) {
        // 创建用户消息
        UserMessage userMessage = new UserMessage(message);
        
        // 创建提示
        Prompt prompt = new Prompt(userMessage);
        
        // 发送到STDIO客户端并获取响应
        ChatResponse response = stdioChatClient.call(prompt);
        
        return response.getResult().getOutput().getContent();
    }
}

5.3 综合示例：同时支持SSE和STDIO的聊天服务

以下是一个综合示例，演示如何创建一个同时支持SSE和STDIO的聊天服务：

import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.ChatResponse;
import org.springframework.ai.chat.StreamingChatClient;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.prompt.SystemPromptTemplate;
import org.springframework.ai.chat.prompt.UserMessage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;

@RestController
@RequestMapping("/ai")
public class MultiChannelChatController {

    private final StreamingChatClient streamingChatClient; // SSE客户端
    private final ChatClient stdioChatClient; // STDIO客户端
    
    @Autowired
    public MultiChannelChatController(
            @Qualifier("openAiStreamingChatClient") StreamingChatClient streamingChatClient,
            @Qualifier("stdioChatClient") ChatClient stdioChatClient) {
        this.streamingChatClient = streamingChatClient;
        this.stdioChatClient = stdioChatClient;
    }
    
    // SSE流式响应接口
    @PostMapping(value = "/chat/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<String> chatStream(@RequestBody String message) {
        SystemPromptTemplate systemPrompt = new SystemPromptTemplate("你是一个有帮助的AI助手。请用中文回答问题。");
        UserMessage userMessage = new UserMessage(message);
        Prompt prompt = new Prompt(systemPrompt.createMessage(), userMessage);
        
        return streamingChatClient.stream(prompt)
                .map(response -> {
                    String content = response.getResult().getOutput().getContent();
                    return "data: " + content + "\n\n";
                });
    }
    
    // STDIO标准响应接口
    @PostMapping("/chat/stdio")
    public String chatStdio(@RequestBody String message) {
        UserMessage userMessage = new UserMessage(message);
        Prompt prompt = new Prompt(userMessage);
        
        ChatResponse response = stdioChatClient.call(prompt);
        return response.getResult().getOutput().getContent();
    }
    
    // 自动选择通道的智能接口
    @PostMapping("/chat/auto")
    public Object chatAuto(
            @RequestBody String message,
            @RequestParam(defaultValue = "false") boolean streaming) {
        
        // 根据参数选择使用SSE还是STDIO
        if (streaming) {
            return chatStream(message);
        } else {
            // 优先使用本地模型(STDIO)，如果失败则回退到网络模型(OpenAI)
            try {
                return chatStdio(message);
            } catch (Exception e) {
                SystemPromptTemplate systemPrompt = new SystemPromptTemplate("你是一个有帮助的AI助手。请用中文回答问题。");
                UserMessage userMessage = new UserMessage(message);
                Prompt prompt = new Prompt(systemPrompt.createMessage(), userMessage);
                
                ChatResponse response = streamingChatClient.call(prompt);
                return response.getResult().getOutput().getContent();
            }
        }
    }
}

6. 应用场景与最佳实践

6.1 SSE的典型应用场景

• Web应用实时交互：在网页应用中实现AI助手的打字机效果
• 移动应用推送通知：向移动客户端推送AI生成的实时内容
• 实时数据可视化：AI分析结果的实时展示和更新
• 大型语言模型的流式生成：降低用户等待时间，提升体验

6.2 STDIO的典型应用场景

• 本地模型部署：与本地部署的大型语言模型交互
• 命令行工具集成：创建CLI工具与AI模型交互
• 批处理任务：通过管道处理大量AI生成请求
• 低延迟要求的场景：减少网络开销，提高响应速度

6.3 选择合适通信方式的建议

在选择SSE还是STDIO时，可以考虑以下因素：

1. 部署环境：云环境优先考虑SSE，本地环境可优先考虑STDIO
2. 交互模式：需要实时反馈的场景适合SSE，批处理场景适合STDIO
3. 性能要求：对延迟敏感的场景可能更适合STDIO
4. 扩展性：需要支持多客户端的场景适合SSE
5. 集成复杂度：与Web应用集成优先考虑SSE，与命令行工具集成优先考虑STDIO

7. 总结与展望

Spring AI提供的MCP模式为开发者提供了灵活而强大的工具，可以根据不同的场景选择合适的通信方式。SSE和STDIO各有优势，在实际应用中可以根据需求进行选择：

• SSE适合网络环境中的实时交互场景，特别是Web应用
• STDIO适合本地环境和命令行工具集成场景

随着大型语言模型技术的发展，未来MCP模式可能会扩展支持更多的通信方式，如WebSocket、gRPC等，进一步丰富开发者的选择。同时，Spring AI也会不断完善其API设计和实现，使得与AI模型的集成变得更加简单和高效。

通过本文介绍的技术和示例，开发者可以快速构建基于Spring AI的AI应用，充分利用MCP的灵活性和强大功能，创造更加智能和交互式的用户体验。

---

以上就是关于Spring AI实现MCP多通道提供者的详细实践指南，希望能够帮助开发者更好地理解和应用这一技术。