exovault-mcp-server 1.1.1 → 1.2.0

package/dist/db.d.ts

@@ -191,6 +191,22 @@ export declare function matchNotesByBlindTokens(supabase: SupabaseClient, tokenH
 export declare function getNotesByIds(supabase: SupabaseClient, userId: string, noteIds: string[]): Promise<NoteRow[]>;
 export declare function getNoteByImportSource(supabase: SupabaseClient, userId: string, vaultId: string, importSource: string, importSourceId: string): Promise<NoteRow | null>;
 export declare function getMemoriesByIds(supabase: SupabaseClient, userId: string, memoryIds: string[]): Promise<MemoryRow[]>;
+export interface MediaAttachmentRow {
+    id: string;
+    memory_id: string | null;
+    note_id: string | null;
+    modality: string;
+    mime_type: string;
+    file_name: string | null;
+    file_size_bytes: number;
+    embedding_status: string;
+    extracted_text: string | null;
+    extracted_text_iv: string | null;
+    extraction_status: string;
+}
+export declare function getAttachmentsForMemories(supabase: SupabaseClient, userId: string, memoryIds: string[]): Promise<MediaAttachmentRow[]>;
+export declare function getAttachmentsForNotes(supabase: SupabaseClient, userId: string, noteIds: string[]): Promise<MediaAttachmentRow[]>;
+export declare function formatAttachmentWithExtraction(att: MediaAttachmentRow, decryptedText: string | null, truncate?: number): string;
 export interface ActiveAgentRow {
     agentId: string;
     modelId: string | null;

package/dist/db.js

@@ -372,6 +372,40 @@ export async function getMemoriesByIds(supabase, userId, memoryIds) {
         throw new Error(sanitizeDbError("fetch memories by IDs", error.message));
     return (data ?? []);
 }
+export async function getAttachmentsForMemories(supabase, userId, memoryIds) {
+    if (memoryIds.length === 0)
+        return [];
+    const { data, error } = await supabase
+        .from("media_attachments")
+        .select("id, memory_id, note_id, modality, mime_type, file_name, file_size_bytes, embedding_status, extracted_text, extracted_text_iv, extraction_status")
+        .eq("user_id", userId)
+        .in("memory_id", memoryIds);
+    if (error)
+        throw new Error(sanitizeDbError("fetch attachments", error.message));
+    return (data ?? []);
+}
+export async function getAttachmentsForNotes(supabase, userId, noteIds) {
+    if (noteIds.length === 0)
+        return [];
+    const { data, error } = await supabase
+        .from("media_attachments")
+        .select("id, memory_id, note_id, modality, mime_type, file_name, file_size_bytes, embedding_status, extracted_text, extracted_text_iv, extraction_status")
+        .eq("user_id", userId)
+        .in("note_id", noteIds);
+    if (error)
+        throw new Error(sanitizeDbError("fetch note attachments", error.message));
+    return (data ?? []);
+}
+export function formatAttachmentWithExtraction(att, decryptedText, truncate) {
+    let text = decryptedText;
+    if (text && truncate)
+        text = text.slice(0, truncate);
+    return [
+        `[${att.modality}] ${att.file_name ?? "unnamed"} (${att.mime_type}, ${att.file_size_bytes}B)`,
+        `  embedding: ${att.embedding_status}, extraction: ${att.extraction_status}`,
+        text ? `  content: ${text}` : null,
+    ].filter(Boolean).join("\n");
+}
 export async function getActiveAgents(supabase, userId, sinceDays = 30, limit = 20) {
     const since = new Date();
     since.setDate(since.getDate() - sinceDays);

package/dist/embedding-config.d.ts

@@ -1,11 +1,10 @@
 import type { McpContext } from "./auth.js";
 export interface EmbeddingConfig {
     apiKey: string;
-    baseUrl: string;
     model: string;
 }
 /**
  * Resolve embedding API configuration from env vars or MCP context.
- * Priority: env vars > ctx.openaiApiKey > null.
+ * Priority: env vars > ctx.geminiApiKey > ctx.openaiApiKey > null.
  */
 export declare function resolveEmbeddingConfig(ctx: McpContext): EmbeddingConfig | null;

package/dist/embedding-config.js

@@ -1,23 +1,24 @@
-const OPENAI_EMBEDDING_MODEL = "text-embedding-3-small";
+const DEFAULT_EMBEDDING_MODEL = "gemini-embedding-2-preview";
 /**
  * Resolve embedding API configuration from env vars or MCP context.
- * Priority: env vars > ctx.openaiApiKey > null.
+ * Priority: env vars > ctx.geminiApiKey > ctx.openaiApiKey > null.
  */
 export function resolveEmbeddingConfig(ctx) {
-    const envApiKey = process.env.EMBEDDING_API_KEY ??
-        process.env.OPENAI_API_KEY;
+    const envApiKey = process.env.EXO_GEMINI_KEY ??
+        process.env.GEMINI_API_KEY ??
+        process.env.EMBEDDING_API_KEY;
     if (envApiKey) {
         return {
             apiKey: envApiKey,
-            baseUrl: process.env.EMBEDDING_BASE_URL ?? "https://api.openai.com/v1",
-            model: process.env.EMBEDDING_MODEL ?? OPENAI_EMBEDDING_MODEL,
+            model: process.env.EMBEDDING_MODEL ?? DEFAULT_EMBEDDING_MODEL,
         };
     }
-    if (ctx.openaiApiKey) {
+    // Fallback to MCP context keys
+    const ctxKey = ctx.geminiApiKey ?? ctx.openaiApiKey;
+    if (ctxKey && typeof ctxKey === "string") {
         return {
-            apiKey: ctx.openaiApiKey,
-            baseUrl: "https://api.openai.com/v1",
-            model: OPENAI_EMBEDDING_MODEL,
+            apiKey: ctxKey,
+            model: DEFAULT_EMBEDDING_MODEL,
         };
     }
     return null;

package/dist/gateway-client.d.ts

@@ -134,8 +134,28 @@ export declare class GatewayClient {
     readNotes(noteIds: string[]): Promise<string>;
     searchNotes(params: {
         query: string;
+        topK?: number;
+        threshold?: number;
+        searchMode?: "auto" | "hybrid" | "bm25" | "semantic";
+        diversity?: number;
         vaultId?: string;
-        limit?: number;
+        includeContent?: boolean;
+        compact?: boolean;
+    }): Promise<string>;
+    search(params: {
+        query: string;
+        topK?: number;
+        threshold?: number;
+        searchMode?: "auto" | "hybrid" | "bm25" | "semantic";
+        diversity?: number;
+        vaultId?: string;
+        includeContent?: boolean;
+        compact?: boolean;
+        scope?: "all" | "memories" | "notes";
+        memoryType?: string;
+        entity?: string;
+        includeArchived?: boolean;
+        decayHalfLife?: number;
     }): Promise<string>;
     createNote(params: {
         vaultId?: string;
@@ -151,17 +171,6 @@ export declare class GatewayClient {
         tags?: string[];
     }): Promise<string>;
     deleteNote(noteId: string): Promise<string>;
-    semanticSearch(params: {
-        query: string;
-        topK?: number;
-        threshold?: number;
-        vaultId?: string;
-    }): Promise<string>;
-    searchAndRead(params: {
-        query: string;
-        maxNotes?: number;
-        vaultId?: string;
-    }): Promise<string>;
     listFolders(params: {
         vaultId?: string;
     }): Promise<string>;
@@ -310,4 +319,24 @@ export declare class GatewayClient {
         documentType: "instructions" | "skills" | "checks";
         appendContent: string;
     }): Promise<string>;
+    attachMedia(params: {
+        fileBytes: Uint8Array;
+        fileName: string;
+        mimeType: string;
+        memoryId?: string;
+        vaultId?: string;
+    }): Promise<string>;
+    downloadMedia(params: {
+        attachmentId: string;
+    }): Promise<{
+        attachmentId: string;
+        memoryId: string | null;
+        modality: string;
+        mimeType: string;
+        fileName: string | null;
+        fileSizeBytes: number;
+        embeddingStatus: string;
+        base64Content: string;
+    }>;
+    deleteMedia(attachmentId: string, vaultId?: string): Promise<string>;
 }

package/dist/gateway-client.js

@@ -154,8 +154,12 @@ export class GatewayClient {
         return JSON.stringify(result);
     }
     async searchNotes(params) {
-        const result = await this.request("POST", "/api/agent/search-notes", params);
-        return JSON.stringify(result);
+        const data = await this.request("POST", "/api/agent/search-notes", params);
+        return JSON.stringify(data, null, 2);
+    }
+    async search(params) {
+        const data = await this.request("POST", "/api/agent/search", params);
+        return JSON.stringify(data, null, 2);
     }
     async createNote(params) {
         const result = await this.request("POST", "/api/agent/create-note", params);
@@ -169,14 +173,6 @@ export class GatewayClient {
         const result = await this.request("POST", "/api/agent/delete-note", { noteId });
         return JSON.stringify(result);
     }
-    async semanticSearch(params) {
-        const result = await this.request("POST", "/api/agent/semantic-search", params);
-        return JSON.stringify(result);
-    }
-    async searchAndRead(params) {
-        const result = await this.request("POST", "/api/agent/search-and-read", params);
-        return JSON.stringify(result);
-    }
     // ─── Folder operations ──────────────────────────────────────────────────
     async listFolders(params) {
         const result = await this.request("POST", "/api/agent/list-folders", params);
@@ -287,4 +283,51 @@ export class GatewayClient {
         const result = await this.request("POST", "/api/agent/update-document", params);
         return JSON.stringify(result);
     }
+    // ─── Media operations ───────────────────────────────────────────────────────
+    async attachMedia(params) {
+        const url = `${this.baseUrl}/api/agent/attach-media`;
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+        };
+        if (this.sessionRunId) {
+            headers["X-Agent-Run-Id"] = this.sessionRunId;
+        }
+        // Build multipart form data
+        const formData = new FormData();
+        const ab = params.fileBytes.buffer.slice(params.fileBytes.byteOffset, params.fileBytes.byteOffset + params.fileBytes.byteLength);
+        const blob = new Blob([ab], { type: params.mimeType });
+        formData.append("file", blob, params.fileName);
+        if (params.memoryId)
+            formData.append("memoryId", params.memoryId);
+        if (params.vaultId)
+            formData.append("vaultId", params.vaultId);
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: formData,
+        });
+        if (!response.ok) {
+            let errorBody;
+            try {
+                errorBody = await response.json();
+            }
+            catch {
+                errorBody = null;
+            }
+            const message = errorBody?.error ?? `Gateway returned ${response.status}`;
+            throw new GatewayError(message, response.status, errorBody);
+        }
+        const result = await response.json();
+        return JSON.stringify(result);
+    }
+    async downloadMedia(params) {
+        return this.request("POST", "/api/agent/download-media", params);
+    }
+    async deleteMedia(attachmentId, vaultId) {
+        const body = { attachmentId };
+        if (vaultId)
+            body.vaultId = vaultId;
+        const res = await this.request("POST", "/api/agent/delete-media", body);
+        return JSON.stringify(res);
+    }
 }

package/dist/index.js

@@ -12,8 +12,6 @@ import { listNotes } from "./tools/list-notes.js";
 import { readNote } from "./tools/read-note.js";
 import { readNotes } from "./tools/read-notes.js";
 import { searchNotes } from "./tools/search-notes.js";
-import { semanticSearch } from "./tools/semantic-search.js";
-import { searchAndRead } from "./tools/search-and-read.js";
 import { createNote } from "./tools/create-note.js";
 import { updateNote } from "./tools/update-note.js";
 import { deleteNote } from "./tools/delete-note.js";
@@ -30,6 +28,7 @@ import { cleanupMemories } from "./tools/cleanup-memories.js";
 import { getLinks, addLink, removeLink } from "./tools/knowledge-links.js";
 import { exploreGraph } from "./tools/explore-graph.js";
 import { recall } from "./tools/recall.js";
+import { search } from "./tools/search.js";
 import { sendMessage, ackMessage, readMessages } from "./tools/agent-messages.js";
 // Task tools are thin wrappers around memory tools — no separate agent-tasks import needed
 import { resolveVaultId } from "./tools/resolve-vault-id.js";
@@ -371,7 +370,7 @@ async function main() {
     if (gw) {
         instructionLines.push("Running in gateway mode. Turn ingestion is automatic.");
     }
-    instructionLines.push("", "## Tasks", "`create_task` (title, description, status, priority, assignedAgentId, doneWhen). `update_task` to change status. `list_tasks` to view.", "Set `doneWhen` for auto-detect completion. Tasks are memories with memoryType='task'.", "assignedAgentId: null=unassigned, 'any'=any agent, '<type>'=specific. Check assigned tasks at session start.", "", "## Messages", "Pending messages from users/agents appear in `session_start` and `context_checkpoint` responses under `pendingMessages`.", "**When you receive a message**: respond with `send_message(targetId: 'user', content: '...', parentMessageId: '<message.id>')` to reply in-thread.", "`ack_message(messageId)` to acknowledge without replying. `read_messages(agentId)` to fetch messages on demand.", "", "## Memory Protocol", "1. Scope to vaultId. 2. SEARCH FIRST before writing/answering. 3. externalWriteId for idempotency.", "4. Set importance+confidence (1-5). 5. Extract entities. 6. relatedMemoryIds for links. 7. supersededById for corrections.", "Types: fact, skill, preference, constraint, task, episodic, correction. Always set dedup:true, agentId, agentRunId.", "", "## Retrieval Tools (pick the right one)", "- `search_memories` — hybrid search. Use compact:true, then read_memories for full content.", "- `explore_graph` — **PREFERRED for deep retrieval**. query/nodeId → multi-hop graph map (nodes+edges). Then read_memories/read_note for full content. Zero LLM cost.", "- `semantic_search` — vector similarity across notes+memories.", "- `search_and_read` — search + auto-read in one call.", "- `get_links` / `get_related_memories` — single-hop link traversal.", "- `read_document` — vault docs (instructions, skills, checks).");
+    instructionLines.push("", "## Tasks", "`create_task` (title, description, status, priority, assignedAgentId, doneWhen). `update_task` to change status. `list_tasks` to view.", "Set `doneWhen` for auto-detect completion. Tasks are memories with memoryType='task'.", "assignedAgentId: null=unassigned, 'any'=any agent, '<type>'=specific. Check assigned tasks at session start.", "", "## Messages", "Pending messages from users/agents appear in `session_start` and `context_checkpoint` responses under `pendingMessages`.", "**When you receive a message**: respond with `send_message(targetId: 'user', content: '...', parentMessageId: '<message.id>')` to reply in-thread.", "`ack_message(messageId)` to acknowledge without replying. `read_messages(agentId)` to fetch messages on demand.", "", "## Memory Protocol", "1. Scope to vaultId. 2. SEARCH FIRST before writing/answering. 3. externalWriteId for idempotency.", "4. Set importance+confidence (1-5). 5. Extract entities. 6. relatedMemoryIds for links. 7. supersededById for corrections.", "Types: fact, skill, preference, constraint, task, episodic, correction. Always set dedup:true, agentId, agentRunId.", "", "## Retrieval Tools (pick the right one)", "- `search` — **universal search** across memories+notes with cross-type MMR. Set scope='all' (default), 'memories', or 'notes'.", "- `search_memories` — hybrid search memories only. Use compact:true, then read_memories for full content.", "- `search_notes` — hybrid search notes only. Use includeContent:true for full content, or read_notes for specific IDs.", "- `explore_graph` — **PREFERRED for deep retrieval**. query/nodeId → multi-hop graph map (nodes+edges). Then read_memories/read_note for full content. Zero LLM cost.", "- `get_links` / `get_related_memories` — single-hop link traversal.", "- `read_document` — vault docs (instructions, skills, checks).");
     const instructionsText = instructionLines.join("\n");
     // ── Guard: keep instructions ≤4,000 chars ─────────────────────────
     const INSTRUCTION_CHAR_LIMIT = 4_000;
@@ -438,17 +437,22 @@ async function main() {
     })));
     // ─── search_notes ─────────────────────────────────────────────────────────
     server.registerTool("search_notes", {
-        description: "Search notes by keyword. Weighted: 3x title, 2x tags, 1x content. Returns scored results.",
+        description: "Search notes using 4-signal hybrid scoring (semantic + BM25 + blind index + graph) with RRF fusion and MMR diversity. Gateway mode uses server-side pipeline; direct mode uses local Supabase queries. Use includeContent:true to get full note content inline, or follow up with read_notes for specific IDs. Consider `search` tool (scope='notes') for unified cross-type results.",
         inputSchema: {
-            query: s(z.string().min(1).describe("Search query")),
+            query: s(z.string().min(1).describe("Search query (natural language or keywords)")),
+            topK: s(z.number().int().min(1).max(50).optional().describe("Max results (default 10)")),
+            threshold: s(z.number().min(0).max(1).optional().describe("Minimum similarity threshold 0-1 (default 0.5)")),
+            searchMode: s(z.enum(["auto", "hybrid", "bm25", "semantic"]).optional().describe("Search mode: auto (default), hybrid, bm25, or semantic")),
+            diversity: s(z.number().min(0).max(1).optional().describe("MMR diversity balance 0-1 (default 0.7). Higher = more relevance, lower = more diversity.")),
             vaultId: s(z.string().uuid().optional().describe("Limit search to a specific vault")),
-            limit: s(z.number().int().min(1).max(50).optional().describe("Max results (default 10)")),
+            includeContent: s(z.boolean().optional().describe("Include full note content in results (default false, returns preview only)")),
+            compact: s(z.boolean().optional().describe("Return shorter previews (200 chars instead of 500)")),
         },
     }, auto.wrap(wrapToolHandler(async (args) => {
-        const { query, vaultId, limit } = args;
+        const input = args;
         return gw
-            ? await gw.searchNotes({ query, vaultId: resolveVault(vaultId), limit })
-            : await searchNotes(ctx, query, resolveVaultId(ctx, vaultId), limit);
+            ? await gw.searchNotes({ ...input, vaultId: resolveVault(input.vaultId) })
+            : await searchNotes(ctx, { ...input, vaultId: resolveVaultId(ctx, input.vaultId) });
     })));
     // ─── create_note ──────────────────────────────────────────────────────────
     server.registerTool("create_note", {
@@ -549,35 +553,6 @@ async function main() {
         const { noteIds } = args;
         return gw ? await gw.readNotes(noteIds) : await readNotes(ctx, noteIds);
     })));
