MCP (Model Context Protocol) : connecter vos LLMs à vos outils en 2026

MCP — Model Context Protocol — est le protocole open source publié par Anthropic en novembre 2024 qui est devenu en quelques mois un standard de facto pour connecter des LLMs à des systèmes externes. Là où le function calling classique force chaque application à re-décrire ses outils dans chaque prompt, MCP découple complètement la définition des outils de leur utilisation.

En juin 2026, l’écosystème compte plus de 3 000 serveurs MCP publics. Si vous construisez des applications IA en 2026, vous allez croiser MCP.

Le problème que MCP résout

Imaginez une équipe avec 5 applications IA différentes qui doivent toutes accéder au même Jira, au même Confluence et à la même base de données produit. Sans MCP :

• Chaque application réimplémente son propre client Jira
• Chaque prompt redécrit les mêmes outils différemment
• Changer l’API Jira casse les 5 applications

Avec MCP :

[Application 1] ──┐
[Application 2] ──┤──→ [Serveur MCP Jira] ──→ API Jira
[Application 3] ──┘

[Application 1] ──┐
[Application 2] ──┤──→ [Serveur MCP DB]   ──→ PostgreSQL
[Application 3] ──┘

Un serveur MCP expose des outils, des ressources et des prompts. N’importe quel client MCP peut les découvrir et les utiliser. La logique de connexion n’est écrite qu’une fois.

Architecture MCP

MCP repose sur JSON-RPC 2.0 et définit trois types de capacités exposées par un serveur :

Capacité	Description	Exemple
Tools	Fonctions que le LLM peut appeler	search_issues, create_ticket
Resources	Données que le LLM peut lire	jira://project/PROJ/issues
Prompts	Templates de prompts paramétrables	summarize_sprint(sprint_id)

Le transport peut être :

• stdio : communication via stdin/stdout (local, simple)
• SSE (Server-Sent Events) : communication HTTP (remote, scalable)

Créer un serveur MCP en TypeScript

L’exemple le plus courant : un serveur MCP qui expose votre base de données produit.

npm init -y
npm install @modelcontextprotocol/sdk
npm install -D typescript @types/node tsx

// src/server.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";

const server = new Server(
  { name: "product-catalog", version: "1.0.0" },
  { capabilities: { tools: {} } }
);

// Déclarer les outils disponibles
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "search_products",
      description: "Recherche des produits par nom, catégorie ou prix maximum.",
      inputSchema: {
        type: "object",
        properties: {
          query:    { type: "string",  description: "Terme de recherche" },
          category: { type: "string",  description: "Catégorie (optionnel)" },
          maxPrice: { type: "number",  description: "Prix maximum en € (optionnel)" },
        },
        required: ["query"],
      },
    },
    {
      name: "get_product_details",
      description: "Retourne les détails complets d'un produit par son ID.",
      inputSchema: {
        type: "object",
        properties: {
          productId: { type: "string", description: "ID du produit" },
        },
        required: ["productId"],
      },
    },
    {
      name: "check_stock",
      description: "Vérifie le stock disponible pour un produit.",
      inputSchema: {
        type: "object",
        properties: {
          productId: { type: "string", description: "ID du produit" },
          quantity:  { type: "number", description: "Quantité souhaitée" },
        },
        required: ["productId", "quantity"],
      },
    },
  ],
}));

// Implémenter les appels
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  switch (name) {
    case "search_products": {
      const products = await db.products.search({
        query:    args.query as string,
        category: args.category as string | undefined,
        maxPrice: args.maxPrice as number | undefined,
      });
      return {
        content: [{ type: "text", text: JSON.stringify(products, null, 2) }],
      };
    }

    case "get_product_details": {
      const product = await db.products.findById(args.productId as string);
      if (!product) {
        return {
          content: [{ type: "text", text: `Produit ${args.productId} introuvable.` }],
          isError: true,
        };
      }
      return {
        content: [{ type: "text", text: JSON.stringify(product, null, 2) }],
      };
    }

    case "check_stock": {
      const stock = await db.inventory.getStock(args.productId as string);
      const available = stock >= (args.quantity as number);
      return {
        content: [{
          type: "text",
          text: JSON.stringify({ available, stock, requested: args.quantity }),
        }],
      };
    }

    default:
      throw new Error(`Outil inconnu : ${name}`);
  }
});

// Démarrage via stdio
const transport = new StdioServerTransport();
await server.connect(transport);

Ajouter des Resources

Les ressources permettent au LLM de lire des données structurées (documentation, listes, fichiers de config) sans appeler un outil.

import { ListResourcesRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";

server.setRequestHandler(ListResourcesRequestSchema, async () => ({
  resources: [
    {
      uri: "catalog://categories",
      name: "Catégories de produits",
      description: "Liste de toutes les catégories disponibles dans le catalogue.",
      mimeType: "application/json",
    },
    {
      uri: "catalog://promotions/current",
      name: "Promotions en cours",
      description: "Liste des promotions actives avec leurs conditions.",
      mimeType: "application/json",
    },
  ],
}));

server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
  const { uri } = request.params;

  if (uri === "catalog://categories") {
    const categories = await db.categories.findAll();
    return {
      contents: [{
        uri,
        mimeType: "application/json",
        text: JSON.stringify(categories, null, 2),
      }],
    };
  }

  if (uri === "catalog://promotions/current") {
    const promos = await db.promotions.findActive();
    return {
      contents: [{
        uri,
        mimeType: "application/json",
        text: JSON.stringify(promos, null, 2),
      }],
    };
  }

  throw new Error(`Resource inconnue : ${uri}`);
});

Configurer dans Claude Desktop

Une fois le serveur compilé, il suffit d’une ligne de config dans Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json sur macOS) :

{
  "mcpServers": {
    "product-catalog": {
      "command": "node",
      "args": ["/chemin/vers/votre/serveur/dist/server.js"],
      "env": {
        "DATABASE_URL": "postgres://user:pass@localhost/products"
      }
    }
  }
}

Claude peut maintenant utiliser les outils search_products, get_product_details et check_stock dans n’importe quelle conversation.

Serveur MCP HTTP (SSE) pour le remote

Pour exposer votre serveur MCP à distance (plusieurs clients, déploiement cloud) :

import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
import express from "express";

const app = express();
const transports = new Map<string, SSEServerTransport>();

app.get("/sse", async (req, res) => {
  const sessionId = crypto.randomUUID();
  const transport = new SSEServerTransport("/messages", res);
  transports.set(sessionId, transport);

  res.on("close", () => transports.delete(sessionId));

  const server = createServer(); // votre logique de création serveur
  await server.connect(transport);
});

app.post("/messages", express.json(), async (req, res) => {
  const sessionId = req.headers["x-session-id"] as string;
  const transport = transports.get(sessionId);
  if (!transport) { res.status(404).end(); return; }
  await transport.handlePostMessage(req, res, req.body);
});

app.listen(3000, () => console.log("MCP server on :3000"));

Utiliser un serveur MCP depuis Java

Si votre application est en Java, des clients MCP existent :

// Avec le SDK MCP Java (communautaire)
var client = MpcClient.builder()
    .transport(new StdioClientTransport("node", "/chemin/server.js"))
    .build();

await client.initialize();

// Lister les outils disponibles
List<Tool> tools = await client.listTools();

// Appeler un outil
CallToolResult result = await client.callTool(
    "search_products",
    Map.of("query", "Java", "maxPrice", 50.0)
);

String json = result.content().get(0).text();

Ou en intégrant les outils MCP directement dans LangChain4j :

// LangChain4j supporte nativement les serveurs MCP
McpToolProvider mcpTools = McpToolProvider.builder()
    .mcpClients(List.of(
        McpClient.using(new StdioMcpTransport(
            List.of("node", "/chemin/server.js"),
            Map.of("DATABASE_URL", System.getenv("DATABASE_URL"))
        ))
    ))
    .build();

ShoppingAgent agent = AiServices.builder(ShoppingAgent.class)
    .chatLanguageModel(claudeModel)
    .toolProvider(mcpTools) // outils découverts dynamiquement depuis le serveur MCP
    .build();

Serveurs MCP publics à connaître

L’écosystème propose déjà des serveurs prêts à l’emploi pour les outils courants :

Serveur	Ce qu’il expose
@modelcontextprotocol/server-github	Issues, PRs, code, commits
@modelcontextprotocol/server-postgres	Requêtes SQL, schéma
@modelcontextprotocol/server-filesystem	Lecture/écriture de fichiers
@modelcontextprotocol/server-brave-search	Recherche web
mcp-server-jira	Tickets, sprints, projets Jira
mcp-server-slack	Messages, canaux, historique

# Utiliser directement sans installation
npx @modelcontextprotocol/server-github
npx @modelcontextprotocol/server-postgres postgresql://localhost/mydb

---

MCP est en train de devenir la couche d’intégration standard entre les LLMs et le reste du système d’information. Construire un serveur MCP pour votre domaine métier, c’est l’investissement le plus rentable pour rendre votre SI “IA-ready” sans réécrire toutes vos applications.

Sur le même sujet

• IA agentique en Java : construire des agents autonomes avec Spring AI — Comment les agents Java utilisent concrètement les outils exposés via MCP pour automatiser des processus métier complexes.
• Platform Engineering : construire une plateforme développeur interne — Déployer et opérer vos serveurs MCP dans une IDP avec ArgoCD et Kubernetes, pour les rendre accessibles à toute l’organisation.
• WebAssembly et Java : compiler du Java en WASM avec GraalVM — Une alternative pour exposer de la logique métier Java via WASM dans des environnements sandboxés, complémentaire à MCP.