MCP Servers et plugins : étendre Claude Code avec des outils sur mesure

Comment donner à votre IA l'accès à votre base de données, votre gestionnaire de tickets ou votre navigateur ? C'est exactement le problème que résout le Model Context Protocol (MCP).

Qu'est-ce que le Model Context Protocol ?

Le MCP est un protocole ouvert, initié par Anthropic, qui définit une interface universelle entre un LLM client et des serveurs d'outils. L'analogie : MCP est au LLM ce que USB est au matériel informatique.

Trois concepts fondamentaux :

• Tools : fonctions que le LLM peut appeler (requête SQL, créer un ticket)
• Resources : données que le LLM peut lire (fichiers, documentation)
• Prompts : templates réutilisables exposés par le serveur

Installer des MCP servers existants

Configuration pour Claude Code dans .claude/settings.json :

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@anthropic/mcp-server-playwright"],
      "env": { "PLAYWRIGHT_HEADLESS": "true" }
    },
    "brave-search": {
      "command": "npx",
      "args": ["@anthropic/mcp-server-brave-search"],
      "env": { "BRAVE_API_KEY": "votre-clé" }
    },
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp@latest"]
    }
  }
}

Créer son propre MCP server en TypeScript

mkdir mcp-server-jira && cd mcp-server-jira
npm init -y
npm install @modelcontextprotocol/sdk zod node-fetch
npm install -D typescript @types/node

Fichier src/index.ts :

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const JIRA_BASE_URL = process.env.JIRA_URL;
const jiraHeaders = {
  Authorization: `Basic ${Buffer.from(
    `${process.env.JIRA_EMAIL}:${process.env.JIRA_API_TOKEN}`
  ).toString("base64")}`,
  "Content-Type": "application/json",
};

const server = new McpServer({ name: "jira-server", version: "1.0.0" });

// Tool : récupérer un ticket
server.tool(
  "get_issue",
  "Récupère les détails d'un ticket Jira",
  { issueKey: z.string().describe("Clé du ticket, ex: PROJ-123") },
  async ({ issueKey }) => {
    const res = await fetch(`${JIRA_BASE_URL}/rest/api/3/issue/${issueKey}`, {
      headers: jiraHeaders,
    });
    const issue = await res.json();
    return {
      content: [{
        type: "text",
        text: JSON.stringify({
          key: issue.key,
          summary: issue.fields.summary,
          status: issue.fields.status?.name,
          assignee: issue.fields.assignee?.displayName || "Non assigné",
        }, null, 2),
      }],
    };
  }
);

// Tool : rechercher via JQL
server.tool(
  "search_issues",
  "Recherche des tickets via JQL",
  {
    jql: z.string().describe("Requête JQL"),
    maxResults: z.number().optional().default(10),
  },
  async ({ jql, maxResults }) => {
    const res = await fetch(
      `${JIRA_BASE_URL}/rest/api/3/search?jql=${encodeURIComponent(jql)}&maxResults=${maxResults}`,
      { headers: jiraHeaders }
    );
    const data = await res.json();
    const issues = data.issues.map((i) => ({
      key: i.key,
      summary: i.fields.summary,
      status: i.fields.status?.name,
    }));
    return { content: [{ type: "text", text: JSON.stringify(issues, null, 2) }] };
  }
);

const transport = new StdioServerTransport();
server.connect(transport);

L'écosystème MCP en 2026

• Bases de données : PostgreSQL, MySQL, MongoDB, Redis, SQLite
• Gestion de projet : Jira, Linear, GitHub Issues, Notion
• Recherche : Brave Search, Exa, Tavily, Google Search
• Navigateur : Playwright, Puppeteer, Chrome DevTools
• Documentation : Context7, Mintlify
• Cloud : AWS, GCP, Cloudflare Workers, Vercel

Sécurité : bonnes pratiques

// Toujours valider les entrées
server.tool(
  "execute_query",
  "Requête en lecture seule",
  {
    query: z.string().refine(
      (q) => /^SELECT/i.test(q.trim()),
      "Seules les requêtes SELECT sont autorisées"
    ),
  },
  async ({ query }) => {
    const result = await db.query(query, { readOnly: true });
    return { content: [{ type: "text", text: JSON.stringify(result) }] };
  }
);

Le MCP transforme la manière dont nous intégrons les outils dans nos workflows IA. En standardisant la communication, il crée un écosystème partagé où chaque serveur bénéficie à l'ensemble de la communauté. OpenAI, Google et JetBrains l'ont adopté — c'est devenu le standard de facto.