-    // ─── semantic_search ────────────────────────────────────────────────────
-    server.registerTool("semantic_search", {
-        description: "Search notes by meaning using vector embeddings. Finds conceptually similar content even without exact keyword matches. Requires OpenAI API key in config.",
-        inputSchema: {
-            query: s(z.string().min(1).describe("Natural language search query")),
-            topK: s(z.number().int().min(1).max(50).optional().describe("Max results (default 10)")),
-            threshold: s(z.number().min(0).max(1).optional().describe("Minimum similarity threshold 0-1 (default 0.5)")),
-            vaultId: s(z.string().uuid().optional().describe("Vault to search within. Uses default vault if omitted.")),
-        },
-    }, auto.wrap(wrapToolHandler(async (args) => {
-        const { query, topK, threshold, vaultId } = args;
-        return gw
-            ? await gw.semanticSearch({ query, topK, threshold, vaultId: resolveVault(vaultId) })
-            : await semanticSearch(ctx, query, topK, threshold);
-    })));
-    // ─── search_and_read ────────────────────────────────────────────────────
-    server.registerTool("search_and_read", {
-        description: "Search notes using hybrid scoring (70% semantic + 30% keyword) and return the full content of top matches. Falls back to keyword-only if no OpenAI key, and to recency if no matches found. Best for gathering all relevant content on a topic.",
-        inputSchema: {
-            query: s(z.string().min(1).describe("Search query (natural language or keywords)")),
-            maxNotes: s(z.number().int().min(1).max(20).optional().describe("Max notes to return (default 5)")),
-            vaultId: s(z.string().uuid().optional().describe("Vault to search within. Uses default vault if omitted.")),
-        },
-    }, auto.wrap(wrapToolHandler(async (args) => {
-        const { query, maxNotes, vaultId } = args;
-        return gw
-            ? await gw.searchAndRead({ query, maxNotes, vaultId: resolveVault(vaultId) })
-            : await searchAndRead(ctx, query, maxNotes);
-    })));
     // ─── write_memory ───────────────────────────────────────────────────────────
     server.registerTool("write_memory", {
         description: "Create or upsert a durable memory entry.\n\nMemory types: fact (durable knowledge, importance 3-5), skill (procedures/how-tos, 3-5), preference (user style/choices, 2-4), constraint (hard rules/limits, 4-5), task (active work items, 2-4), episodic (session summaries, 1-3), correction (superseded knowledge — always set supersededById, 3-5).\n\nImportance scale: 5=critical, 4=important, 3=standard (default), 2=supplementary, 1=low-value. Confidence scale: 5=verified, 4=observed multiple times, 3=reasonable inference (default), 2=uncertain, 1=speculative.\n\nRelationship fields: relatedMemoryIds links to related memories (derived_from, contradicts, refines, part_of, supersedes). sourceNoteIds links to source notes. supersededById points to the memory this one replaces. entities array enables cross-linking.\n\nServer dedup (dedup: true): >92% similarity = skip, >80% = supersede old, <80% = create new.",
@@ -638,6 +613,31 @@ async function main() {
         }
         return await searchMemories(ctx, { ...input, vaultId: resolveVaultId(ctx, input.vaultId) });
     })));
