Introduction au MCP : Guide de Demarrage Rapide pour Debutants

Ce que vous apprendrez

Dans ce tutoriel adapte aux debutants, vous allez :

• Comprendre ce qu'est MCP et pourquoi c'est important
• Configurer un environnement de developpement MCP complet
• Construire votre premier serveur MCP de zero
• Connecter votre serveur a une application IA

Commençons !

Prerequis

Avant de plonger, assurez-vous d'avoir :

• Node.js 18+ installe (telecharger ici)
• npm ou pnpm comme gestionnaire de paquets
• Connaissances basiques TypeScript/JavaScript (variables, fonctions, async/await)
• Un editeur de code (VS Code recommande)
• Familiarite avec le Terminal/Ligne de commande

Aucune experience MCP prealable n'est requise. Nous expliquerons tout etape par etape.

Qu'est-ce que MCP ?

Le Model Context Protocol (MCP) est un protocole ouvert developpe par Anthropic qui standardise comment les applications IA se connectent aux sources de donnees externes et aux outils.

Pensez a MCP comme un adaptateur universel pour l'IA :

• Tout comme USB-C connecte vos appareils a n'importe quel peripherique compatible
• MCP connecte les modeles IA a n'importe quelle source de donnees ou outil compatible

Pourquoi utiliser MCP ?

Sans MCP, connecter une IA a vos donnees necessite du code personnalise pour chaque integration. Avec MCP :

Vue d'ensemble de l'architecture MCP

MCP utilise un modele client-serveur :

[Application IA] <---> [Client MCP] <---> [Serveur MCP] <---> [Vos Donnees/Outils]

• Serveur MCP : Expose les outils et donnees aux applications IA
• Client MCP : Vit dans l'application IA, communique avec les serveurs
• Outils : Fonctions que votre IA peut appeler (recuperer des donnees, effectuer des actions)

Etape 1 : Configuration du projet

Creons votre premier serveur MCP. Ouvrez votre terminal et executez :

# Creer le repertoire du projet
mkdir mcp-hello-world
cd mcp-hello-world
 
# Initialiser le projet Node.js
npm init -y

Installez les dependances requises :

# Installer le SDK MCP et Zod pour la validation
npm install @modelcontextprotocol/sdk zod
 
# Installer les dependances de developpement TypeScript
npm install -D typescript @types/node

Etape 2 : Configurer TypeScript

Creez un fichier tsconfig.json a la racine de votre projet :

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "Node16",
    "moduleResolution": "Node16",
    "outDir": "./build",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "declaration": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules"]
}

Mettez a jour votre package.json pour inclure le script de build et le type de module :

{
  "name": "mcp-hello-world",
  "version": "1.0.0",
  "type": "module",
  "scripts": {
    "build": "tsc",
    "start": "node build/index.js"
  },
  "dependencies": {
    "@modelcontextprotocol/sdk": "^0.5.0",
    "zod": "^3.22.0"
  },
  "devDependencies": {
    "@types/node": "^20.0.0",
    "typescript": "^5.0.0"
  }
}

Creez le repertoire source :

mkdir src

Etape 3 : Construire votre premier serveur MCP

Creez le fichier serveur principal dans src/index.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";
import { z } from "zod";
 
// Definir le schema de validation pour notre outil
const GreetingSchema = z.object({
  name: z.string().describe("Le nom de la personne a saluer"),
});
 
// Creer l'instance du serveur MCP
const server = new Server(
  {
    name: "hello-world-server",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {},
    },
  }
);
 
// Gestionnaire : Lister les outils disponibles
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "greet",
        description: "Generer une salutation amicale pour une personne",
        inputSchema: {
          type: "object",
          properties: {
            name: {
              type: "string",
              description: "Le nom de la personne a saluer",
            },
          },
          required: ["name"],
        },
      },
      {
        name: "get_current_time",
        description: "Obtenir la date et l'heure actuelles",
        inputSchema: {
          type: "object",
          properties: {},
          required: [],
        },
      },
    ],
  };
});
 
