screenpipe-mcp 0.8.6 → 0.10.0

package/src/index.ts

@@ -8,8 +8,6 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import {
   CallToolRequestSchema,
   ListToolsRequestSchema,
-  ListPromptsRequestSchema,
-  GetPromptRequestSchema,
   ListResourcesRequestSchema,
   ReadResourceRequestSchema,
   Tool,
@@ -19,20 +17,6 @@ import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
 
-// Helper to get current date in ISO format
-function getCurrentDateInfo(): { isoDate: string; localDate: string } {
-  const now = new Date();
-  return {
-    isoDate: now.toISOString(),
-    localDate: now.toLocaleDateString("en-US", {
-      weekday: "long",
-      year: "numeric",
-      month: "long",
-      day: "numeric",
-    }),
-  };
-}
-
 // Parse command line arguments
 const args = process.argv.slice(2);
 let port = 3030;
@@ -48,644 +32,266 @@ const SCREENPIPE_API = `http://localhost:${port}`;
 const server = new Server(
   {
     name: "screenpipe",
-    version: "0.8.5",
+    version: "0.9.0",
   },
   {
     capabilities: {
       tools: {},
-      prompts: {},
       resources: {},
     },
   }
 );
 
-// Tool definitions
-const BASE_TOOLS: Tool[] = [
+// ---------------------------------------------------------------------------
+// Tools — minimal descriptions, no behavioral guidance (that belongs in resources)
+// ---------------------------------------------------------------------------
+const TOOLS: Tool[] = [
   {
     name: "search-content",
     description:
-      "Search screenpipe's recorded content: screen text (accessibility APIs, with OCR fallback), audio transcriptions, and UI elements. " +
-      "Returns timestamped results with app context. " +
-      "Call with no parameters to get recent activity. " +
-      "Use the 'screenpipe://context' resource for current time when building time-based queries.\n\n" +
-      "WHEN TO USE WHICH content_type:\n" +
-      "- For meetings/calls/conversations: content_type='audio', do NOT use q param (transcriptions are noisy, q filters too aggressively)\n" +
-      "- For screen text/reading: content_type='all' or 'accessibility'\n" +
-      "- For time spent/app usage questions: use activity-summary tool instead (this tool returns content, not time stats)\n\n" +
-      "SEARCH STRATEGY: First search with ONLY time params (start_time/end_time) — no q, no app_name, no content_type. " +
-      "This gives ground truth of what's recorded. Scan results to find correct app_name values, then narrow with filters using exact observed values. " +
-      "App names are case-sensitive (e.g. 'Discord' vs 'Discord.exe'). " +
-      "The q param searches captured text, NOT app names. NEVER report 'no data' after one filtered search — verify with unfiltered time-only search first.\n\n" +
-      "DEEP LINKS: When referencing specific moments, create clickable links using IDs from search results:\n" +
-      "- OCR results (PREFERRED): [10:30 AM — Chrome](screenpipe://frame/12345) — use content.frame_id from the result\n" +
-      "- Audio results: [meeting at 3pm](screenpipe://timeline?timestamp=2024-01-15T15:00:00Z) — use exact timestamp from result\n" +
-      "NEVER fabricate frame IDs or timestamps — only use values from actual search results.",
-    annotations: {
-      title: "Search Content",
-      readOnlyHint: true,
-    },
+      "Search screen text, audio transcriptions, input events, and memories. " +
+      "Returns timestamped results with app context. Call with no params for recent activity.",
+    annotations: { title: "Search Content", readOnlyHint: true },
     inputSchema: {
       type: "object",
       properties: {
         q: {
           type: "string",
-          description: "Search query (full-text search on captured text). Optional - omit to return all content in time range. IMPORTANT: Do NOT use q for audio/meeting searches — transcriptions are noisy and q filters too aggressively. Only use q when searching for specific text the user saw on screen.",
+          description: "Full-text search query. Omit to return all content in time range.",
         },
         content_type: {
           type: "string",
-          enum: ["all", "ocr", "audio", "input", "accessibility"],
-          description: "Content type filter: 'audio' (transcriptions — use for meetings/calls/conversations), 'accessibility' (accessibility tree text, preferred for screen content), 'ocr' (screen text via OCR, legacy fallback), 'input' (clicks, keystrokes, clipboard, app switches), 'all'. Default: 'all'. For meeting/call queries, ALWAYS use 'audio'.",
+          enum: ["all", "ocr", "audio", "input", "accessibility", "memory"],
+          description: "Filter by content type. Default: 'all'.",
           default: "all",
         },
-        limit: {
-          type: "integer",
-          description: "Max results. Default: 10",
-          default: 10,
-        },
-        offset: {
-          type: "integer",
-          description: "Skip N results for pagination. Default: 0",
-          default: 0,
-        },
+        limit: { type: "integer", description: "Max results (default 10)", default: 10 },
+        offset: { type: "integer", description: "Pagination offset", default: 0 },
         start_time: {
           type: "string",
-          format: "date-time",
-          description: "Start time: ISO 8601 UTC (e.g., 2024-01-15T10:00:00Z) or relative (e.g., '16h ago', '2d ago', 'now')",
+          description: "ISO 8601 UTC or relative (e.g. '2h ago')",
         },
         end_time: {
           type: "string",
-          format: "date-time",
-          description: "End time: ISO 8601 UTC (e.g., 2024-01-15T18:00:00Z) or relative (e.g., 'now', '1h ago')",
-        },
-        app_name: {
-          type: "string",
-          description: "Filter by app (e.g., 'Google Chrome', 'Slack', 'zoom.us')",
-        },
-        window_name: {
-          type: "string",
-          description: "Filter by window title",
-        },
-        min_length: {
-          type: "integer",
-          description: "Minimum content length in characters",
-        },
-        max_length: {
-          type: "integer",
-          description: "Maximum content length in characters",
+          description: "ISO 8601 UTC or relative (e.g. 'now')",
         },
+        app_name: { type: "string", description: "Filter by app name" },
+        window_name: { type: "string", description: "Filter by window title" },
+        min_length: { type: "integer", description: "Min content length" },
+        max_length: { type: "integer", description: "Max content length" },
         include_frames: {
           type: "boolean",
-          description: "Include base64 screenshots (OCR only). Default: false",
+          description: "Include base64 screenshots (OCR only)",
           default: false,
         },
-        speaker_ids: {
-          type: "string",
-          description: "Comma-separated speaker IDs to filter audio results (e.g., '1,2,3')",
-        },
-        speaker_name: {
-          type: "string",
-          description: "Filter audio by speaker name (case-insensitive partial match)",
-        },
+        speaker_ids: { type: "string", description: "Comma-separated speaker IDs" },
+        speaker_name: { type: "string", description: "Filter audio by speaker name" },
         max_content_length: {
           type: "integer",
-          description: "Truncate each result's text/transcription to this many characters using middle-truncation (keeps first half + last half). Useful for limiting token usage with small-context models.",
+          description: "Truncate each result via middle-truncation",
         },
       },
     },
   },
   {
-    name: "export-video",
-    description:
-      "Export a video of screen recordings for a specific time range. " +
-      "Creates an MP4 video from the recorded frames between the start and end times.\n\n" +
-      "IMPORTANT: Use ISO 8601 UTC timestamps (e.g., 2024-01-15T10:00:00Z) or relative times (e.g., '16h ago', 'now')\n\n" +
-      "EXAMPLES:\n" +
-      "- Last 30 minutes: Calculate timestamps from current time\n" +
-      "- Specific meeting: Use the meeting's start and end times in UTC",
-    annotations: {
-      title: "Export Video",
-      destructiveHint: true,
+    name: "list-meetings",
+    description: "List detected meetings (Zoom, Teams, Meet, etc.) with duration, app, and attendees.",
+    annotations: { title: "List Meetings", readOnlyHint: true },
+    inputSchema: {
+      type: "object",
+      properties: {
+        start_time: { type: "string", description: "ISO 8601 UTC or relative" },
+        end_time: { type: "string", description: "ISO 8601 UTC or relative" },
+        limit: { type: "integer", description: "Max results (default 20)", default: 20 },
+        offset: { type: "integer", description: "Pagination offset", default: 0 },
+      },
     },
+  },
+  {
+    name: "activity-summary",
+    description:
+      "Lightweight activity overview (~200-500 tokens): app usage with active minutes, audio speakers, recent texts. " +
+      "Use for 'how long on X?', 'which apps?', 'what was I doing?' questions.",
+    annotations: { title: "Activity Summary", readOnlyHint: true },
     inputSchema: {
       type: "object",
       properties: {
-        start_time: {
-          type: "string",
-          format: "date-time",
-          description:
-            "Start time: ISO 8601 UTC (e.g., '2024-01-15T10:00:00Z') or relative (e.g., '16h ago', 'now')",
-        },
-        end_time: {
-          type: "string",
-          format: "date-time",
-          description:
-            "End time: ISO 8601 UTC (e.g., '2024-01-15T10:30:00Z') or relative (e.g., 'now', '1h ago')",
-        },
-        fps: {
-          type: "number",
-          description:
-            "Frames per second for the output video. Lower values (0.5-1.0) create smaller files, higher values (5-10) create smoother playback. Default: 1.0",
-          default: 1.0,
-        },
+        start_time: { type: "string", description: "ISO 8601 UTC or relative" },
+        end_time: { type: "string", description: "ISO 8601 UTC or relative" },
+        app_name: { type: "string", description: "Optional app name filter" },
       },
       required: ["start_time", "end_time"],
     },
   },
   {
-    name: "list-meetings",
+    name: "search-elements",
     description:
-      "List detected meetings with duration, app, and attendees. " +
-      "Returns meetings detected via app focus (Zoom, Meet, Teams) and audio. " +
-      "Only available when screenpipe runs in smart transcription mode.",
-    annotations: {
-      title: "List Meetings",
-      readOnlyHint: true,
-    },
+      "Search UI elements (buttons, links, text fields) from the accessibility tree. " +
+      "Lighter than search-content for targeted UI lookups.",
+    annotations: { title: "Search Elements", readOnlyHint: true },
     inputSchema: {
       type: "object",
       properties: {
-        start_time: {
-          type: "string",
-          format: "date-time",
-          description: "Start filter: ISO 8601 UTC (e.g., 2024-01-15T10:00:00Z) or relative (e.g., '16h ago', 'now')",
-        },
-        end_time: {
+        q: { type: "string", description: "Full-text search on element text" },
+        frame_id: { type: "integer", description: "Filter to specific frame" },
+        source: {
           type: "string",
-          format: "date-time",
-          description: "End filter: ISO 8601 UTC (e.g., 2024-01-15T18:00:00Z) or relative (e.g., 'now', '1h ago')",
-        },
-        limit: {
-          type: "integer",
-          description: "Max results. Default: 20",
-          default: 20,
-        },
-        offset: {
-          type: "integer",
-          description: "Skip N results for pagination. Default: 0",
-          default: 0,
-        },
+          enum: ["accessibility", "ocr"],
+          description: "Element source filter",
+        },
+        role: { type: "string", description: "Element role (e.g. AXButton, AXLink)" },
+        start_time: { type: "string", description: "ISO 8601 UTC or relative" },
+        end_time: { type: "string", description: "ISO 8601 UTC or relative" },
+        app_name: { type: "string", description: "Filter by app name" },
+        limit: { type: "integer", description: "Max results (default 50)", default: 50 },
+        offset: { type: "integer", description: "Pagination offset", default: 0 },
       },
     },
   },
   {
-    name: "activity-summary",
+    name: "frame-context",
     description:
-      "Get a lightweight compressed activity overview for a time range (~200-500 tokens). " +
-      "Returns app usage (name, frame count, active minutes, first/last seen), recent accessibility texts, and audio speaker summary. " +
-      "Minutes are based on active session time (consecutive frames with gaps < 5min count as active). " +
-      "first_seen/last_seen show the wall-clock span per app.\n\n" +
-      "USE THIS TOOL (not search-content or raw SQL) for:\n" +
-      "- 'how long did I spend on X?' → active_minutes per app\n" +
-      "- 'which apps did I use today?' → app list sorted by active_minutes\n" +
-      "- 'what was I doing?' → broad overview before drilling deeper\n" +
-      "- Any time-spent or app-usage question\n\n" +
-      "WARNING: Do NOT estimate time from raw frame counts or SQL queries — those are inaccurate. " +
-      "This endpoint calculates actual active session time correctly.",
-    annotations: {
-      title: "Activity Summary",
-      readOnlyHint: true,
+      "Get accessibility text, parsed tree nodes, and URLs for a specific frame ID.",
+    annotations: { title: "Frame Context", readOnlyHint: true },
+    inputSchema: {
+      type: "object",
+      properties: {
+        frame_id: { type: "integer", description: "Frame ID from search results" },
+      },
+      required: ["frame_id"],
     },
+  },
+  {
+    name: "export-video",
+    description: "Export an MP4 video of screen recordings for a time range.",
+    annotations: { title: "Export Video", destructiveHint: true },
     inputSchema: {
       type: "object",
       properties: {
-        start_time: {
-          type: "string",
-          format: "date-time",
-          description: "Start of time range: ISO 8601 UTC (e.g., 2024-01-15T10:00:00Z) or relative (e.g., '16h ago', 'now')",
-        },
-        end_time: {
-          type: "string",
-          format: "date-time",
-          description: "End of time range: ISO 8601 UTC (e.g., 2024-01-15T18:00:00Z) or relative (e.g., 'now', '1h ago')",
-        },
-        app_name: {
-          type: "string",
-          description: "Optional app name filter (e.g., 'Google Chrome', 'VS Code')",
-        },
+        start_time: { type: "string", description: "ISO 8601 UTC or relative" },
+        end_time: { type: "string", description: "ISO 8601 UTC or relative" },
+        fps: { type: "number", description: "Output FPS (default 1.0)", default: 1.0 },
       },
       required: ["start_time", "end_time"],
     },
   },
   {
-    name: "search-elements",
+    name: "update-memory",
     description:
-      "Search structured UI elements (accessibility tree nodes and OCR text blocks). " +
-      "Returns ~100-500 bytes per element — much lighter than search-content for targeted lookups. " +
-      "Each element has: id, frame_id, source (accessibility/ocr), role (AXButton, AXStaticText, AXLink, etc.), text, bounds, depth.\n\n" +
-      "Use for: finding specific buttons, links, text fields, or UI components. " +
-      "Prefer this over search-content when you need structural UI detail rather than full screen text.",
-    annotations: {
-      title: "Search Elements",
-      readOnlyHint: true,
-    },
+      "Create, update, or delete a persistent memory (facts, preferences, decisions). " +
+      "Retrieve memories via search-content with content_type='memory'.",
+    annotations: { title: "Update Memory", destructiveHint: false },
     inputSchema: {
       type: "object",
       properties: {
-        q: {
-          type: "string",
-          description: "Full-text search query across element text. Optional.",
-        },
-        frame_id: {
-          type: "integer",
-          description: "Filter to elements from a specific frame",
-        },
-        source: {
-          type: "string",
-          enum: ["accessibility", "ocr"],
-          description: "Filter by element source: 'accessibility' (structured tree) or 'ocr' (text blocks)",
-        },
-        role: {
-          type: "string",
-          description: "Filter by element role (e.g., 'AXButton', 'AXStaticText', 'AXLink', 'AXTextField', 'line')",
-        },
-        start_time: {
-          type: "string",
-          format: "date-time",
-          description: "Start time: ISO 8601 UTC or relative (e.g., '16h ago', 'now')",
-        },
-        end_time: {
-          type: "string",
-          format: "date-time",
-          description: "End time: ISO 8601 UTC or relative (e.g., 'now', '1h ago')",
-        },
-        app_name: {
-          type: "string",
-          description: "Filter by app name",
-        },
-        limit: {
-          type: "integer",
-          description: "Max results. Default: 50",
-          default: 50,
-        },
-        offset: {
-          type: "integer",
-          description: "Skip N results for pagination. Default: 0",
-          default: 0,
-        },
+        id: { type: "integer", description: "Memory ID (omit to create new)" },
+        content: { type: "string", description: "Memory text" },
+        tags: { type: "array", items: { type: "string" }, description: "Categorization tags" },
+        importance: { type: "number", description: "0.0-1.0 (default 0.5)" },
+        source_context: { type: "object", description: "Optional source data links" },
+        delete: { type: "boolean", description: "Delete the memory identified by id" },
       },
     },
   },
   {
-    name: "frame-context",
+    name: "send-notification",
     description:
-      "Get accessibility text, parsed tree nodes, and extracted URLs for a specific frame. " +
-      "Falls back to OCR data for legacy frames without accessibility data. " +
-      "Use after finding a frame_id from search-content or search-elements to get full structural detail and URLs.",
-    annotations: {
-      title: "Frame Context",
-      readOnlyHint: true,
-    },
+      "Send a notification to the screenpipe desktop UI with optional action buttons. " +
+      "Actions can re-run pipes with context, call API endpoints, or open deep links.",
+    annotations: { title: "Send Notification", destructiveHint: false },
     inputSchema: {
       type: "object",
       properties: {
-        frame_id: {
-          type: "integer",
-          description: "The frame ID to get context for (from search results)",
+        title: { type: "string", description: "Notification title" },
+        body: { type: "string", description: "Notification body (markdown supported)" },
+        pipe_name: { type: "string", description: "Name of the pipe sending this notification" },
+        timeout_secs: { type: "integer", description: "Auto-dismiss seconds (default 20)", default: 20 },
+        actions: {
+          type: "array",
+          description: "Up to 5 action buttons",
+          items: {
+            type: "object",
+            properties: {
+              id: { type: "string", description: "Unique action ID" },
+              label: { type: "string", description: "Button label" },
+              type: { type: "string", enum: ["pipe", "api", "deeplink", "dismiss"], description: "Action type" },
+              pipe: { type: "string", description: "Pipe name to run (type=pipe)" },
+              context: { type: "object", description: "Context passed to pipe (type=pipe)" },
+              url: { type: "string", description: "URL for api/deeplink actions" },
+            },
+            required: ["id", "label", "type"],
+          },
         },
       },
-      required: ["frame_id"],
+      required: ["title", "pipe_name"],
     },
   },
 ];
 
-// List tools handler
 server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return { tools: BASE_TOOLS };
+  return { tools: TOOLS };
 });
 
-// MCP Resources - provide dynamic context data
+// ---------------------------------------------------------------------------
+// Resources — dynamic context only (no duplicated reference docs)
+// ---------------------------------------------------------------------------
 const RESOURCES = [
   {
     uri: "screenpipe://context",
     name: "Current Context",
-    description: "Current date/time and pre-computed timestamps for common time ranges",
+    description: "Current date/time, timezone, and pre-computed timestamps for common time ranges",
     mimeType: "application/json",
   },
-  {
-    uri: "screenpipe://guide",
-    name: "Usage Guide",
-    description: "How to use screenpipe search effectively",
-    mimeType: "text/markdown",
-  },
-  {
-    uri: "ui://search",
-    name: "Search Dashboard",
-    description: "Interactive search UI for exploring screen recordings and audio transcriptions",
-    mimeType: "text/html",
-  },
 ];
 
-// List resources handler
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
   return { resources: RESOURCES };
 });
 
-// Read resource handler
 server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
   const { uri } = request.params;
-  const dateInfo = getCurrentDateInfo();
-  const now = Date.now();
-
-  switch (uri) {
-    case "screenpipe://context":
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify({
-              current_time: dateInfo.isoDate,
-              current_date_local: dateInfo.localDate,
+
+  if (uri === "screenpipe://context") {
+    const now = new Date();
+    const ms = now.getTime();
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify(
+            {
+              current_time: now.toISOString(),
+              current_date_local: now.toLocaleDateString("en-US", {
+                weekday: "long",
+                year: "numeric",
+                month: "long",
+                day: "numeric",
+              }),
               timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
               timestamps: {
-                now: dateInfo.isoDate,
-                one_hour_ago: new Date(now - 60 * 60 * 1000).toISOString(),
-                three_hours_ago: new Date(now - 3 * 60 * 60 * 1000).toISOString(),
-                today_start: `${new Date().toISOString().split("T")[0]}T00:00:00Z`,
-                yesterday_start: `${new Date(now - 24 * 60 * 60 * 1000).toISOString().split("T")[0]}T00:00:00Z`,
-                one_week_ago: new Date(now - 7 * 24 * 60 * 60 * 1000).toISOString(),
+                now: now.toISOString(),
+                one_hour_ago: new Date(ms - 60 * 60 * 1000).toISOString(),
+                three_hours_ago: new Date(ms - 3 * 60 * 60 * 1000).toISOString(),
+                today_start: `${now.toISOString().split("T")[0]}T00:00:00Z`,
+                yesterday_start: `${new Date(ms - 24 * 60 * 60 * 1000).toISOString().split("T")[0]}T00:00:00Z`,
+                one_week_ago: new Date(ms - 7 * 24 * 60 * 60 * 1000).toISOString(),
               },
-              common_apps: ["Google Chrome", "Safari", "Slack", "zoom.us", "Microsoft Teams", "Code", "Terminal"],
-            }, null, 2),
-          },
-        ],
-      };
-
-    case "screenpipe://guide":
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "text/markdown",
-            text: `# Screenpipe Search Guide
-
-## Data Modalities
-
-Screenpipe captures four types of data:
-1. **Accessibility** - Screen text via accessibility APIs (primary, preferred for screen content)
-2. **OCR** - Screen text from screenshots (legacy fallback for apps without accessibility support)
-3. **Audio** - Transcribed speech from microphone/system audio
-4. **Input** - Keyboard input, mouse clicks, app switches, clipboard (macOS)
-
-## Quick Start
-- **Get recent activity**: Call search-content with no parameters
-- **Search screen text**: \`{"q": "search term", "content_type": "all"}\`
-- **Get keyboard input**: \`{"content_type": "input"}\`
-- **Get audio only**: \`{"content_type": "audio"}\`
-
-## Common User Requests → Correct Tool Choice
-| User says | Use this tool | Key params |
-|-----------|--------------|------------|
-| "summarize my meeting/call" | search-content | content_type:"audio", NO q param, start_time |
-| "what did they/I say about X" | search-content | content_type:"audio", NO q param (scan results manually) |
-| "how long on X" / "which apps" / "time spent" | activity-summary | start_time, end_time |
-| "what was I doing" | activity-summary | start_time, end_time (then drill into search-content) |
-| "what was I reading/looking at" | search-content | content_type:"all", start_time |
-
-## Behavior Rules
-- Act immediately on clear requests. NEVER ask "what time range?" or "which content type?" when the intent is obvious.
-- If search returns empty, silently retry with wider time range or fewer filters. Do NOT ask the user what to change.
-- For meetings: ALWAYS use content_type:"audio" and do NOT use the q param. Transcriptions are noisy — q filters too aggressively and misses relevant content.
-
-## search-content
-| Parameter | Description | Default |
-|-----------|-------------|---------|
-| q | Search query | (none - returns all) |
-| content_type | all/ocr/audio/input/accessibility | all |
-| limit | Max results | 10 |
-| start_time | ISO 8601 UTC or relative (e.g. '16h ago') | (no filter) |
-| end_time | ISO 8601 UTC or relative (e.g. 'now') | (no filter) |
-| app_name | Filter by app | (no filter) |
-| include_frames | Include screenshots | false |
-
-## Search Strategy (MANDATORY)
-1. First search: ONLY use time params (start_time/end_time). No q, no app_name, no content_type. This gives ground truth of what's recorded.
-2. Scan results to find correct app_name values and content patterns.
-3. Only THEN narrow with filters using exact observed values. App names are case-sensitive and may differ from user input (e.g. "Discord" vs "Discord.exe").
-4. The q param searches captured text (accessibility/OCR), NOT app names — an app can be visible without its name in the captured text.
-5. NEVER report "no data found" after one filtered search. Verify with unfiltered time-only search first.
-
-## Progressive Disclosure (Token-Efficient Strategy)
-1. **Start with activity-summary** (~200 tokens) for broad questions ("what was I doing?")
-2. **Narrow with search-content** (~500-1000 tokens) using filters from step 1
-3. **Drill into search-elements** (~200 tokens each) for structural UI detail (buttons, links)
-4. **Fetch frame-context** for URLs and accessibility tree of specific frames
-5. **Screenshots** (include_frames=true) only when text isn't enough
-
-## Chat History
-Previous screenpipe chat conversations are stored as individual JSON files in ~/.screenpipe/chats/{conversation-id}.json
-Each file contains: id, title, messages[], createdAt, updatedAt. You can read these files to reference or search previous conversations.
-
-## Speaker Management
-screenpipe auto-identifies speakers in audio. API endpoints for managing them:
-- \`GET /speakers/unnamed?limit=10\` — list unnamed speakers
-- \`GET /speakers/search?name=John\` — search by name
-- \`POST /speakers/update\` with \`{"id": 5, "name": "John"}\` — rename a speaker
-- \`POST /speakers/merge\` with \`{"speaker_to_keep_id": 1, "speaker_to_merge_id": 2}\` — merge duplicates
-- \`GET /speakers/similar?speaker_id=5\` — find similar speakers for merging
-- \`POST /speakers/reassign\` — reassign audio chunk to different speaker
-
-## Tips
-1. Read screenpipe://context first to get current timestamps
-2. Use activity-summary before search-content for broad overview questions
-3. Use search-elements instead of search-content for targeted UI lookups (10x lighter)
-4. Use content_type=input for "what did I type?" queries
-5. Use content_type=accessibility for accessibility tree text
-6. For large aggregations (e.g. "what apps did I use today?"), paginate with offset or suggest the user run raw SQL via \`curl -X POST http://localhost:3030/raw_sql\` for efficient GROUP BY queries
-
-## Deep Links (Clickable References)
-When showing search results to users, create clickable links so they can jump to that exact moment.
-
-**ALWAYS prefer frame-based links for OCR results** (frame IDs are exact DB keys):
-- \`[10:30 AM — Chrome](screenpipe://frame/12345)\` — use \`content.frame_id\` from OCR results
-
-**Use timestamp links only for audio results** (which have no frame_id):
-- \`[meeting at 3pm](screenpipe://timeline?timestamp=2024-01-15T15:00:00Z)\` — use exact \`timestamp\` from audio results
-
-**NEVER fabricate frame IDs or timestamps.** Only use values copied from actual search results.`,
-          },
-        ],
-      };
-
-    case "ui://search": {
-      // MCP App UI - Interactive search dashboard
-      const uiHtmlPath = path.join(__dirname, "..", "ui", "search.html");
-      let htmlContent: string;
-      try {
-        htmlContent = fs.readFileSync(uiHtmlPath, "utf-8");
-      } catch {
-        // Fallback: serve embedded minimal UI if file not found
-        htmlContent = `<!DOCTYPE html>
-<html>
-<head>
-  <style>
-    body { font-family: system-ui; background: #0a0a0a; color: #fff; padding: 20px; }
-    input { width: 100%; padding: 10px; margin-bottom: 10px; background: #1a1a1a; border: 1px solid #333; color: #fff; border-radius: 6px; }
-    button { padding: 10px 20px; background: #fff; color: #000; border: none; border-radius: 6px; cursor: pointer; }
-    #results { margin-top: 20px; }
-    .result { background: #1a1a1a; padding: 12px; margin: 8px 0; border-radius: 8px; border: 1px solid #333; }
-  </style>
-</head>
-<body>
-  <h2>screenpipe search</h2>
-  <input id="q" placeholder="search..." onkeydown="if(event.key==='Enter')search()"/>
-  <button onclick="search()">search</button>
-  <div id="results"></div>
-  <script>
-    function search() {
-      window.parent.postMessage({jsonrpc:'2.0',method:'tools/call',params:{name:'search-content',arguments:{q:document.getElementById('q').value,limit:20}}},'*');
-    }
-    window.addEventListener('message',e=>{
-      if(e.data?.result||e.data?.method==='tool/result'){
-        const r=e.data.result||e.data.params?.result;
-        const d=r?.data||r||[];
-        document.getElementById('results').innerHTML=d.map(x=>'<div class="result"><b>'+((x.type||'')+'</b> '+(x.content?.app_name||'')+': '+(x.content?.text||x.content?.transcription||'').substring(0,200))+'</div>').join('');
-      }
-    });
-  </script>
-</body>
-</html>`;
-      }
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: "text/html",
-            text: htmlContent,
-          },
-        ],
-      };
-    }
-
-    default:
-      throw new Error(`Unknown resource: ${uri}`);
-  }
-});
-
-// MCP Prompts - static interaction templates
-const PROMPTS = [
-  {
-    name: "search-recent",
-    description: "Search recent screen activity",
-    arguments: [
-      { name: "query", description: "Optional search term", required: false },
-      { name: "hours", description: "Hours to look back (default: 1)", required: false },
-    ],
-  },
-  {
-    name: "find-in-app",
-    description: "Find content from a specific application",
-    arguments: [
-      { name: "app", description: "App name (e.g., Chrome, Slack)", required: true },
-      { name: "query", description: "Optional search term", required: false },
-    ],
-  },
-  {
-    name: "meeting-notes",
-    description: "Get audio transcriptions from meetings",
-    arguments: [
-      { name: "hours", description: "Hours to look back (default: 3)", required: false },
-    ],
-  },
-];
-
-// List prompts handler
-server.setRequestHandler(ListPromptsRequestSchema, async () => {
-  return { prompts: PROMPTS };
-});
-
-// Get prompt handler
-server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-  const { name, arguments: promptArgs } = request.params;
-  const dateInfo = getCurrentDateInfo();
-  const now = Date.now();
-
-  switch (name) {
-    case "search-recent": {
-      const query = promptArgs?.query || "";
-      const hours = parseInt(promptArgs?.hours || "1", 10);
-      const startTime = new Date(now - hours * 60 * 60 * 1000).toISOString();
-
-      return {
-        description: `Search recent activity (last ${hours} hour${hours > 1 ? "s" : ""})`,
-        messages: [
-          {
-            role: "user" as const,
-            content: {
-              type: "text" as const,
-              text: `Search screenpipe for recent activity.
-
-Current time: ${dateInfo.isoDate}
-
-Use search-content with:
-${query ? `- q: "${query}"` : "- No query filter (get all content)"}
-- start_time: "${startTime}"
-- limit: 50`,
-            },
-          },
-        ],
-      };
-    }
-
-    case "find-in-app": {
-      const app = promptArgs?.app || "Google Chrome";
-      const query = promptArgs?.query || "";
-
-      return {
-        description: `Find content from ${app}`,
-        messages: [
-          {
-            role: "user" as const,
-            content: {
-              type: "text" as const,
-              text: `Search screenpipe for content from ${app}.
-
-Current time: ${dateInfo.isoDate}
-
-Use search-content with:
-- app_name: "${app}"
-${query ? `- q: "${query}"` : "- No query filter"}
-- content_type: "all"
-- limit: 50`,
             },
-          },
-        ],
-      };
-    }
-
-    case "meeting-notes": {
-      const hours = parseInt(promptArgs?.hours || "3", 10);
-      const startTime = new Date(now - hours * 60 * 60 * 1000).toISOString();
-
-      return {
-        description: `Get meeting transcriptions (last ${hours} hours)`,
-        messages: [
-          {
-            role: "user" as const,
-            content: {
-              type: "text" as const,
-              text: `Get audio transcriptions from recent meetings.
-
-Current time: ${dateInfo.isoDate}
-
-Use search-content with:
-- content_type: "audio"
-- start_time: "${startTime}"
-- limit: 100
-
-Common meeting apps: zoom.us, Microsoft Teams, Google Meet, Slack`,
-            },
-          },
-        ],
-      };
-    }
-
-    default:
-      throw new Error(`Unknown prompt: ${name}`);
+            null,
+            2
+          ),
+        },
+      ],
+    };
   }
