reflect-mcp 1.0.4 → 1.0.5

package/README.md

@@ -125,8 +125,6 @@ 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/server.js

@@ -63,7 +63,6 @@ export async function startReflectMCPServer(config) {
     await server.start({
         httpStream: {
             port,
-            stateless: true,
         },
         transportType: "httpStream",
     });

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.",
+        description: "Get a list of all Reflect graphs accessible with the current access token",
         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 Reflect. Use  this tool to get more context about a note after calling the get_note tool.",
+        description: "Get backlinks for a note from the local Reflect database. Returns notes that link to the specified note.",
         parameters: z.object({
             subject: z.string().describe("The subject/title of the note to get backlinks for"),
-            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graphId: 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, graph_id, limit } = args;
+            const { subject, graphId, 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, graph_id, limit);
+                const results = stmt.all(subject, graphId, 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, graph_id, backlinks }, null, 2),
+                            text: JSON.stringify({ subject, graphId, 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 Reflect.",
+        description: "Get the most recent daily notes from the local Reflect database",
         parameters: z.object({
             limit: z.number().default(5).describe("Number of recent daily notes to return"),
-            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graphId: z.string().default("rapheal-brain").describe("The graph ID to search in"),
         }),
         execute: async (args) => {
-            const { limit, graph_id } = args;
+            const { limit, graphId } = 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(graph_id, limit);
+                const rows = stmt.all(graphId, 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),
-                    graph_id: row.graphId,
+                    graphId: row.graphId,
                 }));
                 return {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify({ graph_id, count: dailyNotes.length, dailyNotes }, null, 2),
+                            text: JSON.stringify({ graphId, 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.",
+        description: "Get the daily note for a specific date from the local Reflect database",
         parameters: z.object({
             date: z.string().describe("The date in YYYY-MM-DD format"),
-            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graphId: z.string().default("rapheal-brain").describe("The graph ID to search in"),
         }),
         execute: async (args) => {
-            const { date, graph_id } = args;
+            const { date, graphId } = 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(graph_id, dateMs);
+                const result = stmt.get(graphId, dateMs);
                 db.close();
                 if (!result) {
                     return {
                         content: [
                             {
                                 type: "text",
-                                text: JSON.stringify({ error: `No daily note found for ${date}`, date, graph_id }),
+                                text: JSON.stringify({ error: `No daily note found for ${date}`, date, graphId }),
                             },
                         ],
                     };
@@ -199,13 +199,13 @@ export function registerTools(server, dbPath) {
                     editedAt: formatDate(result.editedAt),
                     tags: result.tags ? JSON.parse(result.tags) : [],
                     dailyDate: formatDate(result.dailyDate),
-                    graph_id: result.graph_id,
+                    graphId: result.graphId,
                 };
                 return {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify({ date, graph_id, dailyNote }, null, 2),
+                            text: JSON.stringify({ date, graphId, 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 Reflect.",
+        description: "Get notes that have at least a minimum number of backlinks from the local Reflect database",
         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"),
-            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graphId: z.string().default("rapheal-brain").describe("The graph ID to search in"),
         }),
         execute: async (args) => {
-            const { minBacklinks, limit, graph_id } = args;
+            const { minBacklinks, limit, graphId } = 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(graph_id, minBacklinks, limit);
+                const results = stmt.all(graphId, 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({ graph_id, minBacklinks, count: notes.length, notes }, null, 2),
+                            text: JSON.stringify({ graphId, 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 Reflect.",
+        description: "Get all unique tags with their usage counts from the local Reflect database",
         parameters: z.object({
-            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graphId: 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 { graph_id, limit } = args;
+            const { graphId, 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(graph_id);
+                const rows = stmt.all(graphId);
                 db.close();
                 const tagCounts = {};
                 for (const row of rows) {
@@ -314,7 +314,7 @@ export function registerTools(server, dbPath) {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify({ graph_id, totalTags: Object.keys(tagCounts).length, tags: sortedTags }, null, 2),
+                            text: JSON.stringify({ graphId, 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 Reflect.",
+        description: "Get notes that have a specific tag from the local Reflect database",
         parameters: z.object({
             tag: z.string().describe("The tag to search for"),
-            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graphId: 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, graph_id, limit } = args;
+            const { tag, graphId, 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(graph_id, `%"${tag}"%`, limit);
+                const results = stmt.all(graphId, `%"${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, graph_id, count: notes.length, notes }, null, 2),
+                            text: JSON.stringify({ tag, graphId, count: notes.length, notes }, null, 2),
                         },
                     ],
                 };
@@ -383,116 +383,49 @@ export function registerTools(server, dbPath) {
             }
         },
     });
-    // Tool: Get a note by title (exact match first, then fuzzy fallback)
+    // Tool: Get a note by title
     server.addTool({
         name: "get_note",
-        description: "Get a note by its title (subject) from Reflect.",
+        description: "Get a note by its title (subject) from the local Reflect database",
         parameters: z.object({
             title: z.string().describe("The title/subject of the note to retrieve"),
-            graph_id: z.string().default("rapheal-brain").describe("The graph ID to search in"),
+            graphId: z.string().default("rapheal-brain").describe("The graph ID to search in"),
         }),
         execute: async (args) => {
-            const { title, graph_id } = args;
-            const FUZZY_LIMIT = 3;
+            const { title, graphId } = args;
             try {
                 const dbFile = resolvedDbPath;
                 const db = new Database(dbFile, { readonly: true });
-                // Try exact match first
-                const exactStmt = db.prepare(`
+                const stmt = db.prepare(`
           SELECT id, subject, documentText, tags, editedAt, createdAt
           FROM notes 
           WHERE isDeleted = 0 AND graphId = ? AND subject = ?
         `);
-                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);
+                const result = stmt.get(graphId, title);
                 db.close();
-                if (fuzzyResults.length === 0) {
+                if (!result) {
                     return {
                         content: [
                             {
                                 type: "text",
-                                text: JSON.stringify({
-                                    error: `No notes found matching '${title}'`,
-                                    query: title,
-                                    graph_id
-                                }),
+                                text: JSON.stringify({ error: `Note '${title}' not found`, title, graphId }),
                             },
                         ],
                     };
                 }
-                const notes = fuzzyResults.map((result) => ({
+                const note = {
                     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({
-                                query: title,
-                                graph_id,
-                                matchCount: notes.length,
-                                notes
-                            }, null, 2),
+                            text: JSON.stringify({ title, graphId, note }, null, 2),
                         },
                     ],
                 };

package/package.json

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