// Gestionnaire : Executer les appels d'outils
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;
 
  if (name === "greet") {
    const { name: personName } = GreetingSchema.parse(args);
    const greeting = `Bonjour, ${personName} ! Bienvenue dans le monde de MCP.`;
 
    return {
      content: [
        {
          type: "text",
          text: greeting,
        },
      ],
    };
  }
 
  if (name === "get_current_time") {
    const now = new Date();
    const timeString = now.toLocaleString("fr-FR", {
      weekday: "long",
      year: "numeric",
      month: "long",
      day: "numeric",
      hour: "2-digit",
      minute: "2-digit",
      second: "2-digit",
      timeZoneName: "short",
    });
 
    return {
      content: [
        {
          type: "text",
          text: `L'heure actuelle est : ${timeString}`,
        },
      ],
    };
  }
 
  throw new Error(`Outil inconnu : ${name}`);
});
 
// Fonction principale pour demarrer le serveur
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("Le serveur MCP Hello World est en cours d'execution !");
}
 
main().catch((error) => {
  console.error("Erreur fatale :", error);
  process.exit(1);
});

Comprendre le code

Decomposons ce que fait chaque partie :

1. Creation du serveur : Nous creons un nouveau serveur MCP avec un nom et une version
2. ListToolsRequestSchema : Indique aux clients IA quels outils sont disponibles
3. CallToolRequestSchema : Gere l'execution reelle des outils lorsque l'IA les appelle
4. StdioServerTransport : Couche de communication utilisant stdin/stdout

Etape 4 : Construire et tester

Compilez votre code TypeScript :

npm run build

Vous devriez voir un fichier build/index.js cree. Votre serveur est pret !

Test rapide

Pour verifier que ca fonctionne, vous pouvez l'executer directement (il attendra les messages du protocole MCP) :

npm start

Vous devriez voir : Le serveur MCP Hello World est en cours d'execution !

Etape 5 : Connecter a une application IA

Maintenant, connectons votre serveur a une application IA. La methode la plus courante est via Claude Desktop.

Configuration Claude Desktop

1. Ouvrez les parametres de Claude Desktop
2. Naviguez vers la configuration des serveurs MCP
3. Ajoutez votre serveur :

{
  "mcpServers": {
    "hello-world": {
      "command": "node",
      "args": ["/chemin/absolu/vers/mcp-hello-world/build/index.js"]
    }
  }
}

4. Redemarrez Claude Desktop
5. Demandez a Claude de "saluer Jean" ou "quelle heure est-il"

Prochaines etapes

Felicitations ! Vous avez construit votre premier serveur MCP. Voici quelques prochaines etapes :

Etendre votre serveur

Ajoutez des outils plus utiles :

• Acces au systeme de fichiers
• Integrations API
• Requetes de base de donnees
• Logique metier personnalisee

En savoir plus

• Comprendre MCP et A2A - Plongee approfondie dans l'architecture MCP
• Implications de securite MCP - Meilleures pratiques de securite pour les serveurs MCP

Explorer l'ecosysteme

• Documentation officielle MCP
• Exemples de serveurs MCP
• Serveurs preconstruits pour GitHub, Slack, bases de donnees, et plus

Reference rapide

Structure du projet

mcp-hello-world/
|-- src/
|   |-- index.ts      # Code serveur
|-- build/
|   |-- index.js      # Sortie compilee
|-- package.json
|-- tsconfig.json

Concepts cles

Depannage

Erreurs de build ? Assurez-vous d'utiliser Node.js 18+ et d'avoir installe toutes les dependances.

Serveur ne repond pas ? Verifiez que le chemin dans la configuration de votre client IA est absolu et correct.

Outils non affiches ? Redemarrez votre application IA apres avoir mis a jour la configuration du serveur.

Resume

Dans ce guide de demarrage rapide, vous avez appris :

1. Ce qu'est MCP - Un protocole universel pour connecter l'IA aux outils et donnees
2. Comment configurer - Structure du projet, configuration TypeScript, dependances
3. Comment construire - Creer un serveur avec des outils que l'IA peut appeler
4. Comment connecter - Integration avec Claude Desktop ou des clients programmatiques

Vous avez maintenant les bases pour construire de puissantes integrations IA avec MCP. Commencez a experimenter et voyez ce que vous pouvez creer !

Reference : Ce tutoriel suit la documentation officielle du Model Context Protocol.