Comment utiliser le serveur Spring Boot MCP

Prêt à rendre vos applications alimentées par l'IA encore plus intelligentes ? Aujourd'hui, nous plongeons dans le SpringBoot MCP Server, un outil fantastique qui permet aux modèles d'IA comme Claude ou Cursor d'interagir avec vos données via le Model Context Protocol (MCP). Imaginez votre IA récupérant des informations de cours ou recherchant des données spécifiques avec seulement quelques commandes – le tout alimenté par une application Spring Boot légère. Dans ce guide conversationnel, nous vous guiderons à travers la configuration et l'utilisation du SpringBoot MCP Server, avec un test pour le voir en action. C'est parti pour le codage !

💡

Envie d'un excellent outil de test d'API qui génère une belle documentation API ?

Envie d'une plateforme intégrée, tout-en-un, pour que votre équipe de développeurs travaille ensemble avec une productivité maximale ?

Apidog répond à toutes vos exigences et remplace Postman à un prix beaucoup plus abordable !

button

Qu'est-ce que le SpringBoot MCP Server ?

Le SpringBoot MCP Server est une application Spring Boot qui utilise le framework Spring AI MCP pour exposer vos données en tant qu'outils pour les modèles d'IA. C'est comme donner à votre IA une ligne directe vers les données de votre application, telles que les détails des cours, via des outils MCP standardisés. Dans ce tutoriel, nous nous concentrerons sur un serveur qui offre deux outils principaux :

Get all games : Récupère une liste de tous les jeux disponibles.
Search games by title : Trouve un jeu spécifique par son titre.

Cette configuration est parfaite pour intégrer des données externes avec des modèles d'IA ou pour construire vos propres serveurs MCP. De plus, il est construit avec Spring Boot, ce qui le rend convivial pour les développeurs et facile à étendre. Enthousiasmé ? Configurons-le !

Comment utiliser le SpringBoot MCP Server

Prérequis

Avant de commencer, assurez-vous d'avoir :

Java 24 : Télécharger depuis oracle.com.
Maven 3.8+ : Installer depuis maven.apache.org.
IntelliJ IDEA : Obtenir depuis jetbrains.com (ou utiliser votre IDE préféré).
Claude Desktop ou Cursor : pour tester avec un client IA (anthropic.com & curosor.com).
Connaissances de base de Spring Boot : Une familiarité avec les bases de Spring Boot est utile.

Étape 1 : Créer un nouveau projet Spring Boot

Visiter Spring Initializr :

Aller sur start.spring.io.
Configurer votre projet :
Projet : Maven
Langage : Java
Spring Boot : 3.5.4 (dernière version stable en juillet 2025)
Packaging : Jar
Version Java : 24 (ou votre version installée)
Ajouter la dépendance Spring AI MCP Server :

Cliquer sur Générer et télécharger le projet.

Ouvrir dans IntelliJ IDEA :

Dézipper le projet téléchargé et l'ouvrir dans IntelliJ IDEA comme un nouveau projet.

Étape 2 : Comprendre la structure du projet

Votre SpringBoot MCP Server inclut des composants clés :

Game.java : Un enregistrement pour les données de cours (par exemple, titre et URL).
GameService.java : Contient des outils MCP avec des annotations @Tool.
TestMcpServerApplication.java : La classe d'application principale qui enregistre les outils.
application.properties : Configure le serveur MCP pour le transport STDIO.

Voici un exemple de configuration application.properties :

spring.application.name=test-mcp-server
spring.main.web-application-type=none
spring.ai.mcp.server.name=game-demo-mcp
spring.ai.mcp.server.version=0.0.1
spring.main.banner-mode=off
logging.pattern.console=

Ceci configure l'application comme un serveur non web utilisant le transport STDIO, parfait pour la communication MCP.

Étape 3 : Définir le modèle de données

Créer un simple enregistrement Game.java pour représenter les données de cours :

package com.example.testmcpserver;

public record Game(String title, String url){
}

Cet enregistrement immuable contient les détails des cours comme le titre et l'URL, ce qui facilite le traitement par les modèles d'IA.

Étape 4 : Implémenter les outils MCP

Dans GameService.java, définissez les outils en utilisant l'annotation @Tool. Voici un exemple :

package com.example.testmcpserver;

import jakarta.annotation.PostConstruct;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.ai.tool.annotation.Tool;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class GameService {

    private static final Logger log = LoggerFactory.getLogger(GameService.class);
    private List<Game> games = new ArrayList<>();

    @Tool(name = "get_games", description = "Get a list of games from the collection")
    public List<Game> getGames() {
        return games;
    }

    @Tool(name = "get_game", description = "Get a single game from from the collection by title")
    public Game getGame(String title) {
        return games.stream().filter(course -> course.title().equals(title)).findFirst().orElse(null);
    }

    @PostConstruct
    public void init() {
        games.addAll(List.of(
                new Game("GTA 6", "https://www.rockstargames.com/VI"),
                new Game("FC 26","https://www.ea.com/en/games/ea-sports-fc/fc-26"),
                new Game("Call of Duty: Black Ops 7","https://www.callofduty.com/blackops7")
        ));
    }

}

Ces outils permettent aux modèles d'IA de récupérer tous les cours ou de trouver un cours spécifique par son titre.

Étape 5 : Enregistrer les outils avec le framework MCP

Dans TestMcpServerApplication.java, enregistrez les outils :

package com.example.testmcpserver;

