@menutes/mcp-server 0.1.0

package/README.md

@@ -0,0 +1,44 @@
+# @menutes/mcp-server
+
+MCP server for accessing [Menutes](https://menutes.com) meeting transcripts and summaries from Claude Code.
+
+## Setup
+
+1. Get an API key from [Settings](https://app.menutes.com/settings?tab=api-keys)
+
+2. Add to your MCP config:
+
+```json
+{
+  "mcpServers": {
+    "menutes": {
+      "command": "npx",
+      "args": ["@menutes/mcp-server"],
+      "env": {
+        "MENUTES_API_KEY": "mnts_your_key_here"
+      }
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `list_recordings` | List meetings with optional filtering by status and scope |
+| `get_recording` | Get metadata for a specific recording |
+| `get_transcript` | Get speaker-labeled transcript with timestamps |
+| `get_summary` | Get AI-generated summary with action items |
+| `search_recordings` | Search recordings by title |
+
+## Environment Variables
+
+| Variable | Required | Default | Description |
+|----------|----------|---------|-------------|
+| `MENUTES_API_KEY` | Yes | - | API key (starts with `mnts_`) |
+| `MENUTES_BASE_URL` | No | `https://app.menutes.com` | API base URL |
+
+## License
+
+MIT

package/dist/api.d.ts

@@ -0,0 +1,63 @@
+export interface Recording {
+    id: string;
+    meetingTitle: string | null;
+    status: "UPLOADING" | "PROCESSING" | "COMPLETED" | "FAILED";
+    duration: number | null;
+    speakerCount: number | null;
+    sharingScope: string;
+    createdAt: string;
+    updatedAt: string;
+    processingPhase: string | null;
+    sourceType: string;
+    user: {
+        id: string;
+        name: string | null;
+    };
+    team: {
+        id: string;
+        name: string;
+    } | null;
+    isOwner: boolean;
+}
+export interface RecordingContent {
+    transcription: string | null;
+    summary: string | null;
+    transcriptSegments: {
+        speaker: string;
+        text: string;
+        startTime: number | null;
+        endTime: number | null;
+    }[];
+    speakerNames: Record<string, string>;
+    notes: string | null;
+}
+export interface ListRecordingsResponse {
+    recordings: Recording[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        totalPages: number;
+        hasNextPage: boolean;
+        hasPrevPage: boolean;
+    };
+}
+export interface SearchResponse {
+    recordings: Recording[];
+    total: number;
+}
+export declare class MenutesApiClient {
+    private baseUrl;
+    private apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    private request;
+    listRecordings(params?: {
+        page?: number;
+        limit?: number;
+        status?: string;
+        view?: string;
+    }): Promise<ListRecordingsResponse>;
+    getRecording(id: string): Promise<Recording>;
+    getRecordingContent(id: string): Promise<RecordingContent>;
+    searchRecordings(query: string, limit?: number): Promise<SearchResponse>;
+}

package/dist/api.js

@@ -0,0 +1,66 @@
+export class MenutesApiClient {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async request(path, params) {
+        const url = new URL(path, this.baseUrl);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined && value !== null) {
+                    url.searchParams.set(key, String(value));
+                }
+            }
+        }
+        let response;
+        try {
+            response = await fetch(url.toString(), {
+                headers: { Authorization: `Bearer ${this.apiKey}` },
+            });
+        }
+        catch {
+            throw new Error(`Could not connect to Menutes API at ${this.baseUrl}`);
+        }
+        if (!response.ok) {
+            if (response.status === 401) {
+                throw new Error("Invalid API key. Check your MENUTES_API_KEY.");
+            }
+            if (response.status === 403) {
+                throw new Error("You don't have access to this recording.");
+            }
+            if (response.status === 404) {
+                throw new Error("Recording not found.");
+            }
+            if (response.status === 429) {
+                throw new Error("Rate limit exceeded (1000 req/hour). Try again later.");
+            }
+            const body = await response.text();
+            let message;
+            try {
+                message = JSON.parse(body).error || body;
+            }
+            catch {
+                message = body || `HTTP ${response.status}`;
+            }
+            throw new Error(`Menutes API error: ${message}`);
+        }
+        return (await response.json());
+    }
+    async listRecordings(params) {
+        return this.request("/api/v1/recordings", params);
+    }
+    async getRecording(id) {
+        return this.request(`/api/v1/recordings/${encodeURIComponent(id)}`);
+    }
+    async getRecordingContent(id) {
+        return this.request(`/api/v1/recordings/${encodeURIComponent(id)}/content`);
+    }
+    async searchRecordings(query, limit) {
+        const params = { q: query };
+        if (limit !== undefined)
+            params.limit = limit;
+        return this.request("/api/v1/recordings/search", params);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { MenutesApiClient } from "./api.js";
+import { createServer } from "./server.js";
+const apiKey = process.env.MENUTES_API_KEY;
+if (!apiKey) {
+    console.error("MENUTES_API_KEY environment variable is required");
+    process.exit(1);
+}
+if (!apiKey.startsWith("mnts_")) {
+    console.error("MENUTES_API_KEY must start with 'mnts_'");
+    process.exit(1);
+}
+const baseUrl = process.env.MENUTES_BASE_URL || "https://app.menutes.com";
+const api = new MenutesApiClient(baseUrl, apiKey);
+const server = createServer(api);
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { MenutesApiClient } from "./api.js";
+export declare function createServer(api: MenutesApiClient): McpServer;

package/dist/server.js

@@ -0,0 +1,18 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerListRecordings } from "./tools/list-recordings.js";
+import { registerGetRecording } from "./tools/get-recording.js";
+import { registerGetTranscript } from "./tools/get-transcript.js";
+import { registerGetSummary } from "./tools/get-summary.js";
+import { registerSearchRecordings } from "./tools/search-recordings.js";
+export function createServer(api) {
+    const server = new McpServer({
+        name: "menutes",
+        version: "0.1.0",
+    });
+    registerListRecordings(server, api);
+    registerGetRecording(server, api);
+    registerGetTranscript(server, api);
+    registerGetSummary(server, api);
+    registerSearchRecordings(server, api);
+    return server;
+}

