Notes MCP サーバーの構築

npm install @mastra/mcp

rm -rf src/mastra/agents src/mastra/workflows src/mastra/tools/weather-tool.ts

import { Mastra } from "@mastra/core/mastra";
import { PinoLogger } from "@mastra/loggers";
import { LibSQLStore } from "@mastra/libsql";
 
export const mastra = new Mastra({
  storage: new LibSQLStore({
    // テレメトリや評価などをメモリストレージに保存します。永続化が必要な場合は file:../mastra.db に変更してください
    url: ":memory:",
  }),
  logger: new PinoLogger({
    name: "Mastra",
    level: "info",
  }),
});

mkdir notes src/mastra/mcp

touch src/mastra/mcp/{server,resources,prompts}.ts

import { MCPServer } from "@mastra/mcp";
 
export const notes = new MCPServer({
  name: "notes",
  version: "0.1.0",
  tools: {},
});

import { Mastra } from "@mastra/core";
import { PinoLogger } from "@mastra/loggers";
import { LibSQLStore } from "@mastra/libsql";
import { notes } from "./mcp/server";
 
export const mastra = new Mastra({
  storage: new LibSQLStore({
    // テレメトリや評価結果などをメモリストレージに保存します。永続化が必要な場合は file:../mastra.db に変更してください
    url: ":memory:",
  }),
  logger: new PinoLogger({
    name: "Mastra",
    level: "info",
  }),
  mcpServers: {
    notes,
  },
});

import fs from "fs/promises";
import path from "path";
import { fileURLToPath } from "url";
import type { MCPServerResources, Resource } from "@mastra/mcp";
 
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const NOTES_DIR = path.resolve(__dirname, "../../notes"); // デフォルトの出力ディレクトリからの相対パス
 
const listNoteFiles = async (): Promise<Resource[]> => {
  try {
    await fs.mkdir(NOTES_DIR, { recursive: true });
    const files = await fs.readdir(NOTES_DIR);
    return files
      .filter((file) => file.endsWith(".md"))
      .map((file) => {
        const title = file.replace(".md", "");
        return {
          uri: `notes://${title}`,
          name: title,
          description: `${title} に関するノート`,
          mime_type: "text/markdown",
        };
      });
  } catch (error) {
    console.error("ノートのリソース一覧取得中にエラーが発生しました:", error);
    return [];
  }
};
 
const readNoteFile = async (uri: string): Promise<string | null> => {
  const title = uri.replace("notes://", "");
  const notePath = path.join(NOTES_DIR, `${title}.md`);
  try {
    return await fs.readFile(notePath, "utf-8");
  } catch (error) {
    if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
      console.error(`リソース ${uri} の読み取り中にエラーが発生しました:`, error);
    }
    return null;
  }
};
 
export const resourceHandlers: MCPServerResources = {
  listResources: listNoteFiles,
  getResourceContent: async ({ uri }: { uri: string }) => {
    const content = await readNoteFile(uri);
    if (content === null) return { text: "" };
    return { text: content };
  },
};

import { MCPServer } from "@mastra/mcp";
import { resourceHandlers } from "./resources";
 
export const notes = new MCPServer({
  name: "notes",
  version: "0.1.0",
  tools: {},
  resources: resourceHandlers,
});

import { createTool } from "@mastra/core/tools";
import { z } from "zod";
import { fileURLToPath } from "url";
import path from "node:path";
import fs from "fs/promises";
 
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const NOTES_DIR = path.resolve(__dirname, "../../../notes");
 
export const writeNoteTool = createTool({
  id: "write",
  description: "新しいノートを書き込むか、既存のノートを上書きします。",
  inputSchema: z.object({
    title: z
      .string()
      .nonempty()
      .describe("ノートのタイトル。ファイル名として使用されます。"),
    content: z
      .string()
      .nonempty()
      .describe("ノートの Markdown コンテンツ。"),
  }),
  outputSchema: z.string().nonempty(),
  execute: async ({ context }) => {
    try {
      const { title, content } = context;
      const filePath = path.join(NOTES_DIR, `${title}.md`);
      await fs.mkdir(NOTES_DIR, { recursive: true });
      await fs.writeFile(filePath, content, "utf-8");
      return `ノート「${title}」への書き込みに成功しました。`;
    } catch (error: any) {
      return `ノートの書き込み中にエラーが発生しました: ${error.message}`;
    }
  },
});

