Model Context Protocol (MCP) : une interface cognitive, pas une API

@RestController
@RequestMapping("/api/articles")
public class ArticleController {

    @GetMapping
    public List<ArticleDto> getArticles(@RequestParam(required = false) ArticleType type) {
        return type != null
            ? articleService.getArticlesByType(type)
            : articleService.getAllArticles();
    }

    @PostMapping
    public ArticleDto createArticle(@Valid @RequestBody ArticleInputDto input) {
        return articleService.createArticle(input);
    }
}

{
  "jsonrpc": "2.0",
  "method": "notifications/initialized"
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/list",
  "params": {}
}

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "prompts/list",
  "params": {}
}

{
  "jsonrpc": "2.0",
  "id": 3,
  "method": "resources/list",
  "params": {}
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "tools": [
      {
        "name": "search_articles",
        "description": "Recherche des articles de blog par type ou mot-clé",
        "inputSchema": {
          "type": "object",
          "properties": {
            "query": {
              "type": "string",
              "description": "Mot-clé à rechercher dans les articles"
            },
            "type": {
              "type": "string",
              "enum": ["TECHNICAL", "SCIENTIFIC"],
              "description": "Filtrer par type d'article"
            }
          }
        }
      },
      {
        "name": "create_article",
        "description": "Crée un nouvel article de blog avec le titre et le contenu fournis",
        "inputSchema": {
          "type": "object",
          "properties": {
            "title": { "type": "string" },
            "content": { "type": "string" },
            "type": { "type": "string", "enum": ["TECHNICAL", "SCIENTIFIC"] }
          },
          "required": ["title", "content", "type"]
        }
      }
    ]
  }
}

{
  "jsonrpc": "2.0",
  "id": 2,
  "result": {
    "prompts": []
  }
}

{
  "jsonrpc": "2.0",
  "id": 2,
  "result": {
    "resources": []
  }
}

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "search_articles",
    "arguments": {
      "query": "architecture hexagonale",
      "type": "TECHNICAL"
    }
  },
  "id": 2
}

<dependency>
    <groupId>io.modelcontextprotocol.sdk</groupId>
    <artifactId>mcp</artifactId>
    <version>0.16.0</version>
</dependency>

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.modelcontextprotocol.json.McpJsonMapper;
import io.modelcontextprotocol.server.McpServer;
import io.modelcontextprotocol.server.McpServerFeatures;
import io.modelcontextprotocol.server.McpSyncServer;
import io.modelcontextprotocol.server.transport.StdioServerTransportProvider;
import io.modelcontextprotocol.spec.McpSchema;

import java.util.*;
import java.util.logging.Logger;

public class BlogMcpServer {

    private static final Logger logger = Logger.getLogger(BlogMcpServer.class.getName());
    private static final ObjectMapper objectMapper = new ObjectMapper();