+
+  throw new Error(`Unknown resource: ${uri}`);
 });
 
-// Helper function to make HTTP requests
+// ---------------------------------------------------------------------------
+// Helper
+// ---------------------------------------------------------------------------
 async function fetchAPI(
   endpoint: string,
   options: RequestInit = {}
@@ -700,7 +306,9 @@ async function fetchAPI(
   });
 }
 
-// Call tool handler
+// ---------------------------------------------------------------------------
+// Tool handlers
+// ---------------------------------------------------------------------------
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
 
@@ -720,9 +328,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
 
         const response = await fetchAPI(`/search?${params.toString()}`);
-        if (!response.ok) {
-          throw new Error(`HTTP error: ${response.status}`);
-        }
+        if (!response.ok) throw new Error(`HTTP error: ${response.status}`);
 
         const data = await response.json();
         const results = data.data || [];
@@ -733,13 +339,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             content: [
               {
                 type: "text",
-                text: "No results found. Try: broader search terms, different content_type, or wider time range.",
+                text: "No results found. Try: broader terms, different content_type, or wider time range.",
               },
             ],
           };
         }
 
-        // Build content array with text and optional images
         const contentItems: Array<
           | { type: "text"; text: string }
           | { type: "image"; data: string; mimeType: string }
@@ -756,9 +361,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const tagsStr = content.tags?.length ? `\nTags: ${content.tags.join(", ")}` : "";
             formattedResults.push(
               `[OCR] ${content.app_name || "?"} | ${content.window_name || "?"}\n` +
-              `${content.timestamp || ""}\n` +
-              `${content.text || ""}` +
-              tagsStr
+                `${content.timestamp || ""}\n` +
+                `${content.text || ""}` +
+                tagsStr
             );
             if (includeFrames && content.frame) {
               images.push({
@@ -770,29 +375,39 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const tagsStr = content.tags?.length ? `\nTags: ${content.tags.join(", ")}` : "";
             formattedResults.push(
               `[Audio] ${content.device_name || "?"}\n` +
-              `${content.timestamp || ""}\n` +
-              `${content.transcription || ""}` +
-              tagsStr
+                `${content.timestamp || ""}\n` +
+                `${content.transcription || ""}` +
+                tagsStr
             );
           } else if (result.type === "UI" || result.type === "Accessibility") {
             formattedResults.push(
               `[Accessibility] ${content.app_name || "?"} | ${content.window_name || "?"}\n` +
-              `${content.timestamp || ""}\n` +
-              `${content.text || ""}`
+                `${content.timestamp || ""}\n` +
+                `${content.text || ""}`
+            );
+          } else if (result.type === "Memory") {
+            const tagsStr = content.tags?.length ? ` [${content.tags.join(", ")}]` : "";
+            const importance =
+              content.importance != null ? ` (importance: ${content.importance})` : "";
+            formattedResults.push(
+              `[Memory #${content.id}]${tagsStr}${importance}\n` +
+                `${content.created_at || ""}\n` +
+                `${content.content || ""}`
             );
           }
         }
 
-        // Header with pagination info
-        const header = `Results: ${results.length}/${pagination.total || "?"}` +
-          (pagination.total > results.length ? ` (use offset=${(pagination.offset || 0) + results.length} for more)` : "");
+        const header =
+          `Results: ${results.length}/${pagination.total || "?"}` +
+          (pagination.total > results.length
+            ? ` (use offset=${(pagination.offset || 0) + results.length} for more)`
+            : "");
 
         contentItems.push({
           type: "text",
           text: header + "\n\n" + formattedResults.join("\n---\n"),
         });
 
-        // Add images if requested
         for (const img of images) {
           contentItems.push({ type: "text", text: `\n📷 ${img.context}` });
           contentItems.push({ type: "image", data: img.data, mimeType: "image/png" });
@@ -801,178 +416,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return { content: contentItems };
       }
 
-      case "export-video": {
-        const startTime = args.start_time as string;
-        const endTime = args.end_time as string;
-        const fps = (args.fps as number) || 1.0;
-
-        // Validate time inputs
-        if (!startTime || !endTime) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "Error: Both start_time and end_time are required in ISO 8601 format (e.g., '2024-01-15T10:00:00Z')",
-              },
-            ],
-          };
-        }
-
-        // Step 1: Query the search API to get frame IDs for the time range
-        const searchParams = new URLSearchParams({
-          content_type: "ocr",
-          start_time: startTime,
-          end_time: endTime,
-          limit: "10000", // Get all frames in range
-        });
-
-        const searchResponse = await fetchAPI(`/search?${searchParams.toString()}`);
-        if (!searchResponse.ok) {
-          throw new Error(`Failed to search for frames: HTTP ${searchResponse.status}`);
-        }
-
-        const searchData = await searchResponse.json();
-        const results = searchData.data || [];
-
-        if (results.length === 0) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `No screen recordings found between ${startTime} and ${endTime}. Make sure screenpipe was recording during this time period.`,
-              },
-            ],
-          };
-        }
-
-        // Extract unique frame IDs from OCR results
-        const frameIds: number[] = [];
-        const seenIds = new Set<number>();
-        for (const result of results) {
-          if (result.type === "OCR" && result.content?.frame_id) {
-            const frameId = result.content.frame_id;
-            if (!seenIds.has(frameId)) {
-              seenIds.add(frameId);
-              frameIds.push(frameId);
-            }
-          }
-        }
-
-        if (frameIds.length === 0) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Found ${results.length} results but no valid frame IDs. The recordings may be audio-only.`,
-              },
-            ],
-          };
-        }
-
-        // Sort frame IDs
-        frameIds.sort((a, b) => a - b);
-
-        // Step 2: Connect to WebSocket and export video
-        // Send frame_ids in message body to avoid URL length limits
-        const wsUrl = `ws://localhost:${port}/frames/export?fps=${fps}`;
-
-        const exportResult = await new Promise<{
-          success: boolean;
-          filePath?: string;
-          error?: string;
-          frameCount?: number;
-        }>((resolve) => {
-          const ws = new WebSocket(wsUrl);
-          let resolved = false;
-
-          const timeout = setTimeout(() => {
-            if (!resolved) {
-              resolved = true;
-              ws.close();
-              resolve({ success: false, error: "Export timed out after 5 minutes" });
-            }
-          }, 5 * 60 * 1000); // 5 minute timeout
-
-          ws.on("open", () => {
-            // Send frame_ids in message body to avoid URL length limits
-            ws.send(JSON.stringify({ frame_ids: frameIds }));
-          });
-
-          ws.on("error", (error) => {
-            if (!resolved) {
-              resolved = true;
-              clearTimeout(timeout);
-              resolve({ success: false, error: `WebSocket error: ${error.message}` });
-            }
-          });
-
-          ws.on("close", () => {
-            if (!resolved) {
-              resolved = true;
-              clearTimeout(timeout);
-              resolve({ success: false, error: "Connection closed unexpectedly" });
-            }
-          });
-
-          ws.on("message", (data) => {
-            try {
-              const message = JSON.parse(data.toString());
-
-              if (message.status === "completed" && message.video_data) {
-                // Save video to temp file
-                const tempDir = os.tmpdir();
-                const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-                const filename = `screenpipe_export_${timestamp}.mp4`;
-                const filePath = path.join(tempDir, filename);
-
-                fs.writeFileSync(filePath, Buffer.from(message.video_data));
-
-                resolved = true;
-                clearTimeout(timeout);
-                ws.close();
-                resolve({
-                  success: true,
-                  filePath,
-                  frameCount: frameIds.length,
-                });
-              } else if (message.status === "error") {
-                resolved = true;
-                clearTimeout(timeout);
-                ws.close();
-                resolve({ success: false, error: message.error || "Export failed" });
-              }
-              // Ignore "extracting" and "encoding" status updates
-            } catch (parseError) {
-              // Ignore parse errors for progress messages
-            }
-          });
-        });
-
-        if (exportResult.success && exportResult.filePath) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Successfully exported video!\n\n` +
-                  `File: ${exportResult.filePath}\n` +
-                  `Frames: ${exportResult.frameCount}\n` +
-                  `Time range: ${startTime} to ${endTime}\n` +
-                  `FPS: ${fps}`,
-              },
-            ],
-          };
-        } else {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Failed to export video: ${exportResult.error}`,
-              },
-            ],
-          };
-        }
-      }
-
       case "list-meetings": {
         const params = new URLSearchParams();
         for (const [key, value] of Object.entries(args)) {
@@ -982,20 +425,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
 
         const response = await fetchAPI(`/meetings?${params.toString()}`);
-        if (!response.ok) {
-          throw new Error(`HTTP error: ${response.status}`);
-        }
+        if (!response.ok) throw new Error(`HTTP error: ${response.status}`);
 
         const meetings = await response.json();
 
         if (!Array.isArray(meetings) || meetings.length === 0) {
           return {
-            content: [
-              {
-                type: "text",
-                text: "No meetings found. Make sure screenpipe is running in smart transcription mode.",
-              },
-            ],
+            content: [{ type: "text", text: "No meetings found in the given time range." }],
           };
         }
 
@@ -1010,10 +446,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
         return {
           content: [
-            {
-              type: "text",
-              text: `Meetings: ${meetings.length}\n\n${formatted.join("\n---\n")}`,
-            },
+            { type: "text", text: `Meetings: ${meetings.length}\n\n${formatted.join("\n---\n")}` },
           ],
         };
       }
@@ -1027,29 +460,31 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
 
         const response = await fetchAPI(`/activity-summary?${params.toString()}`);
-        if (!response.ok) {
-          throw new Error(`HTTP error: ${response.status}`);
-        }
+        if (!response.ok) throw new Error(`HTTP error: ${response.status}`);
 
         const data = await response.json();
 
-        // Format apps
         const appsLines = (data.apps || []).map(
-          (a: { name: string; frame_count: number; minutes: number; first_seen?: string; last_seen?: string }) => {
-            const timeSpan = a.first_seen && a.last_seen
-              ? `, ${a.first_seen.slice(11, 16)}–${a.last_seen.slice(11, 16)} UTC`
-              : "";
+          (a: {
+            name: string;
+            frame_count: number;
+            minutes: number;
+            first_seen?: string;
+            last_seen?: string;
+          }) => {
+            const timeSpan =
+              a.first_seen && a.last_seen
+                ? `, ${a.first_seen.slice(11, 16)}–${a.last_seen.slice(11, 16)} UTC`
+                : "";
             return `  ${a.name}: ${a.minutes} min (${a.frame_count} frames${timeSpan})`;
           }
         );
 
-        // Format audio
         const speakerLines = (data.audio_summary?.speakers || []).map(
           (s: { name: string; segment_count: number }) =>
             `  ${s.name}: ${s.segment_count} segments`
         );
 
-        // Format recent texts
         const textLines = (data.recent_texts || []).map(
           (t: { text: string; app_name: string; timestamp: string }) =>
             `  [${t.app_name}] ${t.text}`
@@ -1081,9 +516,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
 
         const response = await fetchAPI(`/elements?${params.toString()}`);
-        if (!response.ok) {
-          throw new Error(`HTTP error: ${response.status}`);
-        }
+        if (!response.ok) throw new Error(`HTTP error: ${response.status}`);
 
         const data = await response.json();
         const elements = data.data || [];
@@ -1131,21 +564,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case "frame-context": {
         const frameId = args.frame_id as number;
         if (!frameId) {
-          return {
-            content: [{ type: "text", text: "Error: frame_id is required" }],
-          };
+          return { content: [{ type: "text", text: "Error: frame_id is required" }] };
         }
 
         const response = await fetchAPI(`/frames/${frameId}/context`);
-        if (!response.ok) {
-          throw new Error(`HTTP error: ${response.status}`);
-        }
+        if (!response.ok) throw new Error(`HTTP error: ${response.status}`);
 
         const data = await response.json();
-
-        const lines = [
-          `Frame ${data.frame_id} (source: ${data.text_source})`,
-        ];
+        const lines = [`Frame ${data.frame_id} (source: ${data.text_source})`];
 
         if (data.urls?.length) {
           lines.push("", "URLs:", ...data.urls.map((u: string) => `  ${u}`));
@@ -1163,27 +589,227 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
 
         if (data.text) {
-          // Truncate to avoid massive outputs
-          const truncated = data.text.length > 2000 ? data.text.substring(0, 2000) + "..." : data.text;
+          const truncated =
+            data.text.length > 2000 ? data.text.substring(0, 2000) + "..." : data.text;
           lines.push("", "Full text:", truncated);
         }
 
         return { content: [{ type: "text", text: lines.join("\n") }] };
       }
 
+      case "export-video": {
+        const startTime = args.start_time as string;
+        const endTime = args.end_time as string;
+        const fps = (args.fps as number) || 1.0;
+
+        if (!startTime || !endTime) {
+          return {
+            content: [{ type: "text", text: "Error: start_time and end_time are required" }],
+          };
+        }
+
+        // Get frame IDs for the time range
+        const searchParams = new URLSearchParams({
+          content_type: "ocr",
+          start_time: startTime,
+          end_time: endTime,
+          limit: "10000",
+        });
+
+        const searchResponse = await fetchAPI(`/search?${searchParams.toString()}`);
+        if (!searchResponse.ok) {
+          throw new Error(`Failed to search for frames: HTTP ${searchResponse.status}`);
+        }
+
+        const searchData = await searchResponse.json();
+        const results = searchData.data || [];
+
+        if (results.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No screen recordings found between ${startTime} and ${endTime}.`,
+              },
+            ],
+          };
+        }
+
+        const frameIds: number[] = [];
+        const seenIds = new Set<number>();
+        for (const result of results) {
+          if (result.type === "OCR" && result.content?.frame_id) {
+            const frameId = result.content.frame_id;
+            if (!seenIds.has(frameId)) {
+              seenIds.add(frameId);
+              frameIds.push(frameId);
+            }
+          }
+        }
+
+        if (frameIds.length === 0) {
+          return {
+            content: [{ type: "text", text: "No valid frame IDs found (audio-only?)." }],
+          };
+        }
+
+        frameIds.sort((a, b) => a - b);
+
+        const wsUrl = `ws://localhost:${port}/frames/export?fps=${fps}`;
+
+        const exportResult = await new Promise<{
+          success: boolean;
+          filePath?: string;
+          error?: string;
+          frameCount?: number;
+        }>((resolve) => {
+          const ws = new WebSocket(wsUrl);
+          let resolved = false;
+
+          const timeout = setTimeout(() => {
+            if (!resolved) {
+              resolved = true;
+              ws.close();
+              resolve({ success: false, error: "Export timed out after 5 minutes" });
+            }
+          }, 5 * 60 * 1000);
+
+          ws.on("open", () => {
+            ws.send(JSON.stringify({ frame_ids: frameIds }));
+          });
+
+          ws.on("error", (error) => {
+            if (!resolved) {
+              resolved = true;
+              clearTimeout(timeout);
+              resolve({ success: false, error: `WebSocket error: ${error.message}` });
+            }
+          });
+
+          ws.on("close", () => {
+            if (!resolved) {
+              resolved = true;
+              clearTimeout(timeout);
+              resolve({ success: false, error: "Connection closed unexpectedly" });
+            }
+          });
+
+          ws.on("message", (data) => {
+            try {
+              const message = JSON.parse(data.toString());
+              if (message.status === "completed" && message.video_data) {
+                const tempDir = os.tmpdir();
+                const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+                const filename = `screenpipe_export_${timestamp}.mp4`;
+                const filePath = path.join(tempDir, filename);
+                fs.writeFileSync(filePath, Buffer.from(message.video_data));
+                resolved = true;
+                clearTimeout(timeout);
+                ws.close();
+                resolve({ success: true, filePath, frameCount: frameIds.length });
+              } else if (message.status === "error") {
+                resolved = true;
+                clearTimeout(timeout);
+                ws.close();
+                resolve({ success: false, error: message.error || "Export failed" });
+              }
+            } catch {
+              // Ignore parse errors for progress messages
+            }
+          });
+        });
+
+        if (exportResult.success && exportResult.filePath) {
+          return {
+            content: [
+              {
+                type: "text",
+                text:
+                  `Video exported: ${exportResult.filePath}\n` +
+                  `Frames: ${exportResult.frameCount} | ${startTime} → ${endTime} | ${fps} fps`,
+              },
+            ],
+          };
+        } else {
+          return {
+            content: [{ type: "text", text: `Export failed: ${exportResult.error}` }],
+          };
+        }
+      }
+
+      case "update-memory": {
+        if (args.delete && args.id) {
+          const response = await fetchAPI(`/memories/${args.id}`, { method: "DELETE" });
+          if (!response.ok) throw new Error(`HTTP error: ${response.status}`);
+          return { content: [{ type: "text", text: `Memory ${args.id} deleted.` }] };
+        }
+        if (args.id) {
+          const body: Record<string, unknown> = {};
+          if (args.content !== undefined) body.content = args.content;
+          if (args.tags !== undefined) body.tags = args.tags;
+          if (args.importance !== undefined) body.importance = args.importance;
+          if (args.source_context !== undefined) body.source_context = args.source_context;
+          const response = await fetchAPI(`/memories/${args.id}`, {
+            method: "PUT",
+            body: JSON.stringify(body),
+          });
+          if (!response.ok) throw new Error(`HTTP error: ${response.status}`);
+          const memory = await response.json();
+          return {
+            content: [{ type: "text", text: `Memory ${memory.id} updated: "${memory.content}"` }],
+          };
+        }
+        if (!args.content) {
+          return {
+            content: [{ type: "text", text: "Error: 'content' is required to create a memory" }],
+          };
+        }
+        const memoryBody: Record<string, unknown> = {
+          content: args.content,
+          source: "mcp",
+          tags: args.tags || [],
+          importance: args.importance ?? 0.5,
+        };
+        if (args.source_context) memoryBody.source_context = args.source_context;
+        const memoryResponse = await fetchAPI("/memories", {
+          method: "POST",
+          body: JSON.stringify(memoryBody),
+        });
+        if (!memoryResponse.ok) throw new Error(`HTTP error: ${memoryResponse.status}`);
+        const newMemory = await memoryResponse.json();
+        return {
+          content: [
+            { type: "text", text: `Memory created (id: ${newMemory.id}): "${newMemory.content}"` },
+          ],
+        };
+      }
+
+      case "send-notification": {
+        const notifBody: Record<string, unknown> = {
+          title: args.title,
+          pipe_name: args.pipe_name,
+        };
+        if (args.body) notifBody.body = args.body;
+        if (args.timeout_secs) notifBody.timeout_secs = args.timeout_secs;
+        if (args.actions) notifBody.actions = args.actions;
+        const notifResponse = await fetchAPI("/notify", {
+          method: "POST",
+          body: JSON.stringify(notifBody),
+        });
+        if (!notifResponse.ok) throw new Error(`HTTP error: ${notifResponse.status}`);
+        const notifResult = await notifResponse.json();
+        return {
+          content: [{ type: "text", text: `Notification sent (id: ${notifResult.id})` }],
+        };
+      }
+
       default:
         throw new Error(`Unknown tool: ${name}`);
     }
   } catch (error) {
-    const errorMessage =
-      error instanceof Error ? error.message : "Unknown error";
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
     return {
-      content: [
-        {
-          type: "text",
-          text: `Error executing ${name}: ${errorMessage}`,
-        },
-      ],
+      content: [{ type: "text", text: `Error executing ${name}: ${errorMessage}` }],
     };
   }
 });