import { MCPServer } from "@mastra/mcp";
import { resourceHandlers } from "./resources";
import { writeNoteTool } from "../tools/write-note";
 
export const notes = new MCPServer({
  name: "notes",
  version: "0.1.0",
  resources: resourceHandlers,
  tools: {
    write: writeNoteTool,
  },
});

npm install unified remark-parse gray-matter @types/unist

import type { MCPServerPrompts } from "@mastra/mcp";
import { unified } from "unified";
import remarkParse from "remark-parse";
import matter from "gray-matter";
import type { Node } from "unist";
 
const prompts = [
  {
    name: "new_daily_note",
    description: "日次ノートを新規作成します。",
    version: "1.0.0",
  },
  {
    name: "summarize_note",
    description: "ノートの要約（TL;DR）を提示します。",
    version: "1.0.0",
  },
  {
    name: "brainstorm_ideas",
    description: "ノートをもとに新しいアイデアをブレインストーミングします。",
    version: "1.0.0",
  },
];
 
function stringifyNode(node: Node): string {
  if ("value" in node && typeof node.value === "string") return node.value;
  if ("children" in node && Array.isArray(node.children))
    return node.children.map(stringifyNode).join("");
  return "";
}
 
export async function analyzeMarkdown(md: string) {
  const { content } = matter(md);
  const tree = unified().use(remarkParse).parse(content);
  const headings: string[] = [];
  const wordCounts: Record<string, number> = {};
  let currentHeading = "untitled";
  wordCounts[currentHeading] = 0;
  tree.children.forEach((node) => {
    if (node.type === "heading" && node.depth === 2) {
      currentHeading = stringifyNode(node);
      headings.push(currentHeading);
      wordCounts[currentHeading] = 0;
    } else {
      const textContent = stringifyNode(node);
      if (textContent.trim()) {
        wordCounts[currentHeading] =
          (wordCounts[currentHeading] || 0) + textContent.split(/\\s+/).length;
      }
    }
  });
  return { headings, wordCounts };
}
 
const getPromptMessages: MCPServerPrompts["getPromptMessages"] = async ({
  name,
  args,
}) => {
  switch (name) {
    case "new_daily_note":
      const today = new Date().toISOString().split("T")[0];
      return [
        {
          role: "user",
          content: {
            type: "text",
            text: `タイトルを「${today}」とし、「## Tasks」「## Meetings」「## Notes」というセクションを含む新しいノートを作成してください。`,
          },
        },
      ];
    case "summarize_note":
      if (!args?.noteContent) throw new Error("No content provided");
      const metaSum = await analyzeMarkdown(args.noteContent as string);
      return [
        {
          role: "user",
          content: {
            type: "text",
            text: `各セクションを3項目以内の箇条書きで要約してください。\\n\\n### アウトライン\\n${metaSum.headings.map((h) => `- ${h} (${metaSum.wordCounts[h] || 0} words)`).join("\\n")}`.trim(),
          },
        },
      ];
    case "brainstorm_ideas":
      if (!args?.noteContent) throw new Error("No content provided");
      const metaBrain = await analyzeMarkdown(args.noteContent as string);
      return [
        {
          role: "user",
          content: {
            type: "text",
            text: `以下の未整理・未成熟なセクションについて、${args?.topic ? `「${args.topic}」に関して` : ""}アイデアを3つブレインストーミングしてください。\\n\\n未成熟なセクション:\\n${metaBrain.headings.length ? metaBrain.headings.map((h) => `- ${h}`).join("\\n") : "- (none, pick any)"}`,
          },
        },
      ];
    default:
      throw new Error(`Prompt \"${name}\" not found`);
  }
};
 
export const promptHandlers: MCPServerPrompts = {
  listPrompts: async () => prompts,
  getPromptMessages,
};

import { MCPServer } from "@mastra/mcp";
import { resourceHandlers } from "./resources";
import { writeNoteTool } from "../tools/write-note";
import { promptHandlers } from "./prompts";
 
export const notes = new MCPServer({
  name: "notes",
  version: "0.1.0",
  resources: resourceHandlers,
  prompts: promptHandlers,
  tools: {
    write: writeNoteTool,
  },
});