+    // ─── search (universal) ─────────────────────────────────────────────────────
+    server.registerTool("search", {
+        description: "Universal search across both memories and notes. Set scope to 'all' (default) for cross-type MMR-ranked results, 'memories' for memories only, or 'notes' for notes only. In gateway mode, delegates to the server for full cross-type MMR re-ranking. In direct mode, best-effort interleave.",
+        inputSchema: {
+            query: s(z.string().min(1).describe("Natural language search query")),
+            topK: s(z.number().int().min(1).max(50).optional().describe("Max results (default 10)")),
+            threshold: s(z.number().min(0).max(1).optional().describe("Similarity threshold 0-1 (default 0.5)")),
+            searchMode: s(z.enum(["auto", "hybrid", "bm25", "semantic"]).optional().describe("Search mode (default: auto)")),
+            diversity: s(z.number().min(0).max(1).optional().describe("MMR diversity balance 0-1 (default 0.7)")),
+            vaultId: s(z.string().uuid().optional().describe("Vault filter")),
+            includeContent: s(z.boolean().optional().describe("Include full note content (default false)")),
+            compact: s(z.boolean().optional().describe("Return shorter previews")),
+            scope: s(z.enum(["all", "memories", "notes"]).optional().describe("Search scope: all (default), memories, or notes")),
+            memoryType: s(z.string().optional().describe("Filter by memory type (memories scope only)")),
+            entity: s(z.string().optional().describe("Search by entity name (memories scope only)")),
+            includeArchived: s(z.boolean().optional().describe("Include archived memories (default false)")),
+            decayHalfLife: s(z.number().int().min(1).max(365).optional().describe("Temporal decay half-life in days (default 30)")),
+        },
+    }, auto.wrap(wrapToolHandler(async (args) => {
+        const input = args;
+        if (gw) {
+            return await gw.search({ ...input, vaultId: resolveVault(input.vaultId) });
+        }
+        return await search(ctx, { ...input, vaultId: resolveVaultId(ctx, input.vaultId) });
+    })));
     // ─── read_memories ──────────────────────────────────────────────────────────
     server.registerTool("read_memories", {
         description: "Read and decrypt full memory entries by IDs.",
@@ -1221,6 +1221,55 @@ async function main() {
         }
         return await recall(ctx, { ...input, vaultId: resolveVaultId(ctx, input.vaultId) });
     })));
