reflect-mcp 1.0.5 → 1.0.7

package/README.md

@@ -125,6 +125,8 @@ npx reflect-mcp uninstall
 - Verify database path exists at default location
 - Try specifying custom path: `npx reflect-mcp install /path/to/db`
 
+## Demo:
+https://www.loom.com/share/455b1d3eb7184bdea1ae4e8d5904fc53
 ## License
 
 MIT

package/dist/pkcehandler.d.ts

@@ -17,15 +17,19 @@ export interface PKCEOAuthProxyConfig {
     scopes: string[];
     redirectPath?: string;
     tokenStoragePath?: string;
+    transactionStoragePath?: string;
 }
 export declare class PKCEOAuthProxy {
     private config;
     private transactions;
     private tokens;
+    private recentlyExchangedCodes;
     private cleanupInterval;
     constructor(options: PKCEOAuthProxyConfig);
     private loadTokensFromDisk;
     private saveTokensToDisk;
+    private loadTransactionsFromDisk;
+    private saveTransactionsToDisk;
     private generatePKCE;
     private generateId;
     getAuthorizationServerMetadata(): {

package/dist/pkcehandler.js

@@ -14,10 +14,12 @@ import { OAuthProxyError } from "fastmcp/auth";
 // ============================================================================
 export class PKCEOAuthProxy {
     config;
-    // In-memory storage for transactions (short-lived, don't need persistence)
+    // Transaction storage - now persisted to disk to survive restarts
     transactions = new Map();
     // Token storage - persisted to disk
     tokens = new Map();
+    // Track tokens that have been exchanged but allow brief retry window
+    recentlyExchangedCodes = new Map();
     cleanupInterval = null;
     constructor(options) {
         this.config = {
@@ -28,8 +30,10 @@ export class PKCEOAuthProxy {
             redirectPath: options.redirectPath || "/oauth/callback",
             scopes: options.scopes,
             tokenStoragePath: options.tokenStoragePath || path.join(os.homedir(), ".reflect-mcp-tokens.json"),
+            transactionStoragePath: options.transactionStoragePath || path.join(os.homedir(), ".reflect-mcp-transactions.json"),
         };
         this.loadTokensFromDisk();
+        this.loadTransactionsFromDisk();
         this.startCleanup();
     }
     // Load tokens from disk on startup
@@ -73,6 +77,57 @@ export class PKCEOAuthProxy {
             console.error("[PKCEProxy] Failed to save tokens to disk:", error);
         }
     }
+    // Load transactions from disk on startup (survives server restarts)
+    loadTransactionsFromDisk() {
+        try {
+            if (fs.existsSync(this.config.transactionStoragePath)) {
+                const data = fs.readFileSync(this.config.transactionStoragePath, "utf-8");
+                const stored = JSON.parse(data);
+                for (const [key, value] of Object.entries(stored)) {
+                    const expiresAt = new Date(value.expiresAt);
+                    // Only load non-expired transactions
+                    if (expiresAt > new Date()) {
+                        this.transactions.set(key, {
+                            codeVerifier: value.codeVerifier,
+                            codeChallenge: value.codeChallenge,
+                            clientCallbackUrl: value.clientCallbackUrl,
+                            clientId: value.clientId,
+                            clientState: value.clientState,
+                            scope: value.scope,
+                            createdAt: new Date(value.createdAt),
+                            expiresAt,
+                        });
+                    }
+                }
+                console.log(`[PKCEProxy] Loaded ${this.transactions.size} transactions from disk`);
+            }
+        }
+        catch (error) {
+            console.warn("[PKCEProxy] Failed to load transactions from disk:", error);
+        }
+    }
+    // Save transactions to disk (survives server restarts)
+    saveTransactionsToDisk() {
+        try {
+            const toStore = {};
+            for (const [key, value] of this.transactions) {
+                toStore[key] = {
+                    codeVerifier: value.codeVerifier,
+                    codeChallenge: value.codeChallenge,
+                    clientCallbackUrl: value.clientCallbackUrl,
+                    clientId: value.clientId,
+                    clientState: value.clientState,
+                    scope: value.scope,
+                    createdAt: value.createdAt.toISOString(),
+                    expiresAt: value.expiresAt.toISOString(),
+                };
+            }
+            fs.writeFileSync(this.config.transactionStoragePath, JSON.stringify(toStore, null, 2));
+        }
+        catch (error) {
+            console.error("[PKCEProxy] Failed to save transactions to disk:", error);
+        }
+    }
     // Generate PKCE code verifier and challenge
     generatePKCE() {
         // Generate a random code verifier (43-128 characters)
@@ -124,6 +179,7 @@ export class PKCEOAuthProxy {
             expiresAt: new Date(Date.now() + 600 * 1000), // 10 minutes
         };
         this.transactions.set(transactionId, transaction);
+        this.saveTransactionsToDisk(); // Persist to survive restarts
         console.log("[PKCEProxy] Created transaction:", transactionId);
         // Build upstream authorization URL
         const authUrl = new URL(this.config.authorizationEndpoint);
@@ -172,6 +228,8 @@ export class PKCEOAuthProxy {
         }
         if (transaction.expiresAt < new Date()) {
             this.transactions.delete(state);
+            this.saveTransactionsToDisk();
+            console.error("[PKCEProxy] Transaction expired, created:", transaction.createdAt, "expired:", transaction.expiresAt);
             return new Response(JSON.stringify({ error: "transaction_expired" }), {
                 status: 400,
                 headers: { "Content-Type": "application/json" },
@@ -214,6 +272,7 @@ export class PKCEOAuthProxy {
         clientRedirect.searchParams.set("state", transaction.clientState);
         // Clean up transaction
         this.transactions.delete(state);
+        this.saveTransactionsToDisk();
         console.log("[PKCEProxy] Redirecting to client:", clientRedirect.toString());
         return new Response(null, {
             status: 302,
@@ -223,22 +282,42 @@ export class PKCEOAuthProxy {
     // Handle /oauth/token - exchange proxy code for access token
     // FastMCP expects a TokenResponse object, not a Response
     async exchangeAuthorizationCode(params) {
-        console.log("[PKCEProxy] exchangeAuthorizationCode called with code:", params.code?.slice(0, 8) + "...");
         if (!params.code) {
             throw new OAuthProxyError("invalid_request", "Missing authorization code", 400);
         }
+        // Check if this code was recently exchanged (retry tolerance)
+        // This allows mcp-remote to retry if the first request timed out but actually succeeded
+        const recentExchange = this.recentlyExchangedCodes.get(params.code);
+        if (recentExchange && recentExchange.expiresAt > new Date()) {
+            console.log("[PKCEProxy] Returning cached token for retry of code:", params.code.slice(0, 8) + "...");
+            const tokenData = this.tokens.get(recentExchange.accessToken);
+            if (tokenData) {
+                const expiresIn = Math.floor((tokenData.expiresAt.getTime() - Date.now()) / 1000);
+                return {
+                    access_token: recentExchange.accessToken,
+                    token_type: "Bearer",
+                    expires_in: expiresIn > 0 ? expiresIn : 3600,
+                };
+            }
+        }
         const tokenData = this.tokens.get(params.code);
         if (!tokenData) {
             console.error("[PKCEProxy] Token not found for code:", params.code);
             console.error("[PKCEProxy] Available tokens:", Array.from(this.tokens.keys()).map(k => k.slice(0, 8) + "..."));
+            console.error("[PKCEProxy] Recently exchanged codes:", Array.from(this.recentlyExchangedCodes.keys()).map(k => k.slice(0, 8) + "..."));
             throw new OAuthProxyError("invalid_grant", "Invalid or expired authorization code", 400);
         }
-        // Remove the code (single use)
+        // Remove the code but keep track of it for retry tolerance (30 second window)
         this.tokens.delete(params.code);
         // Generate a new access token for the client
         const accessToken = this.generateId();
         this.tokens.set(accessToken, tokenData);
         this.saveTokensToDisk(); // Persist to disk
+        // Store the exchange for retry tolerance (30 seconds)
+        this.recentlyExchangedCodes.set(params.code, {
+            accessToken,
+            expiresAt: new Date(Date.now() + 30 * 1000),
+        });
         const expiresIn = Math.floor((tokenData.expiresAt.getTime() - Date.now()) / 1000);
         console.log("[PKCEProxy] Issuing access token, expires in:", expiresIn, "seconds");
         return {
@@ -272,13 +351,22 @@ export class PKCEOAuthProxy {
     // Load upstream tokens for a given proxy token
     loadUpstreamTokens(proxyToken) {
         const data = this.tokens.get(proxyToken);
-        if (!data)
+        if (!data) {
+            console.warn("[PKCEProxy] Token not found:", proxyToken.slice(0, 8) + "...");
+            console.warn("[PKCEProxy] Total tokens in store:", this.tokens.size);
             return null;
-        if (data.expiresAt < new Date()) {
+        }
+        const now = new Date();
+        if (data.expiresAt < now) {
+            console.warn("[PKCEProxy] Token expired:", proxyToken.slice(0, 8) + "...", "expired at:", data.expiresAt, "now:", now);
             this.tokens.delete(proxyToken);
             this.saveTokensToDisk();
             return null;
         }
+        const timeRemaining = Math.floor((data.expiresAt.getTime() - now.getTime()) / 1000);
+        if (timeRemaining < 300) { // Less than 5 minutes remaining
+            console.warn("[PKCEProxy] Token expiring soon:", proxyToken.slice(0, 8) + "...", "remaining:", timeRemaining, "seconds");
+        }
         return data;
     }
     // Get first valid token (for stdio mode where we don't have specific token ID)
@@ -291,24 +379,37 @@ export class PKCEOAuthProxy {
         }
         return null;
     }
-    // Cleanup expired transactions and tokens
+    // Cleanup expired transactions, tokens, and retry cache
     startCleanup() {
         this.cleanupInterval = setInterval(() => {
             const now = new Date();
             let tokensChanged = false;
+            let transactionsChanged = false;
             for (const [id, tx] of this.transactions) {
-                if (tx.expiresAt < now)
+                if (tx.expiresAt < now) {
                     this.transactions.delete(id);
+                    transactionsChanged = true;
+                }
             }
             for (const [id, token] of this.tokens) {
                 if (token.expiresAt < now) {
+                    console.log("[PKCEProxy] Cleaning up expired token:", id.slice(0, 8) + "...");
                     this.tokens.delete(id);
                     tokensChanged = true;
                 }
             }
+            // Clean up expired retry cache entries
+            for (const [code, data] of this.recentlyExchangedCodes) {
+                if (data.expiresAt < now) {
+                    this.recentlyExchangedCodes.delete(code);
+                }
+            }
             if (tokensChanged) {
                 this.saveTokensToDisk();
             }
+            if (transactionsChanged) {
+                this.saveTransactionsToDisk();
+            }
         }, 60000); // Every minute
     }
     destroy() {

package/dist/server.js

@@ -35,15 +35,26 @@ export async function startReflectMCPServer(config) {
         authenticate: async (request) => {
             const authHeader = request.headers.authorization;
             if (!authHeader?.startsWith("Bearer ")) {
-                return undefined;
+                console.warn("[Auth] Missing or invalid Authorization header - triggering 401");
+                // Throw Response to trigger re-authentication (per FastMCP docs)
+                throw new Response(null, {
+                    status: 401,
+                    statusText: "Unauthorized - Bearer token required",
+                });
             }
             const token = authHeader.slice(7);
             try {
                 const tokenData = pkceProxy.loadUpstreamTokens(token);
                 if (!tokenData) {
-                    return undefined;
+                    console.warn("[Auth] Token validation failed for:", token.slice(0, 8) + "... - triggering 401");
+                    // Throw Response to trigger re-authentication (per FastMCP docs)
+                    throw new Response(null, {
+                        status: 401,
+                        statusText: "Unauthorized - Invalid or expired token",
+                    });
                 }
                 const expiresIn = Math.floor((tokenData.expiresAt.getTime() - Date.now()) / 1000);
+                console.log("[Auth] Token validated, expires in:", expiresIn, "seconds");
                 return {
                     accessToken: tokenData.accessToken,
                     refreshToken: tokenData.refreshToken,
@@ -51,8 +62,15 @@ export async function startReflectMCPServer(config) {
                 };
             }
             catch (error) {
-                console.error("[Auth] Error:", error);
-                return undefined;
+                // Re-throw if it's already a Response (our auth failures above)
+                if (error instanceof Response) {
+                    throw error;
+                }
+                console.error("[Auth] Error validating token:", error);
+                throw new Response(null, {
+                    status: 401,
+                    statusText: "Unauthorized - Token validation error",
+                });
             }
         },
         version: "1.0.0",

package/dist/tools/index.js

@@ -11,7 +11,7 @@ export function registerTools(server, dbPath) {
     // Tool: Get all Reflect graphs
     server.addTool({
         name: "get_graphs",
-        description: "Get a list of all Reflect graphs accessible with the current access token",
+        description: "Get a list of all Reflect graphs.",
         parameters: z.object({}),
         execute: async (_args, { session }) => {
             if (!session) {
@@ -59,14 +59,14 @@ export function registerTools(server, dbPath) {
     // Tool: Get backlinks for a note from local Reflect SQLite database
     server.addTool({
         name: "get_backlinks",
-        description: "Get backlinks for a note from the local Reflect database. Returns notes that link to the specified note.",
+        description: "Get backlinks for a note from Reflect. Use  this tool to get more context about a note after calling the get_note tool.",
         parameters: z.object({
             subject: z.string().describe("The subject/title of the note to get backlinks for"),
-            graphId: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
             limit: z.number().default(10).describe("Maximum number of backlinks to return"),
         }),
         execute: async (args) => {
-            const { subject, graphId, limit } = args;
+            const { subject, graph_id, limit } = args;
             try {
                 const dbFile = resolvedDbPath;
                 const db = new Database(dbFile, { readonly: true });
@@ -79,7 +79,7 @@ export function registerTools(server, dbPath) {
           ORDER BY bl.updatedAt DESC
           LIMIT ?
         `);
-                const results = stmt.all(subject, graphId, limit);
+                const results = stmt.all(subject, graph_id, limit);
                 db.close();
                 const backlinks = results.map((row) => ({
                     fromSubject: row.from_subject,
@@ -91,7 +91,7 @@ export function registerTools(server, dbPath) {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify({ subject, graphId, backlinks }, null, 2),
+                            text: JSON.stringify({ subject, graph_id, backlinks }, null, 2),
                         },
                     ],
                 };
@@ -111,13 +111,13 @@ export function registerTools(server, dbPath) {
     // Tool: Get recent daily notes
     server.addTool({
         name: "get_daily_notes",
-        description: "Get the most recent daily notes from the local Reflect database",
+        description: "Get the most recent daily notes from Reflect.",
         parameters: z.object({
             limit: z.number().default(5).describe("Number of recent daily notes to return"),
-            graphId: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
         }),
         execute: async (args) => {
-            const { limit, graphId } = args;
+            const { limit, graph_id } = args;
             try {
                 const dbFile = resolvedDbPath;
                 const db = new Database(dbFile, { readonly: true });
@@ -128,7 +128,7 @@ export function registerTools(server, dbPath) {
           ORDER BY dailyDate DESC
           LIMIT ?
         `);
-                const rows = stmt.all(graphId, limit);
+                const rows = stmt.all(graph_id, limit);
                 db.close();
                 const dailyNotes = rows.map((row) => ({
                     id: row.id,
@@ -137,13 +137,13 @@ export function registerTools(server, dbPath) {
                     editedAt: formatDate(row.editedAt),
                     tags: row.tags ? JSON.parse(row.tags) : [],
                     dailyDate: formatDate(row.dailyDate),
-                    graphId: row.graphId,
+                    graph_id: row.graphId,
                 }));
                 return {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify({ graphId, count: dailyNotes.length, dailyNotes }, null, 2),
+                            text: JSON.stringify({ graph_id, count: dailyNotes.length, dailyNotes }, null, 2),
                         },
                     ],
                 };
@@ -163,13 +163,13 @@ export function registerTools(server, dbPath) {
     // Tool: Get daily note by date
     server.addTool({
         name: "get_daily_note_by_date",
-        description: "Get the daily note for a specific date from the local Reflect database",
+        description: "Get the daily note for a specific date.",
         parameters: z.object({
             date: z.string().describe("The date in YYYY-MM-DD format"),
-            graphId: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
         }),
         execute: async (args) => {
-            const { date, graphId } = args;
+            const { date, graph_id } = args;
             try {
                 const dbFile = resolvedDbPath;
                 const db = new Database(dbFile, { readonly: true });
@@ -180,14 +180,14 @@ export function registerTools(server, dbPath) {
           FROM notes 
           WHERE isDaily = 1 AND isDeleted = 0 AND graphId = ? AND dailyDate = ?
         `);
-                const result = stmt.get(graphId, dateMs);
+                const result = stmt.get(graph_id, dateMs);
                 db.close();
                 if (!result) {
                     return {
                         content: [
                             {
                                 type: "text",
-                                text: JSON.stringify({ error: `No daily note found for ${date}`, date, graphId }),
+                                text: JSON.stringify({ error: `No daily note found for ${date}`, date, graph_id }),
                             },
                         ],
                     };
@@ -199,13 +199,13 @@ export function registerTools(server, dbPath) {
                     editedAt: formatDate(result.editedAt),
                     tags: result.tags ? JSON.parse(result.tags) : [],
                     dailyDate: formatDate(result.dailyDate),
-                    graphId: result.graphId,
+                    graph_id: result.graph_id,
                 };
                 return {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify({ date, graphId, dailyNote }, null, 2),
+                            text: JSON.stringify({ date, graph_id, dailyNote }, null, 2),
                         },
                     ],
                 };
@@ -225,14 +225,14 @@ export function registerTools(server, dbPath) {
     // Tool: Get notes with most backlinks
     server.addTool({
         name: "get_backlinked_notes",
-        description: "Get notes that have at least a minimum number of backlinks from the local Reflect database",
+        description: "Get notes that have at least a minimum number of backlinks from Reflect.",
         parameters: z.object({
             minBacklinks: z.number().default(5).describe("Minimum number of backlinks a note must have"),
             limit: z.number().default(10).describe("Maximum number of notes to return"),
-            graphId: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
         }),
         execute: async (args) => {
-            const { minBacklinks, limit, graphId } = args;
+            const { minBacklinks, limit, graph_id } = args;
             try {
                 const dbFile = resolvedDbPath;
                 const db = new Database(dbFile, { readonly: true });
@@ -246,7 +246,7 @@ export function registerTools(server, dbPath) {
           ORDER BY backlink_count DESC
           LIMIT ?
         `);
-                const results = stmt.all(graphId, minBacklinks, limit);
+                const results = stmt.all(graph_id, minBacklinks, limit);
                 db.close();
                 const notes = results.map((row) => ({
                     id: row.id,
@@ -258,7 +258,7 @@ export function registerTools(server, dbPath) {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify({ graphId, minBacklinks, count: notes.length, notes }, null, 2),
+                            text: JSON.stringify({ graph_id, minBacklinks, count: notes.length, notes }, null, 2),
                         },
                     ],
                 };
@@ -278,13 +278,13 @@ export function registerTools(server, dbPath) {
     // Tool: Get all tags with usage counts
     server.addTool({
         name: "get_tags",
-        description: "Get all unique tags with their usage counts from the local Reflect database",
+        description: "Get all unique tags with their usage counts from Reflect.",
         parameters: z.object({
-            graphId: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
             limit: z.number().default(50).describe("Maximum number of tags to return"),
         }),
         execute: async (args) => {
-            const { graphId, limit } = args;
+            const { graph_id, limit } = args;
             try {
                 const dbFile = resolvedDbPath;
                 const db = new Database(dbFile, { readonly: true });
@@ -292,7 +292,7 @@ export function registerTools(server, dbPath) {
           SELECT tags FROM notes 
           WHERE isDeleted = 0 AND graphId = ? AND tags IS NOT NULL AND tags != '[]'
         `);
-                const rows = stmt.all(graphId);
+                const rows = stmt.all(graph_id);
                 db.close();
                 const tagCounts = {};
                 for (const row of rows) {
@@ -314,7 +314,7 @@ export function registerTools(server, dbPath) {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify({ graphId, totalTags: Object.keys(tagCounts).length, tags: sortedTags }, null, 2),
+                            text: JSON.stringify({ graph_id, totalTags: Object.keys(tagCounts).length, tags: sortedTags }, null, 2),
                         },
                     ],
                 };
@@ -334,14 +334,14 @@ export function registerTools(server, dbPath) {
     // Tool: Get notes with a specific tag
     server.addTool({
         name: "get_notes_with_tag",
-        description: "Get notes that have a specific tag from the local Reflect database",
+        description: "Get notes that have a specific tag from Reflect.",
         parameters: z.object({
             tag: z.string().describe("The tag to search for"),
-            graphId: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
             limit: z.number().default(20).describe("Maximum number of notes to return"),
         }),
         execute: async (args) => {
-            const { tag, graphId, limit } = args;
+            const { tag, graph_id, limit } = args;
             try {
                 const dbFile = resolvedDbPath;
                 const db = new Database(dbFile, { readonly: true });
@@ -352,7 +352,7 @@ export function registerTools(server, dbPath) {
           ORDER BY editedAt DESC
           LIMIT ?
         `);
-                const results = stmt.all(graphId, `%"${tag}"%`, limit);
+                const results = stmt.all(graph_id, `%"${tag}"%`, limit);
                 db.close();
                 const notes = results.map((row) => ({
                     id: row.id,
@@ -366,7 +366,7 @@ export function registerTools(server, dbPath) {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify({ tag, graphId, count: notes.length, notes }, null, 2),
+                            text: JSON.stringify({ tag, graph_id, count: notes.length, notes }, null, 2),
                         },
                     ],
                 };
@@ -383,49 +383,116 @@ export function registerTools(server, dbPath) {
             }
         },
     });
-    // Tool: Get a note by title
+    // Tool: Get a note by title (exact match first, then fuzzy fallback)
     server.addTool({
         name: "get_note",
-        description: "Get a note by its title (subject) from the local Reflect database",
+        description: "Get a note by its title (subject) from Reflect.",
         parameters: z.object({
             title: z.string().describe("The title/subject of the note to retrieve"),
-            graphId: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
         }),
         execute: async (args) => {
-            const { title, graphId } = args;
+            const { title, graph_id } = args;
+            const FUZZY_LIMIT = 3;
             try {
                 const dbFile = resolvedDbPath;
                 const db = new Database(dbFile, { readonly: true });
-                const stmt = db.prepare(`
+                // Try exact match first
+                const exactStmt = db.prepare(`
           SELECT id, subject, documentText, tags, editedAt, createdAt
           FROM notes 
           WHERE isDeleted = 0 AND graphId = ? AND subject = ?
         `);
-                const result = stmt.get(graphId, title);
+                const exactResult = exactStmt.get(graph_id, title);
+                if (exactResult) {
+                    db.close();
+                    const note = {
+                        id: exactResult.id,
+                        subject: exactResult.subject,
+                        documentText: exactResult.documentText,
+                        tags: exactResult.tags ? JSON.parse(exactResult.tags) : [],
+                        editedAt: formatDate(exactResult.editedAt),
+                        createdAt: formatDate(exactResult.createdAt),
+                    };
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({ title, graph_id, note }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                // No exact match - try fuzzy search
+                const searchTerm = title.toLowerCase();
+                const fuzzyStmt = db.prepare(`
+          SELECT id, subject, documentText, tags, editedAt, createdAt,
+            CASE 
+              WHEN LOWER(subject) LIKE ? THEN 2
+              WHEN LOWER(subject) LIKE ? THEN 1
+              ELSE 0
+            END as relevance
+          FROM notes 
+          WHERE isDeleted = 0 
+            AND graphId = ? 
+            AND (LOWER(subject) LIKE ? OR LOWER(subject) LIKE ?)
+          ORDER BY relevance DESC, editedAt DESC
+          LIMIT ?
+        `);
+                const fuzzyResults = fuzzyStmt.all(`${searchTerm}%`, // starts with (score 2)
+                `%${searchTerm}%`, // contains (score 1)
+                graph_id, `${searchTerm}%`, // WHERE starts with
+                `%${searchTerm}%`, // WHERE contains
+                FUZZY_LIMIT);
                 db.close();
-                if (!result) {
+                if (fuzzyResults.length === 0) {
                     return {
                         content: [
                             {
                                 type: "text",
-                                text: JSON.stringify({ error: `Note '${title}' not found`, title, graphId }),
+                                text: JSON.stringify({
+                                    error: `No notes found matching '${title}'`,
+                                    query: title,
+                                    graph_id
+                                }),
                             },
                         ],
                     };
                 }
-                const note = {
+                const notes = fuzzyResults.map((result) => ({
                     id: result.id,
                     subject: result.subject,
                     documentText: result.documentText,
                     tags: result.tags ? JSON.parse(result.tags) : [],
                     editedAt: formatDate(result.editedAt),
                     createdAt: formatDate(result.createdAt),
-                };
+                }));
+                // If only one fuzzy match, return it directly
+                if (notes.length === 1) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    query: title,
+                                    graph_id,
+                                    note: notes[0],
+                                    matchType: "fuzzy"
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
                 return {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify({ title, graphId, note }, null, 2),
+                            text: JSON.stringify({
+                                query: title,
+                                graph_id,
+                                matchCount: notes.length,
+                                notes
+                            }, null, 2),
                         },
                     ],
                 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reflect-mcp",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "MCP server for Reflect Notes - connect your notes to Claude Desktop. Just run: npx reflect-mcp",
   "type": "module",
   "main": "dist/server.js",
@@ -15,7 +15,8 @@
     "build": "tsc",
     "dev": "tsx src/cli.ts",
     "start": "node dist/cli.js",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "postinstall": "npm rebuild better-sqlite3 || true"
   },
   "keywords": [
     "mcp",
@@ -36,8 +37,9 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.1",
-    "better-sqlite3": "^11.0.0",
+    "better-sqlite3": "^11.10.0",
     "fastmcp": "^3.25.4",
+    "reflect-mcp": "^1.0.3",
     "zod": "^4.1.13"
   },
   "devDependencies": {