Comment créer des serveurs MCP Node.js qui exposent des ressources de données aux LLM

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

const logger = initLogger();

export async function initializeResources(server) {
  logger.info({ msg: "Initializing resources..." });

  const resourceNodejsReleasesChartURL =
    "https://raw.githubusercontent.com/nodejs/Release/main/schedule.svg?sanitize=true";
  const resourceNodejsReleasesChart = await fetch(
    resourceNodejsReleasesChartURL
  );

  if (!resourceNodejsReleasesChart.ok) {
    logger.error({
      msg: `Failed to fetch Node.js releases chart: ${resourceNodejsReleasesChart.status} ${resourceNodejsReleasesChart.statusText}`,
    });
    throw new Error(
      `Failed to fetch Node.js releases chart: ${resourceNodejsReleasesChart.status} ${resourceNodejsReleasesChart.statusText}`
    );
  }

  const resourceNodejsReleasesChartSVGText =
    await resourceNodejsReleasesChart.text();

 const resources = [
    {
      uri: "nodejs://releases-schedule-chart.svg",
      name: "Node.js Releases Schedule Chart",
      description: "A chart showing the release schedule of Node.js versions.",
      mimeType: "image/svg+xml",
      func: async (request) => {
        logger.info({ msg: "Resource URI Access:", uri: request.params.uri });

        return {
          contents: [
            {
              uri: request.params.uri,
              text: resourceNodejsReleasesChartSVGText,
            },
          ],
        };
      },
    },
  ];

  // Implement dynamic resource definition for listing and implementation by
  // looping over the `resources` array and defining each resource:
  server.setRequestHandler(ListResourcesRequestSchema, async () => {
    const resourcesList = resources.map((resource) => {
      return {
        uri: resource.uri,
        name: resource.name,
        description: resource.description,
        mimeType: resource.mimeType || "text/plain",
      };
    });

    return {
      resources: resourcesList,
    };
  });

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

    if (resource) {
      return await resource.func(request);
    }

    throw new Error(`Resource not found: ${request.params.uri}`);
  });
}

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { initLogger } from "./utils/logger.js";
import { initializeResources } from "./resources/index.js";

const logger = initLogger();

export async function createMcpServer() {
  const server = new Server(
    {
      name: "nodejs-module-api-documentation",
      description:
        "Search built-in core Node.js modules API Documentation. Use whenever the user asks questions about Node.js API, Node.js modules or Node.js functions.",
      version: "1.0.0",
    },
    {
      capabilities: {
        resources: {},
      },
    }
  );

  // await initializeDocumentationServer(server);
  await initializeResources(server);

  // Start receiving messages on stdin and sending messages on stdout
  logger.info({
    msg: "MCP Server instance created",
    name: server.name,
    version: server.version,
  });

  return server;
}

#!/usr/bin/env node
import { createMcpServer } from "./server.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { initLogger } from './utils/logger.js';

const logger = initLogger();

// Initialize the server with Node.js API documentation
async function startServer() {
  let server
  try {
    server = await createMcpServer();
  } catch (error) {
    logger.error({ err: error, msg: 'Failed to create MCP server' });
    console.error(`Fatal error during server creation.`);
    process.exit(1);
  }

  try {
    // Start receiving messages on stdin and sending messages on stdout
    const transport = new StdioServerTransport();
    await server.connect(transport);
    logger.info({ msg: 'Server connected to transport. Ready.' });
  } catch (error) {
    logger.error({ err: error, msg: 'Failed to initialize server' });
    console.error(`Fatal error during server transport init.`);
    process.exit(1);
  }
}

startServer();