Créer son propre serveur MCP en TypeScript : le guide complet

mkdir mcp-project-manager && cd mcp-project-manager
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node tsx

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

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
 
interface Project {
  id: string;
  name: string;
  status: "active" | "completed" | "paused";
  tasks: Task[];
}
 
interface Task {
  id: string;
  title: string;
  done: boolean;
}
 
const projects: Map<string, Project> = new Map();
 
const server = new McpServer({
  name: "project-manager",
  version: "1.0.0",
});
 
server.tool(
  "list-projects",
  "Liste tous les projets avec leur statut",
  {},
  async () => {
    const allProjects = Array.from(projects.values());
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(allProjects, null, 2),
        },
      ],
    };
  }
);
 
server.tool(
  "create-project",
  "Crée un nouveau projet",
  {
    name: z.string().describe("Nom du projet"),
    status: z
      .enum(["active", "completed", "paused"])
      .default("active")
      .describe("Statut initial"),
  },
  async ({ name, status }) => {
    const id = `proj_${Date.now()}`;
    const project: Project = { id, name, status, tasks: [] };
    projects.set(id, project);
 
    return {
      content: [
        {
          type: "text",
          text: `Projet "${name}" créé avec l'ID ${id}`,
        },
      ],
    };
  }
);
 
server.tool(
  "add-task",
  "Ajoute une tâche à un projet",
  {
    projectId: z.string().describe("ID du projet"),
    title: z.string().describe("Titre de la tâche"),
  },
  async ({ projectId, title }) => {
    const project = projects.get(projectId);
    if (!project) {
      return {
        content: [{ type: "text", text: `Projet ${projectId} introuvable` }],
        isError: true,
      };
    }
 
    const task: Task = {
      id: `task_${Date.now()}`,
      title,
      done: false,
    };
    project.tasks.push(task);
 
    return {
      content: [
        {
          type: "text",
          text: `Tâche "${title}" ajoutée au projet "${project.name}"`,
        },
      ],
    };
  }
);
 
server.tool(
  "project-summary",
  "Génère un résumé du projet avec progression",
  {
    projectId: z.string().describe("ID du projet"),
  },
  async ({ projectId }) => {
    const project = projects.get(projectId);
    if (!project) {
      return {
        content: [{ type: "text", text: `Projet ${projectId} introuvable` }],
        isError: true,
      };
    }
 
    const totalTasks = project.tasks.length;
    const doneTasks = project.tasks.filter((t) => t.done).length;
    const progress =
      totalTasks > 0 ? Math.round((doneTasks / totalTasks) * 100) : 0;
 
    const summary = [
      `# ${project.name}`,
      `Statut: ${project.status}`,
      `Progression: ${progress}% (${doneTasks}/${totalTasks} tâches)`,
      "",
      "## Tâches",
      ...project.tasks.map(
        (t) => `- [${t.done ? "x" : " "}] ${t.title}`
      ),
    ].join("\n");
 
    return {
      content: [{ type: "text", text: summary }],
    };
  }
);
 
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
}
 
main();

server.resource(
  "project-list",
  "projects://list",
  async (uri) => ({
    contents: [
      {
        uri: uri.href,
        text: JSON.stringify(Array.from(projects.values()), null, 2),
        mimeType: "application/json",
      },
    ],
  })
);

{
  "mcpServers": {
    "project-manager": {
      "command": "npx",
      "args": ["tsx", "/chemin/vers/mcp-project-manager/src/index.ts"]
    }
  }
}

{
  "mcpServers": {
    "project-manager": {
      "command": "npx",
      "args": ["tsx", "./mcp-project-manager/src/index.ts"]
    }
  }
}

import { readFileSync, writeFileSync, existsSync } from "fs";
 
const DB_PATH = "./data/projects.json";
 
function loadProjects(): Map<string, Project> {
  if (!existsSync(DB_PATH)) return new Map();
  const data = JSON.parse(readFileSync(DB_PATH, "utf-8"));
  return new Map(Object.entries(data));
}
 
function saveProjects(projects: Map<string, Project>) {
  const data = Object.fromEntries(projects);
  writeFileSync(DB_PATH, JSON.stringify(data, null, 2));
}

console.error("[MCP] Tool called: create-project");