    public static void main(String[] args) {
        try {

            StdioServerTransportProvider transport = new StdioServerTransportProvider(McpJsonMapper.getDefault()); (1)

            McpSyncServer server = McpServer.sync(transport) (2)
                    .serverInfo("blog-mcp-server", "1.0.0")
                    .capabilities(McpSchema.ServerCapabilities.builder()
                            .tools(true)
                            .resources(false, false)
                            .prompts(false)
                            .build())
                    .build();

            McpServerFeatures.SyncToolSpecification searchTool = (3)
                    new McpServerFeatures.SyncToolSpecification(
                            McpSchema.Tool.builder()
                                    .name("search_articles")
                                    .description("Rechercher des articles de blog par type ou mot-clé")
                                    .inputSchema(McpJsonMapper.getDefault(), """
                                            {
                                              "type": "object",
                                              "properties": {
                                                "query": {
                                                  "type": "string",
                                                  "description": "Mot-clé à rechercher"
                                                },
                                                "type": {
                                                  "type": "string",
                                                  "enum": ["TECHNICAL", "SCIENTIFIC"],
                                                  "description": "Filtrer par type"
                                                }
                                              }
                                            }
                                            """)
                                    .build(),
                            null,
                            (exchange, request) -> {
                                Map<String, Object> arguments = request.arguments();
                                String query = (String) arguments.get("query");
                                String type = (String) arguments.get("type");

                                // Logique métier : recherche dans la base de données
                                List<Article> results = ArticleRepository.search(query, type);

                                String jsonResults;
                                try {
                                    jsonResults = objectMapper.writeValueAsString(results);
                                } catch (JsonProcessingException e) {
                                    logger.severe("Erreur lors de la sérialisation des résultats de recherche : " + e.getMessage());
                                    return McpSchema.CallToolResult.builder()
                                            .addTextContent("Erreur : " + e.getMessage())
                                            .isError(true)
                                            .build();
                                }

                                return McpSchema.CallToolResult.builder()
                                        .addTextContent(jsonResults)
                                        .isError(false)
                                        .build();
                            }
                    );

            McpServerFeatures.SyncToolSpecification createTool = (4)
                    new McpServerFeatures.SyncToolSpecification(
                            McpSchema.Tool.builder()
                                    .name("create_article")
                                    .description("Créer un nouvel article de blog")
                                    .inputSchema(McpJsonMapper.getDefault(), """
                                            {
                                              "type": "object",
                                              "properties": {
                                                "title": { "type": "string" },
                                                "content": { "type": "string" },
                                                "type": {
                                                  "type": "string",
                                                  "enum": ["TECHNICAL", "SCIENTIFIC"]
                                                }
                                              },
                                              "required": ["title", "content", "type"]
                                            }
                                            """)
                                    .build(),
                            null,
                            (exchange, request) -> {
                                Map<String, Object> arguments = request.arguments();
                                String title = (String) arguments.get("title");
                                String content = (String) arguments.get("content");
                                String type = (String) arguments.get("type");

                                // Logique métier : création dans la base de données
                                Article created = ArticleRepository.create(title, content, type);

                                return McpSchema.CallToolResult.builder()
                                        .addTextContent("Article créé avec succès : " + created.id())
                                        .isError(false)
                                        .build();
                            }
                    );

            server.addTool(searchTool); (5)
            server.addTool(createTool); (6)

            // Le serveur est prêt à recevoir des connexions
            logger.info("Serveur MCP Blog démarré et en attente de connexions");

            // Maintenir le serveur actif - il écoute automatiquement sur stdin/stdout
            Thread.currentThread().join();

        } catch (Exception e) {
            logger.severe("Erreur lors du démarrage du serveur MCP : " + e.getMessage());
            System.exit(1);
        }
    }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "search_articles",
    "arguments": {
      "query": "Spring",
      "type": "TECHNICAL"
    }
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "content": [
      {
        "type": "json",
        "data": [
          {
            "id": "0923340b-872b-4551-ad88-6cf1ea8ff5c5",
            "title": "Créer des API RESTful avec Spring Boot",
            "content": "Apprenez à créer des API REST prêtes pour la production en utilisant le framework Spring Boot...",
            "type": "TECHNICAL"
          }
        ]
      }
    ],
    "isError": false
  }
}

paths:
  /articles/{id}:
    get:
      summary: Récupère un article par son ID
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: string
            format: uuid
      responses:
        '200':
          description: Article trouvé
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Article'
        '404':
          description: Article non trouvé

{
  "name": "get_article",
  "description": "Récupère un article de blog spécifique en utilisant son identifiant unique",
  "inputSchema": {
    "type": "object",
    "properties": {
      "article_id": {
        "type": "string",
        "description": "L'identifiant UUID de l'article à récupérer"
      }
    },
    "required": ["article_id"]
  }
}

// Architecture classique : le client pilote explicitement
RestTemplate client = new RestTemplate();
ResponseEntity<List<Article>> response = client.exchange(
    "https://api.blog.com/articles?type=TECHNICAL",
    HttpMethod.GET,
    null,
    new ParameterizedTypeReference<List<Article>>() {}
);
List<Article> articles = response.getBody();

// Architecture MCP : le modèle raisonne et décide
ChatClient chatClient = ChatClient.builder()
    .defaultSystem("""
        Tu es un assistant qui aide à rechercher et analyser des articles techniques.
        Utilise les outils à ta disposition pour répondre aux questions.
    """)
    .defaultToolCallbacks(tools)
    .build();

String response = chatClient.prompt()
    .user("Quels sont les articles sur Spring publiés récemment ?")
    .call()
    .content();

// Methode 1. Chercher les articles techniques
List<Article> technicalArticles = articleClient.getArticles("TECHNICAL");

// Methode 2. Filtrer par date récente
List<Article> recentArticles = technicalArticles.stream()
    .filter(a -> a.getPublishedDate().isAfter(LocalDate.now().minusMonths(3)))
    .toList();

// Methode 3. Trier par popularité
List<Article> sortedArticles = recentArticles.stream()
    .sorted(Comparator.comparing(Article::getViews).reversed())
    .limit(5)
    .toList();

String response = chatClient.prompt()
    .user("Donne-moi les 5 articles techniques les plus populaires publiés ces 3 derniers mois")
    .call()
    .content();