+    // ─── attach_media ──────────────────────────────────────────────────────────
+    server.registerTool("attach_media", {
+        description: "Attach a media file (image, PDF, audio, video) to a memory for multimodal embedding. The file is encrypted at rest and embedded via Gemini for cross-modal search. Accepts base64-encoded file content.\n\nSupported types: images (PNG, JPEG, WebP, GIF — 20MB), documents (PDF — 50MB), audio (MP3, WAV, OGG, WebM — 50MB), video (MP4, WebM, QuickTime — 20MB). SVG is not supported.\n\nPer-user storage quota applies (free tier: 100MB).",
+        inputSchema: {
+            fileBase64: s(z.string().min(1).describe("Base64-encoded file content")),
+            fileName: s(z.string().min(1).describe("Original file name with extension")),
+            mimeType: s(z.string().min(1).describe("MIME type (e.g. image/png, application/pdf, audio/mpeg, video/mp4)")),
+            memoryId: s(z.string().uuid().optional().describe("Memory to attach this media to")),
+            vaultId: s(z.string().uuid().optional().describe("Vault scope")),
+        },
+    }, auto.wrap(wrapToolHandler(async (args) => {
+        const input = args;
+        if (!gw)
+            throw new Error("attach_media requires gateway mode (agent key)");
+        const fileBytes = Buffer.from(input.fileBase64, "base64");
+        return await gw.attachMedia({
+            fileBytes: new Uint8Array(fileBytes),
+            fileName: input.fileName,
+            mimeType: input.mimeType,
+            memoryId: input.memoryId,
+            vaultId: resolveVault(input.vaultId),
+        });
+    })));
+    // ─── download_media ───────────────────────────────────────────────────────
+    server.registerTool("download_media", {
+        description: "Download and decrypt a media attachment by ID. Returns base64-encoded file content with metadata.",
+        inputSchema: {
+            attachmentId: s(z.string().uuid().describe("Media attachment ID to download")),
+        },
+    }, auto.wrap(wrapToolHandler(async (args) => {
+        const { attachmentId } = args;
+        if (!gw)
+            throw new Error("download_media requires gateway mode (agent key)");
+        const result = await gw.downloadMedia({ attachmentId });
+        return JSON.stringify(result);
+    })));
+    // ─── delete_media ───────────────────────────────────────────────────────
+    server.registerTool("delete_media", {
+        description: "Delete a media attachment and its embedding. Permanently removes the file from storage.",
+        inputSchema: {
+            attachmentId: s(z.string().uuid().describe("The attachment ID to delete")),
+            vaultId: s(z.string().uuid().optional().describe("Optional vault scope")),
+        },
+    }, auto.wrap(wrapToolHandler(async (args) => {
+        const { attachmentId, vaultId } = args;
+        if (!gw)
+            throw new Error("delete_media requires gateway mode (agent key)");
+        return await gw.deleteMedia(attachmentId, vaultId);
+    })));
     // ─── Orphan recovery — flush crashed sessions from previous runs ─────────
     try {
         const orphans = await scanOrphanedBuffers(10);

package/dist/openai.d.ts

@@ -1,12 +1,14 @@
 /**
- * Generates one query embedding using OpenAI text-embedding-3-small.
+ * Generates one query embedding using Gemini.
+ * Used in direct mode for semantic search queries.
  */
 export declare function generateQueryEmbedding(text: string, apiKey: string, options?: {
     model?: string;
     baseUrl?: string;
 }): Promise<number[]>;
 /**
- * Generates multiple embeddings in one request when possible.
+ * Generates multiple embeddings in one request.
+ * Used in direct mode for bulk embedding operations.
  */
 export declare function generateEmbeddings(values: string[], apiKey: string, options?: {
     model?: string;

package/dist/openai.js

@@ -1,43 +1,47 @@
-import { sanitizeApiError } from "./error-sanitizer.js";
-const DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small";
-const DEFAULT_EMBEDDING_BASE_URL = "https://api.openai.com/v1";
-async function requestEmbeddings(input, apiKey, options) {
-    const baseUrl = (options?.baseUrl ?? DEFAULT_EMBEDDING_BASE_URL).replace(/\/$/, "");
+import { GoogleGenAI } from "@google/genai";
+const DEFAULT_EMBEDDING_MODEL = "gemini-embedding-2-preview";
+const DEFAULT_DIMS = 3072;
+/**
+ * Generates one query embedding using Gemini.
+ * Used in direct mode for semantic search queries.
+ */
+export async function generateQueryEmbedding(text, apiKey, options) {
+    const ai = new GoogleGenAI({ apiKey });
     const model = options?.model ?? DEFAULT_EMBEDDING_MODEL;
-    const response = await fetch(`${baseUrl}/embeddings`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${apiKey}`,
+    const response = await ai.models.embedContent({
+        model,
+        contents: [text],
+        config: {
+            outputDimensionality: DEFAULT_DIMS,
+            taskType: "RETRIEVAL_QUERY",
         },
-        body: JSON.stringify({
-            model,
-            input,
-        }),
     });
-    if (!response.ok) {
-        const body = await response.text();
-        throw new Error(sanitizeApiError(response.status, body));
+    const embeddings = response.embeddings ?? [];
+    if (embeddings.length === 0) {
+        throw new Error("Gemini returned unexpected response: no embedding data");
     }
-    const json = (await response.json());
-    const vectors = json.data?.map((d) => d.embedding).filter(Boolean) ?? [];
-    if (vectors.length === 0) {
-        throw new Error("OpenAI returned unexpected response: no embedding data");
-    }
-    return vectors;
-}
-/**
- * Generates one query embedding using OpenAI text-embedding-3-small.
- */
-export async function generateQueryEmbedding(text, apiKey, options) {
-    const vectors = await requestEmbeddings(text, apiKey, options);
-    return vectors[0];
+    return embeddings[0].values;
 }
 /**
- * Generates multiple embeddings in one request when possible.
+ * Generates multiple embeddings in one request.
+ * Used in direct mode for bulk embedding operations.
  */
 export async function generateEmbeddings(values, apiKey, options) {
     if (values.length === 0)
         return [];
-    return requestEmbeddings(values, apiKey, options);
+    const ai = new GoogleGenAI({ apiKey });
+    const model = options?.model ?? DEFAULT_EMBEDDING_MODEL;
+    const response = await ai.models.embedContent({
+        model,
+        contents: values,
+        config: {
+            outputDimensionality: DEFAULT_DIMS,
+            taskType: "RETRIEVAL_DOCUMENT",
+        },
+    });
+    const embeddings = response.embeddings ?? [];
+    if (embeddings.length === 0) {
+        throw new Error("Gemini returned unexpected response: no embedding data");
+    }
+    return embeddings.map((e) => e.values);
 }

package/dist/rlm/actions.js

@@ -61,7 +61,8 @@ function compactReadMemories(raw) {
 function compactSearchNotes(raw) {
     try {
         const data = JSON.parse(raw);
-        const results = Array.isArray(data) ? data : [];
+        // searchNotes returns { searchMode, blindIndexMatchCount, notes: [...] }
+        const results = Array.isArray(data.notes) ? data.notes : (Array.isArray(data) ? data : []);
         return JSON.stringify(results.map((n) => ({
             id: n.id,
             title: n.title,
@@ -194,7 +195,7 @@ export function buildToolDefinitions(ctx, state, vaultId) {
                         advice: "Read existing note hits or call finish().",
                     });
                 }
-                const raw = await searchNotes(ctx, query, vaultId, limit ?? state.tuning.noteSearchTopK);
+                const raw = await searchNotes(ctx, { query, vaultId, topK: limit ?? state.tuning.noteSearchTopK });
                 return compactSearchNotes(raw);
             },
         }),

package/dist/scripts/backfill-memory-embeddings.js

@@ -4,9 +4,8 @@ import { initialize } from "../auth.js";
 import { decrypt } from "../crypto.js";
 import { replaceMemoryEmbeddings, updateMemory } from "../db.js";
 import { generateEmbeddings } from "../openai.js";
-const OPENAI_EMBEDDING_MODEL = "text-embedding-3-small";
-const DEEPSEEK_EMBEDDING_MODEL = "deepseek-embedding";
-const VECTOR_DIMS = 1536;
+const DEFAULT_EMBEDDING_MODEL = "gemini-embedding-2-preview";
+const VECTOR_DIMS = 3072;
 const CHARS_PER_TOKEN = 4;
 const CHUNK_TARGET_CHARS = 2400;
 const CHUNK_OVERLAP_CHARS = 400;
@@ -58,31 +57,18 @@ async function loadBackfillCandidates(ctx, limit) {
 async function main() {
     const ctx = await initialize();
     const limit = parseLimitArg();
-    const envApiKey = process.env.RLM_EMBEDDING_API_KEY ??
+    const apiKey = process.env.EXO_GEMINI_KEY ??
+        process.env.GEMINI_API_KEY ??
         process.env.EMBEDDING_API_KEY ??
-        process.env.OPENAI_API_KEY;
-    const embeddingConfig = envApiKey
-        ? {
-            apiKey: envApiKey,
-            baseUrl: process.env.RLM_EMBEDDING_BASE_URL ?? process.env.EMBEDDING_BASE_URL ?? "https://api.openai.com/v1",
-            model: process.env.RLM_EMBEDDING_MODEL ?? process.env.EMBEDDING_MODEL ?? OPENAI_EMBEDDING_MODEL,
-        }
-        : ctx.openaiApiKey
-            ? {
-                apiKey: ctx.openaiApiKey,
-                baseUrl: "https://api.openai.com/v1",
-                model: OPENAI_EMBEDDING_MODEL,
-            }
-            : ctx.llmConfig
-                ? {
-                    apiKey: ctx.llmConfig.apiKey,
-                    baseUrl: ctx.llmConfig.baseUrl,
-                    model: process.env.RLM_EMBEDDING_MODEL ?? DEEPSEEK_EMBEDDING_MODEL,
-                }
-                : null;
-    if (!embeddingConfig) {
-        throw new Error("No embedding-capable key found in MCP config (openaiApiKey or llmApiKey).");
+        ctx.geminiApiKey ??
+        ctx.openaiApiKey;
+    if (!apiKey) {
+        throw new Error("No EXO_GEMINI_KEY or GEMINI_API_KEY found.");
     }
+    const embeddingConfig = {
+        apiKey,
+        model: process.env.EMBEDDING_MODEL ?? DEFAULT_EMBEDDING_MODEL,
+    };
     const candidates = await loadBackfillCandidates(ctx, limit);
     if (candidates.length === 0) {
         process.stdout.write("No candidate memories found for backfill.\n");
@@ -110,10 +96,7 @@ async function main() {
                 indexing_status: "embedding",
                 indexing_error: null,
             });
-            const vectors = await generateEmbeddings(chunks.map((c) => c.text), embeddingConfig.apiKey, {
-                baseUrl: embeddingConfig.baseUrl,
-                model: embeddingConfig.model,
-            });
+            const vectors = await generateEmbeddings(chunks.map((c) => c.text), embeddingConfig.apiKey, { model: embeddingConfig.model });
             const badVector = vectors.find((v) => v.length !== VECTOR_DIMS);
             if (badVector) {
                 throw new Error(`embedding_dimensions_mismatch expected=${VECTOR_DIMS} got=${badVector.length} model=${embeddingConfig.model}`);

package/dist/tools/explore-graph.js

@@ -63,7 +63,7 @@ export async function exploreGraph(ctx, input) {
                 error: "No embedding configuration available. Set openaiApiKey in config or EMBEDDING_API_KEY env var.",
             });
         }
-        const embedding = await generateQueryEmbedding(query, embeddingConfig.apiKey, { baseUrl: embeddingConfig.baseUrl, model: embeddingConfig.model });
+        const embedding = await generateQueryEmbedding(query, embeddingConfig.apiKey, { model: embeddingConfig.model });
         // Search both memory and note embeddings in parallel
         const [memoryMatches, noteMatches] = await Promise.all([
             matchMemoryEmbeddings(ctx.supabase, embedding, ctx.userId, SEMANTIC_THRESHOLD, SEMANTIC_TOP_K),

package/dist/tools/read-memories.js

@@ -1,12 +1,38 @@
-import { getMemoriesByIds, touchMemories } from "../db.js";
+import { getMemoriesByIds, touchMemories, getAttachmentsForMemories, formatAttachmentWithExtraction } from "../db.js";
+import { decrypt } from "../crypto.js";
 import { logMcpUsageEvent } from "../usage.js";
 import { decryptMemoryFields } from "./decrypt-helpers.js";
 export async function readMemories(ctx, memoryIds) {
     const memories = await getMemoriesByIds(ctx.supabase, ctx.userId, memoryIds);
     const foundIds = new Set(memories.map((m) => m.id));
     const notFound = memoryIds.filter((id) => !foundIds.has(id));
+    const attachmentRows = await getAttachmentsForMemories(ctx.supabase, ctx.userId, memories.map((m) => m.id));
+    const attachByMem = new Map();
+    for (const a of attachmentRows) {
+        if (!a.memory_id)
+            continue;
+        const list = attachByMem.get(a.memory_id) ?? [];
+        list.push(a);
+        attachByMem.set(a.memory_id, list);
+    }
     const decrypted = await Promise.all(memories.map(async (m) => {
         const { content, summary } = await decryptMemoryFields(m, ctx.masterKey);
+        const ma = attachByMem.get(m.id);
+        const attachmentLines = [];
+        if (ma && ma.length > 0) {
+            for (const a of ma) {
+                let decryptedText = null;
+                if (a.extracted_text && a.extracted_text_iv && ctx.masterKey) {
+                    try {
+                        decryptedText = await decrypt(a.extracted_text, a.extracted_text_iv, ctx.masterKey);
+                    }
+                    catch {
+                        // Ignore decryption failures for extracted text
+                    }
+                }
+                attachmentLines.push(formatAttachmentWithExtraction(a, decryptedText));
+            }
+        }
         return {
             id: m.id,
             memoryType: m.memory_type,
@@ -30,6 +56,7 @@ export async function readMemories(ctx, memoryIds) {
             lastAccessedAt: m.last_accessed_at,
             createdAt: m.created_at,
             updatedAt: m.updated_at,
+            ...(attachmentLines.length > 0 ? { attachments: attachmentLines } : {}),
         };
     }));
     // Track access (fire-and-forget)

package/dist/tools/read-note.js

@@ -1,4 +1,4 @@
-import { getNote, getVault } from "../db.js";
+import { getNote, getVault, getAttachmentsForNotes, formatAttachmentWithExtraction } from "../db.js";
 import { decrypt } from "../crypto.js";
 import { logMcpUsageEvent } from "../usage.js";
 import { decryptNoteFields } from "./decrypt-helpers.js";
@@ -14,6 +14,21 @@ export async function readNote(ctx, noteId) {
     if (vault) {
         vaultName = await decrypt(vault.encrypted_name, vault.name_iv, ctx.masterKey);
     }
+    // Fetch and format attachments with extracted text
+    const attachmentRows = await getAttachmentsForNotes(ctx.supabase, ctx.userId, [note.id]);
+    const attachmentLines = [];
+    for (const a of attachmentRows) {
+        let decryptedText = null;
+        if (a.extracted_text && a.extracted_text_iv && ctx.masterKey) {
+            try {
+                decryptedText = await decrypt(a.extracted_text, a.extracted_text_iv, ctx.masterKey);
+            }
+            catch {
+                // Ignore decryption failures for extracted text
+            }
+        }
+        attachmentLines.push(formatAttachmentWithExtraction(a, decryptedText));
+    }
     const payload = JSON.stringify({
         id: note.id,
         title,
@@ -23,6 +38,7 @@ export async function readNote(ctx, noteId) {
         vaultId: note.vault_id,
         createdAt: note.created_at,
         updatedAt: note.updated_at,
+        ...(attachmentLines.length > 0 ? { attachments: attachmentLines } : {}),
     }, null, 2);
     await logMcpUsageEvent({
         supabase: ctx.supabase,

package/dist/tools/read-notes.js

@@ -1,4 +1,4 @@
-import { getNotesByIds, getVault } from "../db.js";
+import { getNotesByIds, getVault, getAttachmentsForNotes, formatAttachmentWithExtraction } from "../db.js";
 import { decrypt } from "../crypto.js";
 import { decryptNoteFields } from "./decrypt-helpers.js";
 /**
@@ -24,11 +24,37 @@ export async function readNotes(ctx, noteIds) {
         vaultNameCache.set(vaultId, name);
         return name;
     }
+    // Fetch attachments for all notes at once
+    const attachmentRows = await getAttachmentsForNotes(ctx.supabase, ctx.userId, notes.map((n) => n.id));
+    const attachByNote = new Map();
+    for (const a of attachmentRows) {
+        if (!a.note_id)
+            continue;
+        const list = attachByNote.get(a.note_id) ?? [];
+        list.push(a);
+        attachByNote.set(a.note_id, list);
+    }
     async function decryptNote(note) {
         const [{ title, content, tags }, vaultName] = await Promise.all([
             decryptNoteFields(note, ctx.masterKey),
             getVaultName(note.vault_id),
         ]);
+        const na = attachByNote.get(note.id);
+        const attachmentLines = [];
+        if (na && na.length > 0) {
+            for (const a of na) {
+                let decryptedText = null;
+                if (a.extracted_text && a.extracted_text_iv && ctx.masterKey) {
+                    try {
+                        decryptedText = await decrypt(a.extracted_text, a.extracted_text_iv, ctx.masterKey);
+                    }
+                    catch {
+                        // Ignore decryption failures for extracted text
+                    }
+                }
+                attachmentLines.push(formatAttachmentWithExtraction(a, decryptedText));
+            }
+        }
         return {
             id: note.id,
             title,
@@ -38,6 +64,7 @@ export async function readNotes(ctx, noteIds) {
             vaultId: note.vault_id,
             createdAt: note.created_at,
             updatedAt: note.updated_at,
+            ...(attachmentLines.length > 0 ? { attachments: attachmentLines } : {}),
         };
     }
     const results = await Promise.all(notes.map(decryptNote));

package/dist/tools/search-and-read.js

@@ -1,4 +1,4 @@
-import { getNotes, getNotesByIds, getVault, matchNoteEmbeddings } from "../db.js";
+import { getNotes, getNotesByIds, getVault, matchNoteEmbeddings, getAttachmentsForNotes, formatAttachmentWithExtraction } from "../db.js";
 import { decrypt } from "../crypto.js";
 import { stripHtml } from "../strip-html.js";
 import { STOPWORDS } from "../stopwords.js";
@@ -166,11 +166,37 @@ export async function searchAndRead(ctx, query, maxNotes = 5) {
         vaultNameCache.set(vaultId, name);
         return name;
     }
+    // Fetch attachments for top notes
+    const attachmentRows = await getAttachmentsForNotes(ctx.supabase, ctx.userId, topIds);
+    const attachByNote = new Map();
+    for (const a of attachmentRows) {
+        if (!a.note_id)
+            continue;
+        const list = attachByNote.get(a.note_id) ?? [];
+        list.push(a);
+        attachByNote.set(a.note_id, list);
+    }
     const results = await Promise.all(topIds.map(async (noteId) => {
         const dec = decryptedMap.get(noteId);
         if (!dec)
             return null;
         const vaultName = await getVaultName(dec.note.vault_id);
+        const na = attachByNote.get(noteId);
+        const attachmentLines = [];
+        if (na && na.length > 0) {
+            for (const a of na) {
+                let decryptedText = null;
+                if (a.extracted_text && a.extracted_text_iv && ctx.masterKey) {
+                    try {
+                        decryptedText = await decrypt(a.extracted_text, a.extracted_text_iv, ctx.masterKey);
+                    }
+                    catch {
+                        // Ignore decryption failures for extracted text
+                    }
+                }
+                attachmentLines.push(formatAttachmentWithExtraction(a, decryptedText));
+            }
+        }
         return {
             id: noteId,
             title: dec.title,
@@ -181,6 +207,7 @@ export async function searchAndRead(ctx, query, maxNotes = 5) {
             score: combinedScores.get(noteId) ?? 0,
             createdAt: dec.note.created_at,
             updatedAt: dec.note.updated_at,
+            ...(attachmentLines.length > 0 ? { attachments: attachmentLines } : {}),
         };
     }));
     const searchMode = semanticScores.size > 0 && keywordScores.size > 0

package/dist/tools/search-memories.js

@@ -1,4 +1,5 @@
-import { getMemoriesByIds, getMemories, matchMemoryEmbeddings, matchMemoriesByBlindTokens, searchMemoriesByEntity, getKnowledgeGraph, touchMemories, getEmbeddingsForMemories, } from "../db.js";
+import { getMemoriesByIds, getMemories, matchMemoryEmbeddings, matchMemoriesByBlindTokens, searchMemoriesByEntity, getKnowledgeGraph, touchMemories, getEmbeddingsForMemories, getAttachmentsForMemories, formatAttachmentWithExtraction, } from "../db.js";
+import { decrypt } from "../crypto.js";
 import { decryptMemoryFields } from "./decrypt-helpers.js";
 import { generateQueryEmbedding } from "../openai.js";
 import { logMcpUsageEvent } from "../usage.js";
@@ -42,11 +43,36 @@ export async function searchMemories(ctx, input) {
             .filter((m) => (input.vaultId ? m.vault_id === input.vaultId : true))
             .filter((m) => (input.includeArchived ? true : !m.is_archived))
             .filter((m) => (input.memoryType ? m.memory_type === input.memoryType : true));
+        const entityAttachments = await getAttachmentsForMemories(ctx.supabase, ctx.userId, filtered.map((m) => m.id));
+        const entityAttachByMem = new Map();
+        for (const a of entityAttachments) {
+            if (!a.memory_id)
+                continue;
+            const list = entityAttachByMem.get(a.memory_id) ?? [];
+            list.push(a);
+            entityAttachByMem.set(a.memory_id, list);
+        }
         const results = await Promise.all(filtered.map(async (m) => {
             const { content, summary } = await decryptMemoryFields(m, ctx.masterKey);
             const displayContent = input.compact
                 ? clip(content, COMPACT_CONTENT_CHARS)
                 : content;
+            const ma = entityAttachByMem.get(m.id);
+            const attachmentLines = [];
+            if (ma && ma.length > 0) {
+                for (const a of ma) {
+                    let decryptedText = null;
+                    if (a.extracted_text && a.extracted_text_iv && ctx.masterKey) {
+                        try {
+                            decryptedText = await decrypt(a.extracted_text, a.extracted_text_iv, ctx.masterKey);
+                        }
+                        catch {
+                            // Ignore decryption failures for extracted text
+                        }
+                    }
+                    attachmentLines.push(formatAttachmentWithExtraction(a, decryptedText, 500));
+                }
+            }
             return {
                 id: m.id,
                 memoryType: m.memory_type,
@@ -64,6 +90,7 @@ export async function searchMemories(ctx, input) {
                 supersededById: m.superseded_by_id,
                 entities: m.entities,
                 updatedAt: m.updated_at,
+                ...(attachmentLines.length > 0 ? { attachments: attachmentLines } : {}),
             };
         }));
         // Track access for returned results (fire-and-forget)
@@ -100,7 +127,6 @@ export async function searchMemories(ctx, input) {
         try {
             embeddingTokens = Math.ceil(input.query.length / 4);
             const queryEmbedding = await generateQueryEmbedding(input.query, embeddingConfig.apiKey, {
-                baseUrl: embeddingConfig.baseUrl,
                 model: embeddingConfig.model,
             });
             const matches = await matchMemoryEmbeddings(ctx.supabase, queryEmbedding, ctx.userId, threshold, topK * 4);
@@ -254,8 +280,19 @@ export async function searchMemories(ctx, input) {
             .filter((m) => (input.memoryType ? m.memory_type === input.memoryType : true))
             .map((m) => m.id);
     }
-    const memories = await getMemoriesByIds(ctx.supabase, ctx.userId, rankedIds);
+    const [memories, attachmentRows] = await Promise.all([
+        getMemoriesByIds(ctx.supabase, ctx.userId, rankedIds),
+        getAttachmentsForMemories(ctx.supabase, ctx.userId, rankedIds),
+    ]);
     const byId = new Map(memories.map((m) => [m.id, m]));
+    const attachByMem = new Map();
+    for (const a of attachmentRows) {
+        if (!a.memory_id)
+            continue;
+        const list = attachByMem.get(a.memory_id) ?? [];
+        list.push(a);
+        attachByMem.set(a.memory_id, list);
+    }
     const ordered = rankedIds
         .map((id) => byId.get(id))
         .filter((m) => !!m)
@@ -266,6 +303,22 @@ export async function searchMemories(ctx, input) {
         const { content, summary } = await decryptMemoryFields(m, ctx.masterKey);
         const shouldClip = input.compact || searchMode === "fallback-recency";
         const clipLimit = input.compact ? COMPACT_CONTENT_CHARS : FALLBACK_CONTENT_PREVIEW_CHARS;
+        const ma = attachByMem.get(m.id);
+        const attachmentLines = [];
+        if (ma && ma.length > 0) {
+            for (const a of ma) {
+                let decryptedText = null;
+                if (a.extracted_text && a.extracted_text_iv && ctx.masterKey) {
+                    try {
+                        decryptedText = await decrypt(a.extracted_text, a.extracted_text_iv, ctx.masterKey);
+                    }
+                    catch {
+                        // Ignore decryption failures for extracted text
+                    }
+                }
+                attachmentLines.push(formatAttachmentWithExtraction(a, decryptedText, 500));
+            }
+        }
         return {
             id: m.id,
             memoryType: m.memory_type,
@@ -283,6 +336,7 @@ export async function searchMemories(ctx, input) {
             supersededById: m.superseded_by_id,
             entities: m.entities,
             updatedAt: m.updated_at,
+            ...(attachmentLines.length > 0 ? { attachments: attachmentLines } : {}),
         };
     }));
     // Track access for returned results (fire-and-forget)

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

@@ -1,2 +1,11 @@
 import type { McpContext } from "../auth.js";
-export declare function searchNotes(ctx: McpContext, query: string, vaultId?: string, limit?: number): Promise<string>;
+export declare function searchNotes(ctx: McpContext, input: {
+    query: string;
+    topK?: number;
+    threshold?: number;
+    searchMode?: "auto" | "hybrid" | "bm25" | "semantic";
+    diversity?: number;
+    vaultId?: string;
+    includeContent?: boolean;
+    compact?: boolean;
+}): Promise<string>;

package/dist/tools/search-notes.js

@@ -40,19 +40,23 @@ function scoreNote(terms, title, tags, content) {
     }
     return { score, matchedFields: Array.from(matchedFields) };
 }
-export async function searchNotes(ctx, query, vaultId, limit = 10) {
-    const terms = parseSearchTerms(query);
+const COMPACT_PREVIEW_CHARS = 200;
+const FULL_PREVIEW_CHARS = 500;
+export async function searchNotes(ctx, input) {
+    const topK = input.topK ?? 10;
+    const vaultId = input.vaultId;
+    const terms = parseSearchTerms(input.query);
     if (terms.length === 0) {
-        return JSON.stringify({ searchMode: "no_terms", blindIndexMatchCount: 0, notes: [] });
+        return JSON.stringify({ searchMode: "no_terms", blindIndexMatchCount: 0, notes: [] }, null, 2);
     }
     let candidateNotes;
     let searchMode = "full_scan";
     let blindIndexMatchCount = 0;
     if (ctx.mekHex) {
         try {
-            const queryTokenHashes = generateBlindTokens(query, ctx.mekHex);
+            const queryTokenHashes = generateBlindTokens(input.query, ctx.mekHex);
             if (queryTokenHashes.length > 0) {
-                const blindMatches = await matchNotesByBlindTokens(ctx.supabase, queryTokenHashes, ctx.userId, vaultId, limit * 3);
+                const blindMatches = await matchNotesByBlindTokens(ctx.supabase, queryTokenHashes, ctx.userId, vaultId, topK * 3);
                 blindIndexMatchCount = blindMatches.length;
                 if (blindMatches.length > 0) {
                     searchMode = "blind_index";
@@ -69,26 +73,32 @@ export async function searchNotes(ctx, query, vaultId, limit = 10) {
     if (!candidateNotes) {
         candidateNotes = await getNotes(ctx.supabase, ctx.userId, vaultId, 500);
     }
+    const previewChars = input.compact ? COMPACT_PREVIEW_CHARS : FULL_PREVIEW_CHARS;
     const scored = [];
     await Promise.all(candidateNotes.map(async (n) => {
         const { title, content, tags } = await decryptNoteFields(n, ctx.masterKey);
         const { score, matchedFields } = scoreNote(terms, title, tags, content);
         if (score > 0) {
-            scored.push({
+            const plainContent = stripHtml(content);
+            const entry = {
                 id: n.id,
                 title,
                 tags,
-                preview: stripHtml(content).slice(0, 200),
+                preview: plainContent.slice(0, previewChars),
                 score,
                 vaultId: n.vault_id,
                 matchedFields,
-            });
+            };
+            if (input.includeContent) {
+                entry.content = content;
+            }
+            scored.push(entry);
         }
     }));
     scored.sort((a, b) => b.score - a.score);
     return JSON.stringify({
         searchMode,
         blindIndexMatchCount,
-        notes: scored.slice(0, limit),
+        notes: scored.slice(0, topK),
     }, null, 2);
 }

package/dist/tools/search.d.ts

@@ -0,0 +1,27 @@
+import type { McpContext } from "../auth.js";
+interface SearchParams {
+    query: string;
+    topK?: number;
+    threshold?: number;
+    searchMode?: "auto" | "hybrid" | "bm25" | "semantic";
+    diversity?: number;
+    vaultId?: string;
+    includeContent?: boolean;
+    compact?: boolean;
+    scope?: "all" | "memories" | "notes";
+    memoryType?: string;
+    includeArchived?: boolean;
+    decayHalfLife?: number;
+}
+/**
+ * Universal search tool — searches memories, notes, or both.
+ *
+ * In direct mode: best-effort — calls searchMemories and/or searchNotes
+ * independently and interleaves results (no cross-type MMR).
+ *
+ * Note: In gateway mode, the MCP server's `search` tool registration in index.ts
+ * delegates to the gateway `/api/agent/search` endpoint which performs full
+ * cross-type MMR re-ranking server-side. This function is only used in direct mode.
+ */
+export declare function search(ctx: McpContext, params: SearchParams): Promise<string>;
+export {};

package/dist/tools/search.js

@@ -0,0 +1,78 @@
+import { searchMemories } from "./search-memories.js";
+import { searchNotes } from "./search-notes.js";
+/**
+ * Universal search tool — searches memories, notes, or both.
+ *
+ * In direct mode: best-effort — calls searchMemories and/or searchNotes
+ * independently and interleaves results (no cross-type MMR).
+ *
+ * Note: In gateway mode, the MCP server's `search` tool registration in index.ts
+ * delegates to the gateway `/api/agent/search` endpoint which performs full
+ * cross-type MMR re-ranking server-side. This function is only used in direct mode.
+ */
+export async function search(ctx, params) {
+    const scope = params.scope ?? "all";
+    const topK = params.topK ?? 10;
+    const searchMemoriesParams = {
+        query: params.query,
+        topK,
+        threshold: params.threshold,
+        vaultId: params.vaultId,
+        memoryType: params.memoryType,
+        includeArchived: params.includeArchived,
+        compact: params.compact,
+        decayHalfLife: params.decayHalfLife,
+        diversity: params.diversity,
+        searchMode: params.searchMode,
+    };
+    const searchNotesParams = {
+        query: params.query,
+        topK,
+        threshold: params.threshold,
+        searchMode: params.searchMode,
+        diversity: params.diversity,
+        vaultId: params.vaultId,
+        includeContent: params.includeContent,
+        compact: params.compact,
+    };
+    try {
+        if (scope === "memories") {
+            const memoriesResult = await searchMemories(ctx, searchMemoriesParams);
+            const parsed = JSON.parse(memoriesResult);
+            return JSON.stringify({ scope: "memories", ...parsed }, null, 2);
+        }
+        if (scope === "notes") {
+            const notesResult = await searchNotes(ctx, searchNotesParams);
+            const parsed = JSON.parse(notesResult);
+            return JSON.stringify({ scope: "notes", ...parsed }, null, 2);
+        }
+        // scope === "all": run both in parallel and interleave results
+        const [memoriesResult, notesResult] = await Promise.all([
+            searchMemories(ctx, { ...searchMemoriesParams, topK: Math.ceil(topK / 2) }),
+            searchNotes(ctx, { ...searchNotesParams, topK: Math.ceil(topK / 2) }),
+        ]);
+        const memoriesParsed = JSON.parse(memoriesResult);
+        const notesParsed = JSON.parse(notesResult);
+        const memories = (memoriesParsed.memories ?? []);
+        const notes = (notesParsed.notes ?? []);
+        // Interleave: memory, note, memory, note, ...
+        const combined = [];
+        const maxLen = Math.max(memories.length, notes.length);
+        for (let i = 0; i < maxLen; i++) {
+            if (i < memories.length)
+                combined.push({ _type: "memory", ...memories[i] });
+            if (i < notes.length)
+                combined.push({ _type: "note", ...notes[i] });
+        }
+        return JSON.stringify({
+            scope: "all",
+            note: "Direct mode: best-effort interleave (no cross-type MMR). Use gateway mode for ranked unified results.",
+            memoriesSearchMode: memoriesParsed.searchMode,
+            notesSearchMode: notesParsed.searchMode,
+            results: combined,
+        }, null, 2);
+    }
+    catch (e) {
+        return JSON.stringify({ error: e instanceof Error ? e.message : String(e) }, null, 2);
+    }
+}

package/dist/tools/semantic-search.js

@@ -1,4 +1,4 @@
-import { matchNoteEmbeddings, getNotesByIds } from "../db.js";
+import { matchNoteEmbeddings, getNotesByIds, getAttachmentsForNotes, formatAttachmentWithExtraction } from "../db.js";
 import { generateQueryEmbedding } from "../openai.js";
 import { decrypt } from "../crypto.js";
 import { stripHtml } from "../strip-html.js";
@@ -43,7 +43,17 @@ export async function semanticSearch(ctx, query, topK = 10, threshold = 0.5) {
     // 4. Fetch the actual notes
     const noteIds = Array.from(bestByNote.keys());
     const notes = await getNotesByIds(ctx.supabase, ctx.userId, noteIds);
-    // 5. Decrypt and build results
+    // 5. Fetch attachments for all matched notes
+    const attachmentRows = await getAttachmentsForNotes(ctx.supabase, ctx.userId, noteIds);
+    const attachByNote = new Map();
+    for (const a of attachmentRows) {
+        if (!a.note_id)
+            continue;
+        const list = attachByNote.get(a.note_id) ?? [];
+        list.push(a);
+        attachByNote.set(a.note_id, list);
+    }
+    // 6. Decrypt and build results
     const results = await Promise.all(notes.map(async (note) => {
         const [title, content] = await Promise.all([
             decrypt(note.encrypted_title, note.title_iv, ctx.masterKey),
@@ -59,6 +69,22 @@ export async function semanticSearch(ctx, query, topK = 10, threshold = 0.5) {
                 // ignore
             }
         }
+        const na = attachByNote.get(note.id);
+        const attachmentLines = [];
+        if (na && na.length > 0) {
+            for (const a of na) {
+                let decryptedText = null;
+                if (a.extracted_text && a.extracted_text_iv && ctx.masterKey) {
+                    try {
+                        decryptedText = await decrypt(a.extracted_text, a.extracted_text_iv, ctx.masterKey);
+                    }
+                    catch {
+                        // Ignore decryption failures for extracted text
+                    }
+                }
+                attachmentLines.push(formatAttachmentWithExtraction(a, decryptedText, 500));
+            }
+        }
         return {
             id: note.id,
             title,
@@ -67,6 +93,7 @@ export async function semanticSearch(ctx, query, topK = 10, threshold = 0.5) {
             similarity: bestByNote.get(note.id) ?? 0,
             vaultId: note.vault_id,
             updatedAt: note.updated_at,
+            ...(attachmentLines.length > 0 ? { attachments: attachmentLines } : {}),
         };
     }));
     // Sort by similarity descending and limit to topK

package/dist/tools/update-memory.js

@@ -6,7 +6,7 @@ import { generateEmbeddings } from "../openai.js";
 import { logMcpUsageEvent } from "../usage.js";
 import { resolveEmbeddingConfig } from "../embedding-config.js";
 import { syncWikiLinks, deleteWikiLinksForNode } from "./wiki-link-sync.js";
-const VECTOR_DIMS = 1536;
+const VECTOR_DIMS = 3072;
 const CHARS_PER_TOKEN = 4;
 const CHUNK_TARGET_CHARS = 2400;
 const CHUNK_OVERLAP_CHARS = 400;
@@ -166,7 +166,7 @@ export async function updateMemoryTool(ctx, input) {
             const chunks = chunkText(base);
             if (chunks.length > 0) {
                 try {
-                    const vectors = await generateEmbeddings(chunks.map((c) => c.text), embeddingConfig.apiKey, { baseUrl: embeddingConfig.baseUrl, model: embeddingConfig.model });
+                    const vectors = await generateEmbeddings(chunks.map((c) => c.text), embeddingConfig.apiKey, { model: embeddingConfig.model });
                     const badVector = vectors.find((v) => v.length !== VECTOR_DIMS);
                     if (badVector) {
                         throw new Error(`embedding_dimensions_mismatch expected=${VECTOR_DIMS} got=${badVector.length}`);

package/dist/tools/write-memory.js

@@ -8,7 +8,7 @@ import { generateEmbeddings, generateQueryEmbedding } from "../openai.js";
 import { logMcpUsageEvent } from "../usage.js";
 import { resolveEmbeddingConfig } from "../embedding-config.js";
 import { syncWikiLinks } from "./wiki-link-sync.js";
-const VECTOR_DIMS = 1536;
+const VECTOR_DIMS = 3072;
 const CHARS_PER_TOKEN = 4;
 const CHUNK_TARGET_CHARS = 2400; // ~600 tokens
 const CHUNK_OVERLAP_CHARS = 400; // ~100 tokens
@@ -55,7 +55,6 @@ export async function checkSemanticDedup(ctx, content, summary) {
             ? `${summary.trim()}\n\n${content.trim()}`
             : content.trim();
         const embedding = await generateQueryEmbedding(textToEmbed, embeddingConfig.apiKey, {
-            baseUrl: embeddingConfig.baseUrl,
             model: embeddingConfig.model,
         });
         const matches = await matchMemoryEmbeddings(ctx.supabase, embedding, ctx.userId, DEDUP_SUPERSEDE_THRESHOLD, 5);
@@ -162,10 +161,7 @@ async function indexMemoryEmbeddings(ctx, memoryId, content, summary) {
         indexing_error: null,
     });
     try {
-        const vectors = await generateEmbeddings(chunks.map((c) => c.text), embeddingConfig.apiKey, {
-            baseUrl: embeddingConfig.baseUrl,
-            model: embeddingConfig.model,
-        });
+        const vectors = await generateEmbeddings(chunks.map((c) => c.text), embeddingConfig.apiKey, { model: embeddingConfig.model });
         const badVector = vectors.find((v) => v.length !== VECTOR_DIMS);
         if (badVector) {
             throw new Error(`embedding_dimensions_mismatch expected=${VECTOR_DIMS} got=${badVector.length} model=${embeddingConfig.model}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exovault-mcp-server",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "type": "module",
   "description": "MCP server for ExoVault — read, search, and manage encrypted notes from Claude Code",
   "main": "dist/index.js",
@@ -25,6 +25,7 @@
   },
   "dependencies": {
     "@ai-sdk/openai": "^3.0.27",
+    "@google/genai": "^1.44.0",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "@supabase/supabase-js": "^2.49.4",
     "ai": "^6.0.82",