Créer un serveur MCP en Node.js

Tool     → action, effet de bord, résultat dynamique selon les paramètres
Resource → contenu, lecture, données à un instant T

Tool     : create_user(name, email)   → crée l'utilisateur, retourne l'ID
Resource : users://list               → lit la liste des utilisateurs

const server = new Server(
  { name: 'mon-mcp', version: '1.0.0' },
  {
    capabilities: {
      tools: {},
      resources: {},  // ← activer les resources
    },
  }
)

import {
  ListResourcesRequestSchema,
  ReadResourceRequestSchema,
} from '@modelcontextprotocol/sdk/types.js'
 
server.setRequestHandler(ListResourcesRequestSchema, async () => ({
  resources: [
    {
      uri: 'app://config',
      name: 'Configuration de l\'application',
      description: 'Variables d\'environnement et configuration actuelle',
      mimeType: 'application/json',
    },
    {
      uri: 'app://logs/recent',
      name: 'Logs récents',
      description: 'Les 100 dernières entrées de log',
      mimeType: 'text/plain',
    },
    {
      uri: 'db://stats',
      name: 'Statistiques base de données',
      description: 'Nombre d\'entrées par table, taille, dernière mise à jour',
      mimeType: 'application/json',
    },
  ],
}))

server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
  const { uri } = request.params
 
  if (uri === 'app://config') {
    const config = {
      nodeEnv: process.env.NODE_ENV,
      port: process.env.PORT,
      dbHost: process.env.DB_HOST,
      // Ne jamais exposer les secrets complets
      dbPasswordSet: !!process.env.DB_PASSWORD,
      version: process.env.npm_package_version,
    }
 
    return {
      contents: [
        {
          uri,
          mimeType: 'application/json',
          text: JSON.stringify(config, null, 2),
        },
      ],
    }
  }
 
  if (uri === 'app://logs/recent') {
    const logs = await readRecentLogs(100)  // votre fonction de lecture
    return {
      contents: [
        {
          uri,
          mimeType: 'text/plain',
          text: logs.join('\n'),
        },
      ],
    }
  }
 
  if (uri === 'db://stats') {
    const stats = await getDatabaseStats()
    return {
      contents: [
        {
          uri,
          mimeType: 'application/json',
          text: JSON.stringify(stats, null, 2),
        },
      ],
    }
  }
 
  throw new McpError(ErrorCode.InvalidRequest, `Resource inconnue : ${uri}`)
})

server.setRequestHandler(ListResourcesRequestSchema, async () => ({
  resources: [
    {
      uri: 'users://list',
      name: 'Liste des utilisateurs',
      mimeType: 'application/json',
    },
  ],
  // URI templates — patterns avec variables
  resourceTemplates: [
    {
      uriTemplate: 'users://{id}',
      name: 'Profil utilisateur',
      description: 'Profil complet d\'un utilisateur par son ID',
      mimeType: 'application/json',
    },
    {
      uriTemplate: 'logs://{service}/{date}',
      name: 'Logs d\'un service à une date',
      description: 'Logs filtrés par service et date (YYYY-MM-DD)',
      mimeType: 'text/plain',
    },
  ],
}))

server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
  const { uri } = request.params
 
  // URI statique
  if (uri === 'users://list') {
    const users = await db.query('SELECT id, name, email FROM users LIMIT 100')
    return {
      contents: [{
        uri,
        mimeType: 'application/json',
        text: JSON.stringify(users.rows, null, 2),
      }],
    }
  }
 
  // URI dynamique : users://42
  const userMatch = uri.match(/^users:\/\/(\d+)$/)
  if (userMatch) {
    const id = parseInt(userMatch[1])
    const user = await db.query('SELECT * FROM users WHERE id = $1', [id])
 
    if (user.rows.length === 0) {
      throw new McpError(ErrorCode.InvalidRequest, `Utilisateur ${id} introuvable`)
    }
 
    return {
      contents: [{
        uri,
        mimeType: 'application/json',
        text: JSON.stringify(user.rows[0], null, 2),
      }],
    }
  }
 
  // URI dynamique : logs://api/2026-06-24
  const logsMatch = uri.match(/^logs:\/\/([a-z-]+)\/(\d{4}-\d{2}-\d{2})$/)
  if (logsMatch) {
    const [, service, date] = logsMatch
    const logs = await fetchLogs(service, date)
    return {
      contents: [{
        uri,
        mimeType: 'text/plain',
        text: logs,
      }],
    }
  }
 
  throw new McpError(ErrorCode.InvalidRequest, `URI non supportée : ${uri}`)
})

> lis les logs du service "api" pour hier

const server = new Server(
  { name: 'mon-mcp', version: '1.0.0' },
  {
    capabilities: {
      resources: {
        subscribe: true,    // activer les subscriptions
        listChanged: true,  // notifier quand la liste change
      },
    },
  }
)
 
// Gérer les subscriptions
import {
  SubscribeRequestSchema,
  UnsubscribeRequestSchema,
} from '@modelcontextprotocol/sdk/types.js'
 
const subscribers = new Map<string, Set<string>>()  // uri → set de session IDs
 
server.setRequestHandler(SubscribeRequestSchema, async (request) => {
  const { uri } = request.params
  if (!subscribers.has(uri)) {
    subscribers.set(uri, new Set())
  }
  // ... enregistrer l'abonnement
  return {}
})
 
server.setRequestHandler(UnsubscribeRequestSchema, async (request) => {
  const { uri } = request.params
  subscribers.delete(uri)
  return {}
})
 
// Notifier les abonnés quand le contenu change
async function notifyResourceUpdated(uri: string) {
  await server.notification({
    method: 'notifications/resources/updated',
    params: { uri },
  })
}
 
// Exemple : surveiller un fichier et notifier
import { watch } from 'fs'
watch('/var/log/app.log', async () => {
  await notifyResourceUpdated('app://logs/recent')
})

return {
  contents: [{
    uri,
    mimeType: 'image/png',
    blob: imageBuffer.toString('base64'),  // base64
  }],
}

await server.notification({
  method: 'notifications/resources/list_changed',
  params: {},
})