import org.springframework.ai.support.ToolCallbacks;
import org.springframework.ai.tool.ToolCallback;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

import java.util.List;

@SpringBootApplication
public class TestMcpServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(TestMcpServerApplication.class, args);
    }

    @Bean
    public List<ToolCallback> danTools(GameService gameService) {
        return List.of(ToolCallbacks.from(gameService));
    }

}

La méthode ToolCallbacks.from() scanne GameService pour les annotations @Tool et les enregistre auprès du SpringBoot MCP Server.

Étape 6 : Exécuter le SpringBoot MCP Server

Construire et Exécuter :

Dans IntelliJ, ouvrir un terminal et exécuter :

mvn spring-boot:run

Le serveur démarre en tant que serveur MCP utilisant le transport STDIO, sans interface web.

Vérifier les outils :

Le serveur enregistre deux outils : get_games (liste tous les jeux) et get_game (trouve un jeu par titre).

Étape 7 : Se connecter à Cursor ou Claude Desktop

Pour utiliser le SpringBoot MCP Server avec Claude Desktop :

Compiler le projet :

Construire le fichier JAR :

mvn clean package

Trouver le JAR dans target/test-mcp-server-0.0.1-SNAPSHOT.jar.

A. Configurer Claude Desktop :

Ouvrir claude_desktop_config.json (macOS : ~/Library/Application Support/Claude, Windows : %APPDATA%\Claude).
Ajouter :

{
  "mcpServers": {
    "game-demo-mcp": {
      "command": "java",
      "args": [
        "-jar",
        "path/to/test-mcp-server-0.0.1-SNAPSHOT.jar"
      ]
    }
  }
}

Remplacer path/to/ par le chemin réel de votre fichier JAR (par exemple, D:/Apidog_Projects/spring-boot-mcp-server/test-mcp-server/target/test-mcp-server-0.0.1-SNAPSHOT.jar).

Redémarrer Claude Desktop :

Fermer et rouvrir Claude pour appliquer la configuration.

B. Configurer Cursor :

Naviguer vers Paramètres, puis Paramètres de Cursor
Sélectionner Outils et Intégrations
Cliquer sur Nouveau serveur MCP

Étape 8 : Tester le SpringBoot MCP Server

Testons le serveur avec Claude Desktop :

Ouvrir Claude Desktop ou Cursor et émettre une commande :

Dans votre client MCP, entrer :

En utilisant le serveur MCP, obtenir tous les jeux disponibles.

Claude (ou Cursor) devrait répondre avec :

Available games:
- Title: GTA 6, URL: https://www.rockstargames.com/VI
- Title: FC 26, URL: https://www.ea.com/en/games/ea-sports-fc/fc-26

Essayer un jeu spécifique :

Entrer :

En utilisant le serveur MCP, obtenir le jeu avec le titre "FC 26".

Réponse attendue :

Game: FC 26, URL: https://www.ea.com/en/games/ea-sports-fc/fc-26

Ceci confirme que votre SpringBoot MCP Server fonctionne !

Étape 9 : Étendre le SpringBoot MCP Server

Envie de le rendre encore plus génial ? Voici quelques idées :

Ajouter plus de cours : Mettre à jour la méthode init() de GameService pour inclure plus d'objets Game.
Nouveaux outils : Ajouter des méthodes avec des annotations @Tool, comme une fonction de recherche :

@Tool(name = "search_games", description = "Search games containing a keyword")
public List<Game> searchGames(String keyword) {
    return games.stream()
        .filter(game -> game.title().toLowerCase().contains(keyword.toLowerCase()))
        .collect(Collectors.toList());
}

Utiliser une base de données : Remplacer la liste games en mémoire par une connexion à une base de données.
Améliorer la recherche : Ajouter une correspondance floue ou des filtres de catégorie.

Conseils de dépannage

Le serveur ne démarre pas ? Assurez-vous que Java 24 et Maven sont installés, et vérifiez application.properties pour les bons paramètres.
Claude ne se connecte pas ? Vérifiez le chemin du JAR dans claude_desktop_config.json et redémarrez Claude.
Outils introuvables ? Confirmez que les annotations @Tool sont correctes et que ToolCallbacks est enregistré.
Pas de sortie ? Vérifiez le terminal exécutant mvn spring-boot:run pour les erreurs.

Pourquoi utiliser le SpringBoot MCP Server ?

Le SpringBoot MCP Server est un rêve pour les développeurs qui aiment la simplicité de Spring Boot et souhaitent intégrer l'IA à leurs données. Il est léger, utilise STDIO pour une communication sécurisée, et permet aux modèles d'IA comme Claude d'accéder aux données de votre application en temps réel. Que vous construisiez une plateforme de cours ou une autre application basée sur les données, ce serveur rend l'intégration de l'IA un jeu d'enfant.

Notre test avec Claude Desktop et Cursor a montré à quel point il est facile de récupérer des données de jeu. Imaginez étendre cela pour gérer des requêtes complexes ou se connecter à une vraie base de données – des possibilités infinies !

Conclusion

Et voilà ! Vous avez appris à configurer et à utiliser le SpringBoot MCP Server pour apporter un accès aux données alimenté par l'IA à vos applications. De la création d'un projet Spring Boot à sa connexion avec Claude Desktop et au test des requêtes de cours, vous êtes maintenant prêt à construire des intégrations IA plus intelligentes. Essayez d'ajouter de nouveaux outils ou de connecter une base de données pour aller plus loin.

💡

button