package/dist/tools/get-recording.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { MenutesApiClient } from "../api.js";
+export declare function registerGetRecording(server: McpServer, api: MenutesApiClient): void;

package/dist/tools/get-recording.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+export function registerGetRecording(server, api) {
+    server.tool("get_recording", "Get detailed metadata for a specific Menutes recording including title, date, duration, speaker count, status, and sharing scope.", {
+        id: z.string().describe("The recording ID"),
+    }, async ({ id }) => {
+        try {
+            const r = await api.getRecording(id);
+            const duration = r.duration
+                ? `${Math.floor(r.duration / 60)}m ${r.duration % 60}s`
+                : "unknown";
+            const date = new Date(r.createdAt).toLocaleString("en-GB", {
+                day: "numeric",
+                month: "short",
+                year: "numeric",
+                hour: "2-digit",
+                minute: "2-digit",
+            });
+            const text = [
+                `**${r.meetingTitle || "Untitled"}**`,
+                `Date: ${date}`,
+                `Duration: ${duration}`,
+                `Speakers: ${r.speakerCount ?? "unknown"}`,
+                `Status: ${r.status}`,
+                `Sharing: ${r.sharingScope}`,
+                `Source: ${r.sourceType}`,
+                `Owner: ${r.user.name || r.user.id}${r.team ? ` (${r.team.name})` : ""}`,
+                `ID: ${r.id}`,
+            ].join("\n");
+            return { content: [{ type: "text", text }] };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/get-summary.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { MenutesApiClient } from "../api.js";
+export declare function registerGetSummary(server: McpServer, api: MenutesApiClient): void;

package/dist/tools/get-summary.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export function registerGetSummary(server, api) {
+    server.tool("get_summary", "Get the AI-generated summary of a Menutes recording including discussion points, decisions, and action items.", {
+        id: z.string().describe("The recording ID"),
+    }, async ({ id }) => {
+        try {
+            const content = await api.getRecordingContent(id);
+            if (!content.summary) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "No summary available for this recording.",
+                        },
+                    ],
+                };
+            }
+            return { content: [{ type: "text", text: content.summary }] };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/get-transcript.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { MenutesApiClient } from "../api.js";
+export declare function registerGetTranscript(server: McpServer, api: MenutesApiClient): void;

package/dist/tools/get-transcript.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+function formatTime(seconds) {
+    if (seconds === null || seconds === undefined)
+        return "??:??";
+    const m = Math.floor(seconds / 60);
+    const s = Math.floor(seconds % 60);
+    return `${m}:${s.toString().padStart(2, "0")}`;
+}
+export function registerGetTranscript(server, api) {
+    server.tool("get_transcript", "Get the full speaker-labeled transcript with timestamps for a Menutes recording. For long meetings, consider using get_summary first.", {
+        id: z.string().describe("The recording ID"),
+    }, async ({ id }) => {
+        try {
+            const content = await api.getRecordingContent(id);
+            if (!content.transcriptSegments ||
+                content.transcriptSegments.length === 0) {
+                if (content.transcription) {
+                    return {
+                        content: [{ type: "text", text: content.transcription }],
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "No transcript available for this recording.",
+                        },
+                    ],
+                };
+            }
+            const names = content.speakerNames || {};
+            const lines = content.transcriptSegments.map((seg) => {
+                const name = names[seg.speaker] || seg.speaker;
+                const time = formatTime(seg.startTime);
+                return `[${name}] (${time}): ${seg.text}`;
+            });
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/list-recordings.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { MenutesApiClient } from "../api.js";
+export declare function registerListRecordings(server: McpServer, api: MenutesApiClient): void;

package/dist/tools/list-recordings.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+export function registerListRecordings(server, api) {
+    server.tool("list_recordings", "List your Menutes meeting recordings with optional filtering. Returns titles, dates, durations, and IDs for further querying.", {
+        page: z
+            .number()
+            .int()
+            .positive()
+            .optional()
+            .describe("Page number (default: 1)"),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .describe("Results per page (default: 20, max: 100)"),
+        status: z
+            .enum(["UPLOADING", "PROCESSING", "COMPLETED", "FAILED"])
+            .optional()
+            .describe("Filter by recording status"),
+        view: z
+            .enum(["my", "team", "organization", "all"])
+            .optional()
+            .describe("Scope: my (own), team (team-shared), organization (org-wide), all (admin)"),
+    }, async (params) => {
+        try {
+            const result = await api.listRecordings(params);
+            const lines = result.recordings.map((r) => {
+                const duration = r.duration
+                    ? `${Math.floor(r.duration / 60)}m ${r.duration % 60}s`
+                    : "unknown";
+                const date = new Date(r.createdAt).toLocaleDateString("en-GB", {
+                    day: "numeric",
+                    month: "short",
+                    year: "numeric",
+                });
+                return `- **${r.meetingTitle || "Untitled"}** (${date}, ${duration}, ${r.speakerCount ?? "?"} speakers) [${r.status}]\n  ID: ${r.id}`;
+            });
+            const { pagination: p } = result;
+            const header = `Found ${p.total} recording(s) — page ${p.page}/${p.totalPages}`;
+            return {
+                content: [
+                    { type: "text", text: `${header}\n\n${lines.join("\n")}` },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/search-recordings.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { MenutesApiClient } from "../api.js";
+export declare function registerSearchRecordings(server: McpServer, api: MenutesApiClient): void;

package/dist/tools/search-recordings.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+export function registerSearchRecordings(server, api) {
+    server.tool("search_recordings", "Search Menutes recordings by title. Returns matching recordings with IDs for further querying.", {
+        query: z.string().describe("Search query to match against titles"),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(50)
+            .optional()
+            .describe("Max results (default: 10, max: 50)"),
+    }, async ({ query, limit }) => {
+        try {
+            const result = await api.searchRecordings(query, limit);
+            if (result.recordings.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `No recordings found matching "${query}".`,
+                        },
+                    ],
+                };
+            }
+            const lines = result.recordings.map((r) => {
+                const date = new Date(r.createdAt).toLocaleDateString("en-GB", {
+                    day: "numeric",
+                    month: "short",
+                    year: "numeric",
+                });
+                const duration = r.duration
+                    ? `${Math.floor(r.duration / 60)}m ${r.duration % 60}s`
+                    : "unknown";
+                return `- **${r.meetingTitle || "Untitled"}** (${date}, ${duration})\n  ID: ${r.id}`;
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Found ${result.total} result(s) for "${query}":\n\n${lines.join("\n")}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@menutes/mcp-server",
+  "version": "0.1.0",
+  "description": "MCP server for accessing Menutes meeting transcripts and summaries from Claude Code",
+  "type": "module",
+  "bin": {
+    "menutes-mcp-server": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && chmod +x dist/index.js",
+    "prepare": "npm run build",
+    "dev": "tsc --watch"
+  },
+  "keywords": [
+    "mcp",
+    "menutes",
+    "meetings",
+    "transcription",
+    "claude-code",
+    "model-context-protocol"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  }
+}