obsidian-mcp-server 1.2.4 → 1.2.5

package/build/obsidian.js

@@ -23,12 +23,17 @@ export class ObsidianClient {
     config;
     constructor(config) {
         if (!config.apiKey) {
-            throw new ObsidianError("API key is required", 40100); // 40100 = Unauthorized
+            throw new ObsidianError("Missing API key. To fix this:\n" +
+                "1. Install the 'Local REST API' plugin in Obsidian\n" +
+                "2. Enable the plugin in Obsidian Settings\n" +
+                "3. Copy your API key from Obsidian Settings > Local REST API\n" +
+                "4. Provide the API key in your configuration", 40100 // Unauthorized
+            );
         }
         // Combine defaults with provided config
         this.config = {
             ...DEFAULT_OBSIDIAN_CONFIG,
-            verifySSL: config.verifySSL ?? process.env.NODE_ENV === 'production', // Enable SSL verification in production by default
+            verifySSL: config.verifySSL ?? true, // Default to true as required by Obsidian REST API plugin
             apiKey: config.apiKey,
             timeout: config.timeout ?? 5000, // 5 second default timeout
             maxContentLength: config.maxContentLength ?? 50 * 1024 * 1024, // 50MB
@@ -61,7 +66,9 @@ export class ObsidianClient {
             decompress: true
         };
         if (!this.config.verifySSL) {
-            console.warn("WARNING: SSL verification is disabled. This is not recommended for production use.", process.env.NODE_ENV === 'production' ? "Consider enabling SSL verification." : "This is acceptable for local development only.");
+            console.warn("WARNING: SSL verification is disabled. The Obsidian REST API plugin requires HTTPS by default.\n" +
+                "Make sure you have configured the certificate as a trusted certificate authority.\n" +
+                "See Obsidian Settings > Local REST API > 'How to Access' for setup instructions.");
         }
         this.client = axios.create(axiosConfig);
     }
@@ -88,17 +95,15 @@ export class ObsidianClient {
         // Prevent path traversal attacks
         const normalizedPath = filepath.replace(/\\/g, '/');
         if (normalizedPath.includes('../') || normalizedPath.includes('..\\')) {
-            throw new ObsidianError('Invalid file path: Path traversal not allowed', 40001); // 40001 = Path traversal error
+            throw new ObsidianError('Invalid file path: Path traversal not allowed', 40001);
         }
         // Additional path validations
         if (normalizedPath.startsWith('/') || /^[a-zA-Z]:/.test(normalizedPath)) {
-            throw new ObsidianError('Invalid file path: Absolute paths not allowed', 40002); // 40002 = Invalid path format
+            throw new ObsidianError('Invalid file path: Absolute paths not allowed', 40002);
         }
     }
     getErrorCode(status) {
-        // Convert HTTP status codes to 5-digit error codes
         switch (status) {
-            // Client errors (400-499)
             case 400: return 40000; // Bad request
             case 401: return 40100; // Unauthorized
             case 403: return 40300; // Forbidden
@@ -106,19 +111,17 @@ export class ObsidianClient {
             case 405: return 40500; // Method not allowed
             case 409: return 40900; // Conflict
             case 429: return 42900; // Too many requests
-            // Server errors (500-599)
             case 500: return 50000; // Internal server error
             case 501: return 50100; // Not implemented
             case 502: return 50200; // Bad gateway
             case 503: return 50300; // Service unavailable
             case 504: return 50400; // Gateway timeout
-            // Default cases
             default:
                 if (status >= 400 && status < 500)
                     return 40000 + (status - 400) * 100;
                 if (status >= 500 && status < 600)
                     return 50000 + (status - 500) * 100;
-                return 50000; // Default to internal server error
+                return 50000;
         }
     }
     async safeRequest(operation) {
@@ -130,16 +133,37 @@ export class ObsidianClient {
                 const axiosError = error;
                 const response = axiosError.response;
                 const errorData = response?.data;
-                // If the API returns a proper 5-digit error code, use it
-                // Otherwise, convert HTTP status to 5-digit code
-                const errorCode = errorData?.errorCode ??
-                    this.getErrorCode(response?.status ?? 500);
-                const message = errorData?.message ??
-                    axiosError.message ??
-                    "Unknown error";
+                // Handle common connection errors with helpful messages
+                if (error.code === 'DEPTH_ZERO_SELF_SIGNED_CERT' || error.code === 'UNABLE_TO_VERIFY_LEAF_SIGNATURE') {
+                    throw new ObsidianError(`SSL certificate verification failed. To fix this:\n` +
+                        `1. Go to Obsidian Settings > Local REST API\n` +
+                        `2. Under 'How to Access', copy the certificate\n` +
+                        `3. Configure the certificate as a trusted certificate authority\n` +
+                        `4. Ensure you're using HTTPS (HTTP is disabled by default)\n` +
+                        `Original error: ${error.message}`, 50001, // SSL error code
+                    { code: error.code, config: { verifySSL: this.config.verifySSL } });
+                }
+                if (error.code === 'ECONNREFUSED') {
+                    throw new ObsidianError(`Connection refused. To fix this:\n` +
+                        `1. Ensure Obsidian is running\n` +
+                        `2. Verify the 'Local REST API' plugin is enabled in Obsidian Settings\n` +
+                        `3. Check that you're using the correct host (${this.config.host}) and port (${this.config.port})\n` +
+                        `4. Make sure HTTPS is enabled in the plugin settings`, 50002, // Connection refused
+                    { code: error.code });
+                }
+                if (response?.status === 401) {
+                    throw new ObsidianError(`Authentication failed. To fix this:\n` +
+                        `1. Go to Obsidian Settings > Local REST API\n` +
+                        `2. Copy your API key from the settings\n` +
+                        `3. Update your configuration with the new API key\n` +
+                        `Note: The API key changes when you regenerate certificates`, 40100, // Unauthorized
+                    { code: error.code });
+                }
+                // For other errors, use API error code if available
+                const errorCode = errorData?.errorCode ?? this.getErrorCode(response?.status ?? 500);
+                const message = errorData?.message ?? axiosError.message ?? "Unknown error";
                 throw new ObsidianError(message, errorCode, errorData);
             }
-            // For non-Axios errors, use a generic server error code
             if (error instanceof Error) {
                 throw new ObsidianError(error.message, 50000, error);
             }
@@ -148,8 +172,6 @@ export class ObsidianClient {
     }
     async listFilesInVault() {
         return this.safeRequest(async () => {
-            const requestId = crypto.randomUUID();
-            console.debug(`[${requestId}] Listing vault files`);
             const response = await this.client.get("/vault/");
             return response.data.files;
         });
@@ -157,8 +179,6 @@ export class ObsidianClient {
     async listFilesInDir(dirpath) {
         this.validateFilePath(dirpath);
         return this.safeRequest(async () => {
-            const requestId = crypto.randomUUID();
-            console.debug(`[${requestId}] Listing files in directory: ${dirpath}`);
             const response = await this.client.get(`/vault/${dirpath}/`);
             return response.data.files;
         });
@@ -166,30 +186,22 @@ export class ObsidianClient {
     async getFileContents(filepath) {
         this.validateFilePath(filepath);
         return this.safeRequest(async () => {
-            const requestId = crypto.randomUUID();
-            console.debug(`[${requestId}] Getting file contents: ${filepath}`);
             const response = await this.client.get(`/vault/${filepath}`);
             return response.data;
         });
     }
     async search(query, contextLength = 100) {
         return this.safeRequest(async () => {
-            const requestId = crypto.randomUUID();
-            console.debug(`[${requestId}] Performing simple search: ${query}`);
-            const response = await this.client.post("/search/simple/", null, {
-                params: { query, contextLength }
-            });
+            const response = await this.client.post("/search/simple/", null, { params: { query, contextLength } });
             return response.data;
         });
     }
     async appendContent(filepath, content) {
         this.validateFilePath(filepath);
         if (!content || typeof content !== 'string') {
-            throw new ObsidianError('Invalid content: Content must be a non-empty string', 40003); // 40003 = Invalid content
+            throw new ObsidianError('Invalid content: Content must be a non-empty string', 40003);
         }
         return this.safeRequest(async () => {
-            const requestId = crypto.randomUUID();
-            console.debug(`[${requestId}] Appending content to: ${filepath}`);
             await this.client.post(`/vault/${filepath}`, content, {
                 headers: {
                     "Content-Type": "text/markdown"
@@ -200,11 +212,9 @@ export class ObsidianClient {
     async updateContent(filepath, content) {
         this.validateFilePath(filepath);
         if (!content || typeof content !== 'string') {
-            throw new ObsidianError('Invalid content: Content must be a non-empty string', 40003); // 40003 = Invalid content
+            throw new ObsidianError('Invalid content: Content must be a non-empty string', 40003);
         }
         return this.safeRequest(async () => {
-            const requestId = crypto.randomUUID();
-            console.debug(`[${requestId}] Updating content in: ${filepath}`);
             await this.client.put(`/vault/${filepath}`, content, {
                 headers: {
                     "Content-Type": "text/markdown"
@@ -214,9 +224,6 @@ export class ObsidianClient {
     }
     async searchJson(query) {
         return this.safeRequest(async () => {
-            const requestId = crypto.randomUUID();
-            console.debug(`[${requestId}] Performing complex search with query:`, JSON.stringify(query));
-            // Check if this is a tag-based search
             const isTagSearch = JSON.stringify(query).includes('"contains"') &&
                 JSON.stringify(query).includes('"#"');
             const response = await this.client.post("/search/", query, {
@@ -225,40 +232,29 @@ export class ObsidianClient {
                     "Accept": "application/vnd.olrapi.note+json"
                 }
             });
-            if (isTagSearch) {
-                return response.data;
-            }
-            return response.data;
+            return isTagSearch ? response.data : response.data;
         });
     }
     async getStatus() {
         return this.safeRequest(async () => {
-            const requestId = crypto.randomUUID();
-            console.debug(`[${requestId}] Getting server status`);
             const response = await this.client.get("/");
             return response.data;
         });
     }
     async listCommands() {
         return this.safeRequest(async () => {
-            const requestId = crypto.randomUUID();
-            console.debug(`[${requestId}] Listing available commands`);
             const response = await this.client.get("/commands/");
             return response.data.commands;
         });
     }
     async executeCommand(commandId) {
         return this.safeRequest(async () => {
-            const requestId = crypto.randomUUID();
-            console.debug(`[${requestId}] Executing command: ${commandId}`);
             await this.client.post(`/commands/${commandId}/`);
         });
     }
     async openFile(filepath, newLeaf = false) {
         this.validateFilePath(filepath);
         return this.safeRequest(async () => {
-            const requestId = crypto.randomUUID();
-            console.debug(`[${requestId}] Opening file: ${filepath}`);
             await this.client.post(`/open/${filepath}`, null, {
                 params: { newLeaf }
             });
@@ -266,8 +262,6 @@ export class ObsidianClient {
     }
     async getActiveFile() {
         return this.safeRequest(async () => {
-            const requestId = crypto.randomUUID();
-            console.debug(`[${requestId}] Getting active file`);
             const response = await this.client.get("/active/", {
                 headers: {
                     "Accept": "application/vnd.olrapi.note+json"
@@ -278,8 +272,6 @@ export class ObsidianClient {
     }
     async updateActiveFile(content) {
         return this.safeRequest(async () => {
-            const requestId = crypto.randomUUID();
-            console.debug(`[${requestId}] Updating active file`);
             await this.client.put("/active/", content, {
                 headers: {
                     "Content-Type": "text/markdown"
@@ -289,15 +281,11 @@ export class ObsidianClient {
     }
     async deleteActiveFile() {
         return this.safeRequest(async () => {
-            const requestId = crypto.randomUUID();
-            console.debug(`[${requestId}] Deleting active file`);
             await this.client.delete("/active/");
         });
     }
     async patchActiveFile(operation, targetType, target, content, options) {
         return this.safeRequest(async () => {
-            const requestId = crypto.randomUUID();
-            console.debug(`[${requestId}] Patching active file: ${operation} ${targetType} ${target}`);
             const headers = {
                 "Operation": operation,
                 "Target-Type": targetType,
@@ -315,8 +303,6 @@ export class ObsidianClient {
     }
     async getPeriodicNote(period) {
         return this.safeRequest(async () => {
-            const requestId = crypto.randomUUID();
-            console.debug(`[${requestId}] Getting ${period} note`);
             const response = await this.client.get(`/periodic/${period}/`, {
                 headers: {
                     "Accept": "application/vnd.olrapi.note+json"
@@ -327,8 +313,6 @@ export class ObsidianClient {
     }
     async updatePeriodicNote(period, content) {
         return this.safeRequest(async () => {
-            const requestId = crypto.randomUUID();
-            console.debug(`[${requestId}] Updating ${period} note`);
             await this.client.put(`/periodic/${period}/`, content, {
                 headers: {
                     "Content-Type": "text/markdown"
@@ -338,15 +322,11 @@ export class ObsidianClient {
     }
     async deletePeriodicNote(period) {
         return this.safeRequest(async () => {
-            const requestId = crypto.randomUUID();
-            console.debug(`[${requestId}] Deleting ${period} note`);
             await this.client.delete(`/periodic/${period}/`);
         });
     }
     async patchPeriodicNote(period, operation, targetType, target, content, options) {
         return this.safeRequest(async () => {
-            const requestId = crypto.randomUUID();
-            console.debug(`[${requestId}] Patching ${period} note: ${operation} ${targetType} ${target}`);
             const headers = {
                 "Operation": operation,
                 "Target-Type": targetType,

package/build/resources.js

@@ -1,8 +1,16 @@
+import { PropertyManager } from "./properties.js";
 export class TagResource {
     client;
     static TAG_PATTERN = /#[a-zA-Z0-9_-]+/g;
+    tagCache = new Map();
+    propertyManager;
+    isInitialized = false;
+    lastUpdate = 0;
+    updateInterval = 5000; // 5 seconds
     constructor(client) {
         this.client = client;
+        this.propertyManager = new PropertyManager(client);
+        this.initializeCache();
     }
     getResourceDescription() {
         return {
@@ -12,37 +20,67 @@ export class TagResource {
             mimeType: "application/json"
         };
     }
-    async getContent() {
+    async initializeCache() {
         try {
-            // Search for files containing #
+            // Get all markdown files
             const query = {
-                "contains": [{ "var": "content" }, "#"]
+                "glob": ["**/*.md", { "var": "path" }]
             };
             const results = await this.client.searchJson(query);
-            // Process results to extract tags
-            const tagMap = new Map();
-            let totalOccurrences = 0;
-            let scannedFiles = 0;
-            results.forEach((result) => {
-                scannedFiles++;
-                if ('matches' in result) {
-                    result.matches.forEach((match) => {
-                        const tags = match.context.match(TagResource.TAG_PATTERN);
-                        if (tags) {
-                            tags.forEach((tag) => {
-                                if (!tagMap.has(tag)) {
-                                    tagMap.set(tag, new Set());
-                                }
-                                tagMap.get(tag).add(result.filename);
-                                totalOccurrences++;
-                            });
-                        }
+            this.tagCache.clear();
+            // Process each file
+            for (const result of results) {
+                if (!('filename' in result))
+                    continue;
+                try {
+                    const content = await this.client.getFileContents(result.filename);
+                    // Extract tags from frontmatter
+                    const properties = this.propertyManager.parseProperties(content);
+                    if (properties.tags) {
+                        properties.tags.forEach((tag) => {
+                            this.addTag(tag, result.filename);
+                        });
+                    }
+                    // Extract inline tags
+                    const inlineTags = content.match(TagResource.TAG_PATTERN) || [];
+                    inlineTags.forEach(tag => {
+                        this.addTag(tag, result.filename);
                     });
                 }
-            });
-            // Convert to sorted response format
+                catch (error) {
+                    console.error(`Failed to process file ${result.filename}:`, error);
+                }
+            }
+            this.isInitialized = true;
+            this.lastUpdate = Date.now();
+        }
+        catch (error) {
+            console.error("Failed to initialize tag cache:", error);
+            throw error;
+        }
+    }
+    addTag(tag, filepath) {
+        if (!this.tagCache.has(tag)) {
+            this.tagCache.set(tag, new Set());
+        }
+        this.tagCache.get(tag).add(filepath);
+    }
+    async updateCacheIfNeeded() {
+        const now = Date.now();
+        if (now - this.lastUpdate > this.updateInterval) {
+            await this.initializeCache();
+        }
+    }
+    async getContent() {
+        try {
+            if (!this.isInitialized) {
+                await this.initializeCache();
+            }
+            else {
+                await this.updateCacheIfNeeded();
+            }
             const response = {
-                tags: Array.from(tagMap.entries())
+                tags: Array.from(this.tagCache.entries())
                     .map(([name, files]) => ({
                     name,
                     count: files.size,
@@ -50,18 +88,22 @@ export class TagResource {
                 }))
                     .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name)),
                 metadata: {
-                    totalOccurrences,
-                    uniqueTags: tagMap.size,
-                    scannedFiles
+                    totalOccurrences: Array.from(this.tagCache.values())
+                        .reduce((sum, files) => sum + files.size, 0),
+                    uniqueTags: this.tagCache.size,
+                    scannedFiles: new Set(Array.from(this.tagCache.values())
+                        .flatMap(files => Array.from(files))).size,
+                    lastUpdate: this.lastUpdate
                 }
             };
             return [{
                     type: "text",
-                    text: JSON.stringify(response, null, 2)
+                    text: JSON.stringify(response, null, 2),
+                    uri: this.getResourceDescription().uri
                 }];
         }
         catch (error) {
-            console.error("Failed to fetch tags:", error);
+            console.error("Failed to get tags:", error);
             throw error;
         }
     }

package/build/tools.js

@@ -641,7 +641,8 @@ export class GetTagsToolHandler extends BaseToolHandler {
                 metadata: {
                     totalOccurrences,
                     uniqueTags: tagMap.size,
-                    scannedFiles
+                    scannedFiles,
+                    lastUpdate: Date.now()
                 }
             };
             return this.createResponse(response);

package/build/types.js

@@ -1,5 +1,5 @@
 export const DEFAULT_OBSIDIAN_CONFIG = {
-    protocol: "https",
+    protocol: "https", // HTTPS required by default in Obsidian REST API plugin
     host: "127.0.0.1",
     port: 27124
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-mcp-server",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "description": "Model Context Protocol server for Obsidian integration with token-aware response handling",
   "main": "build/index.js",
   "type": "module",

package/src/obsidian.ts

@@ -41,13 +41,20 @@ export class ObsidianClient {
 
   constructor(config: ObsidianConfig) {
     if (!config.apiKey) {
-      throw new ObsidianError("API key is required", 40100); // 40100 = Unauthorized
+      throw new ObsidianError(
+        "Missing API key. To fix this:\n" +
+        "1. Install the 'Local REST API' plugin in Obsidian\n" +
+        "2. Enable the plugin in Obsidian Settings\n" +
+        "3. Copy your API key from Obsidian Settings > Local REST API\n" +
+        "4. Provide the API key in your configuration",
+        40100 // Unauthorized
+      );
     }
 
     // Combine defaults with provided config
     this.config = {
       ...DEFAULT_OBSIDIAN_CONFIG,
-      verifySSL: config.verifySSL ?? process.env.NODE_ENV === 'production', // Enable SSL verification in production by default
+      verifySSL: config.verifySSL ?? true, // Default to true as required by Obsidian REST API plugin
       apiKey: config.apiKey,
       timeout: config.timeout ?? 5000, // 5 second default timeout
       maxContentLength: config.maxContentLength ?? 50 * 1024 * 1024, // 50MB
@@ -84,8 +91,9 @@ export class ObsidianClient {
 
     if (!this.config.verifySSL) {
       console.warn(
-        "WARNING: SSL verification is disabled. This is not recommended for production use.",
-        process.env.NODE_ENV === 'production' ? "Consider enabling SSL verification." : "This is acceptable for local development only."
+        "WARNING: SSL verification is disabled. The Obsidian REST API plugin requires HTTPS by default.\n" +
+        "Make sure you have configured the certificate as a trusted certificate authority.\n" +
+        "See Obsidian Settings > Local REST API > 'How to Access' for setup instructions."
       );
     }
 
@@ -121,19 +129,17 @@ export class ObsidianClient {
     // Prevent path traversal attacks
     const normalizedPath = filepath.replace(/\\/g, '/');
     if (normalizedPath.includes('../') || normalizedPath.includes('..\\')) {
-      throw new ObsidianError('Invalid file path: Path traversal not allowed', 40001); // 40001 = Path traversal error
+      throw new ObsidianError('Invalid file path: Path traversal not allowed', 40001);
     }
     
     // Additional path validations
     if (normalizedPath.startsWith('/') || /^[a-zA-Z]:/.test(normalizedPath)) {
-      throw new ObsidianError('Invalid file path: Absolute paths not allowed', 40002); // 40002 = Invalid path format
+      throw new ObsidianError('Invalid file path: Absolute paths not allowed', 40002);
     }
   }
 
   private getErrorCode(status: number): number {
-    // Convert HTTP status codes to 5-digit error codes
     switch (status) {
-      // Client errors (400-499)
       case 400: return 40000; // Bad request
       case 401: return 40100; // Unauthorized
       case 403: return 40300; // Forbidden
@@ -141,19 +147,15 @@ export class ObsidianClient {
       case 405: return 40500; // Method not allowed
       case 409: return 40900; // Conflict
       case 429: return 42900; // Too many requests
-      
-      // Server errors (500-599)
       case 500: return 50000; // Internal server error
       case 501: return 50100; // Not implemented
       case 502: return 50200; // Bad gateway
       case 503: return 50300; // Service unavailable
       case 504: return 50400; // Gateway timeout
-      
-      // Default cases
       default:
         if (status >= 400 && status < 500) return 40000 + (status - 400) * 100;
         if (status >= 500 && status < 600) return 50000 + (status - 500) * 100;
-        return 50000; // Default to internal server error
+        return 50000;
     }
   }
 
@@ -165,20 +167,51 @@ export class ObsidianClient {
         const axiosError = error as AxiosError<ApiError>;
         const response = axiosError.response;
         const errorData = response?.data;
-        
-        // If the API returns a proper 5-digit error code, use it
-        // Otherwise, convert HTTP status to 5-digit code
-        const errorCode = errorData?.errorCode ??
-          this.getErrorCode(response?.status ?? 500);
-        
-        const message = errorData?.message ??
-          axiosError.message ??
-          "Unknown error";
-        
+
+        // Handle common connection errors with helpful messages
+        if (error.code === 'DEPTH_ZERO_SELF_SIGNED_CERT' || error.code === 'UNABLE_TO_VERIFY_LEAF_SIGNATURE') {
+          throw new ObsidianError(
+            `SSL certificate verification failed. To fix this:\n` +
+            `1. Go to Obsidian Settings > Local REST API\n` +
+            `2. Under 'How to Access', copy the certificate\n` +
+            `3. Configure the certificate as a trusted certificate authority\n` +
+            `4. Ensure you're using HTTPS (HTTP is disabled by default)\n` +
+            `Original error: ${error.message}`,
+            50001, // SSL error code
+            { code: error.code, config: { verifySSL: this.config.verifySSL } }
+          );
+        }
+
+        if (error.code === 'ECONNREFUSED') {
+          throw new ObsidianError(
+            `Connection refused. To fix this:\n` +
+            `1. Ensure Obsidian is running\n` +
+            `2. Verify the 'Local REST API' plugin is enabled in Obsidian Settings\n` +
+            `3. Check that you're using the correct host (${this.config.host}) and port (${this.config.port})\n` +
+            `4. Make sure HTTPS is enabled in the plugin settings`,
+            50002, // Connection refused
+            { code: error.code }
+          );
+        }
+
+        if (response?.status === 401) {
+          throw new ObsidianError(
+            `Authentication failed. To fix this:\n` +
+            `1. Go to Obsidian Settings > Local REST API\n` +
+            `2. Copy your API key from the settings\n` +
+            `3. Update your configuration with the new API key\n` +
+            `Note: The API key changes when you regenerate certificates`,
+            40100, // Unauthorized
+            { code: error.code }
+          );
+        }
+
+        // For other errors, use API error code if available
+        const errorCode = errorData?.errorCode ?? this.getErrorCode(response?.status ?? 500);
+        const message = errorData?.message ?? axiosError.message ?? "Unknown error";
         throw new ObsidianError(message, errorCode, errorData);
       }
       
-      // For non-Axios errors, use a generic server error code
       if (error instanceof Error) {
         throw new ObsidianError(error.message, 50000, error);
       }
@@ -189,8 +222,6 @@ export class ObsidianClient {
 
   async listFilesInVault(): Promise<ObsidianFile[]> {
     return this.safeRequest(async () => {
-      const requestId = crypto.randomUUID();
-      console.debug(`[${requestId}] Listing vault files`);
       const response = await this.client.get<{ files: ObsidianFile[] }>("/vault/");
       return response.data.files;
     });
@@ -199,8 +230,6 @@ export class ObsidianClient {
   async listFilesInDir(dirpath: string): Promise<ObsidianFile[]> {
     this.validateFilePath(dirpath);
     return this.safeRequest(async () => {
-      const requestId = crypto.randomUUID();
-      console.debug(`[${requestId}] Listing files in directory: ${dirpath}`);
       const response = await this.client.get<{ files: ObsidianFile[] }>(`/vault/${dirpath}/`);
       return response.data.files;
     });
@@ -209,8 +238,6 @@ export class ObsidianClient {
   async getFileContents(filepath: string): Promise<string> {
     this.validateFilePath(filepath);
     return this.safeRequest(async () => {
-      const requestId = crypto.randomUUID();
-      console.debug(`[${requestId}] Getting file contents: ${filepath}`);
       const response = await this.client.get<string>(`/vault/${filepath}`);
       return response.data;
     });
@@ -218,14 +245,10 @@ export class ObsidianClient {
 
   async search(query: string, contextLength: number = 100): Promise<SimpleSearchResult[]> {
     return this.safeRequest(async () => {
-      const requestId = crypto.randomUUID();
-      console.debug(`[${requestId}] Performing simple search: ${query}`);
       const response = await this.client.post<SimpleSearchResult[]>(
         "/search/simple/",
         null,
-        {
-          params: { query, contextLength }
-        }
+        { params: { query, contextLength } }
       );
       return response.data;
     });
@@ -234,11 +257,9 @@ export class ObsidianClient {
   async appendContent(filepath: string, content: string): Promise<void> {
     this.validateFilePath(filepath);
     if (!content || typeof content !== 'string') {
-      throw new ObsidianError('Invalid content: Content must be a non-empty string', 40003); // 40003 = Invalid content
+      throw new ObsidianError('Invalid content: Content must be a non-empty string', 40003);
     }
     return this.safeRequest(async () => {
-      const requestId = crypto.randomUUID();
-      console.debug(`[${requestId}] Appending content to: ${filepath}`);
       await this.client.post(
         `/vault/${filepath}`,
         content,
@@ -254,12 +275,10 @@ export class ObsidianClient {
   async updateContent(filepath: string, content: string): Promise<void> {
     this.validateFilePath(filepath);
     if (!content || typeof content !== 'string') {
-      throw new ObsidianError('Invalid content: Content must be a non-empty string', 40003); // 40003 = Invalid content
+      throw new ObsidianError('Invalid content: Content must be a non-empty string', 40003);
     }
 
     return this.safeRequest(async () => {
-      const requestId = crypto.randomUUID();
-      console.debug(`[${requestId}] Updating content in: ${filepath}`);
       await this.client.put(
         `/vault/${filepath}`,
         content,
@@ -274,10 +293,6 @@ export class ObsidianClient {
 
   async searchJson(query: JsonLogicQuery): Promise<SearchResponse[]> {
     return this.safeRequest(async () => {
-      const requestId = crypto.randomUUID();
-      console.debug(`[${requestId}] Performing complex search with query:`, JSON.stringify(query));
-      
-      // Check if this is a tag-based search
       const isTagSearch = JSON.stringify(query).includes('"contains"') &&
                          JSON.stringify(query).includes('"#"');
       
@@ -292,17 +307,12 @@ export class ObsidianClient {
         }
       );
 
-      if (isTagSearch) {
-        return response.data as SimpleSearchResult[];
-      }
-      return response.data as SearchResult[];
+      return isTagSearch ? response.data as SimpleSearchResult[] : response.data as SearchResult[];
     });
   }
 
   async getStatus(): Promise<ObsidianStatus> {
     return this.safeRequest(async () => {
-      const requestId = crypto.randomUUID();
-      console.debug(`[${requestId}] Getting server status`);
       const response = await this.client.get<ObsidianStatus>("/");
       return response.data;
     });
@@ -310,8 +320,6 @@ export class ObsidianClient {
 
   async listCommands(): Promise<ObsidianCommand[]> {
     return this.safeRequest(async () => {
-      const requestId = crypto.randomUUID();
-      console.debug(`[${requestId}] Listing available commands`);
       const response = await this.client.get<{commands: ObsidianCommand[]}>("/commands/");
       return response.data.commands;
     });
@@ -319,8 +327,6 @@ export class ObsidianClient {
 
   async executeCommand(commandId: string): Promise<void> {
     return this.safeRequest(async () => {
-      const requestId = crypto.randomUUID();
-      console.debug(`[${requestId}] Executing command: ${commandId}`);
       await this.client.post(`/commands/${commandId}/`);
     });
   }
@@ -328,8 +334,6 @@ export class ObsidianClient {
   async openFile(filepath: string, newLeaf: boolean = false): Promise<void> {
     this.validateFilePath(filepath);
     return this.safeRequest(async () => {
-      const requestId = crypto.randomUUID();
-      console.debug(`[${requestId}] Opening file: ${filepath}`);
       await this.client.post(`/open/${filepath}`, null, {
         params: { newLeaf }
       });
@@ -338,8 +342,6 @@ export class ObsidianClient {
 
   async getActiveFile(): Promise<NoteJson> {
     return this.safeRequest(async () => {
-      const requestId = crypto.randomUUID();
-      console.debug(`[${requestId}] Getting active file`);
       const response = await this.client.get<NoteJson>("/active/", {
         headers: {
           "Accept": "application/vnd.olrapi.note+json"
@@ -351,8 +353,6 @@ export class ObsidianClient {
 
   async updateActiveFile(content: string): Promise<void> {
     return this.safeRequest(async () => {
-      const requestId = crypto.randomUUID();
-      console.debug(`[${requestId}] Updating active file`);
       await this.client.put("/active/", content, {
         headers: {
           "Content-Type": "text/markdown"
@@ -363,21 +363,22 @@ export class ObsidianClient {
 
   async deleteActiveFile(): Promise<void> {
     return this.safeRequest(async () => {
-      const requestId = crypto.randomUUID();
-      console.debug(`[${requestId}] Deleting active file`);
       await this.client.delete("/active/");
     });
   }
 
-  async patchActiveFile(operation: "append" | "prepend" | "replace", targetType: "heading" | "block" | "frontmatter", target: string, content: string, options?: {
-    delimiter?: string;
-    trimWhitespace?: boolean;
-    contentType?: "text/markdown" | "application/json";
-  }): Promise<void> {
+  async patchActiveFile(
+    operation: "append" | "prepend" | "replace",
+    targetType: "heading" | "block" | "frontmatter",
+    target: string,
+    content: string,
+    options?: {
+      delimiter?: string;
+      trimWhitespace?: boolean;
+      contentType?: "text/markdown" | "application/json";
+    }
+  ): Promise<void> {
     return this.safeRequest(async () => {
-      const requestId = crypto.randomUUID();
-      console.debug(`[${requestId}] Patching active file: ${operation} ${targetType} ${target}`);
-      
       const headers: Record<string, string> = {
         "Operation": operation,
         "Target-Type": targetType,
@@ -398,8 +399,6 @@ export class ObsidianClient {
 
   async getPeriodicNote(period: PeriodType["type"]): Promise<NoteJson> {
     return this.safeRequest(async () => {
-      const requestId = crypto.randomUUID();
-      console.debug(`[${requestId}] Getting ${period} note`);
       const response = await this.client.get<NoteJson>(`/periodic/${period}/`, {
         headers: {
           "Accept": "application/vnd.olrapi.note+json"
@@ -411,8 +410,6 @@ export class ObsidianClient {
 
   async updatePeriodicNote(period: PeriodType["type"], content: string): Promise<void> {
     return this.safeRequest(async () => {
-      const requestId = crypto.randomUUID();
-      console.debug(`[${requestId}] Updating ${period} note`);
       await this.client.put(`/periodic/${period}/`, content, {
         headers: {
           "Content-Type": "text/markdown"
@@ -423,21 +420,23 @@ export class ObsidianClient {
 
   async deletePeriodicNote(period: PeriodType["type"]): Promise<void> {
     return this.safeRequest(async () => {
-      const requestId = crypto.randomUUID();
-      console.debug(`[${requestId}] Deleting ${period} note`);
       await this.client.delete(`/periodic/${period}/`);
     });
   }
 
-  async patchPeriodicNote(period: PeriodType["type"], operation: "append" | "prepend" | "replace", targetType: "heading" | "block" | "frontmatter", target: string, content: string, options?: {
-    delimiter?: string;
-    trimWhitespace?: boolean;
-    contentType?: "text/markdown" | "application/json";
-  }): Promise<void> {
+  async patchPeriodicNote(
+    period: PeriodType["type"],
+    operation: "append" | "prepend" | "replace",
+    targetType: "heading" | "block" | "frontmatter",
+    target: string,
+    content: string,
+    options?: {
+      delimiter?: string;
+      trimWhitespace?: boolean;
+      contentType?: "text/markdown" | "application/json";
+    }
+  ): Promise<void> {
     return this.safeRequest(async () => {
-      const requestId = crypto.randomUUID();
-      console.debug(`[${requestId}] Patching ${period} note: ${operation} ${targetType} ${target}`);
-      
       const headers: Record<string, string> = {
         "Operation": operation,
         "Target-Type": targetType,

package/src/resources.ts

@@ -1,11 +1,20 @@
 import { Resource, TextContent } from "@modelcontextprotocol/sdk/types.js";
 import { ObsidianClient } from "./obsidian.js";
-import { TagResponse, SearchMatch, SimpleSearchResult, SearchResponse } from "./types.js";
+import { TagResponse, ObsidianFile, JsonLogicQuery } from "./types.js";
+import { PropertyManager } from "./properties.js";
 
 export class TagResource {
   private static readonly TAG_PATTERN = /#[a-zA-Z0-9_-]+/g;
+  private tagCache: Map<string, Set<string>> = new Map();
+  private propertyManager: PropertyManager;
+  private isInitialized = false;
+  private lastUpdate = 0;
+  private updateInterval = 5000; // 5 seconds
 
-  constructor(private client: ObsidianClient) {}
+  constructor(private client: ObsidianClient) {
+    this.propertyManager = new PropertyManager(client);
+    this.initializeCache();
+  }
 
   getResourceDescription(): Resource {
     return {
@@ -16,41 +25,73 @@ export class TagResource {
     };
   }
 
-  async getContent(): Promise<TextContent[]> {
+  private async initializeCache() {
     try {
-      // Search for files containing #
-      const query = {
-        "contains": [{ "var": "content" }, "#"]
+      // Get all markdown files
+      const query: JsonLogicQuery = {
+        "glob": ["**/*.md", { "var": "path" }]
       };
-
+      
       const results = await this.client.searchJson(query);
+      this.tagCache.clear();
 
-      // Process results to extract tags
-      const tagMap = new Map<string, Set<string>>();
-      let totalOccurrences = 0;
-      let scannedFiles = 0;
-
-      results.forEach((result: SearchResponse) => {
-        scannedFiles++;
-        if ('matches' in result) {
-          result.matches.forEach((match: SearchMatch) => {
-            const tags = match.context.match(TagResource.TAG_PATTERN);
-            if (tags) {
-              tags.forEach((tag: string) => {
-                if (!tagMap.has(tag)) {
-                  tagMap.set(tag, new Set());
-                }
-                tagMap.get(tag)!.add(result.filename);
-                totalOccurrences++;
-              });
-            }
+      // Process each file
+      for (const result of results) {
+        if (!('filename' in result)) continue;
+        
+        try {
+          const content = await this.client.getFileContents(result.filename);
+          
+          // Extract tags from frontmatter
+          const properties = this.propertyManager.parseProperties(content);
+          if (properties.tags) {
+            properties.tags.forEach((tag: string) => {
+              this.addTag(tag, result.filename);
+            });
+          }
+          
+          // Extract inline tags
+          const inlineTags = content.match(TagResource.TAG_PATTERN) || [];
+          inlineTags.forEach(tag => {
+            this.addTag(tag, result.filename);
           });
+        } catch (error) {
+          console.error(`Failed to process file ${result.filename}:`, error);
         }
-      });
+      }
+
+      this.isInitialized = true;
+      this.lastUpdate = Date.now();
+    } catch (error) {
+      console.error("Failed to initialize tag cache:", error);
+      throw error;
+    }
+  }
+
+  private addTag(tag: string, filepath: string) {
+    if (!this.tagCache.has(tag)) {
+      this.tagCache.set(tag, new Set());
+    }
+    this.tagCache.get(tag)!.add(filepath);
+  }
+
+  private async updateCacheIfNeeded() {
+    const now = Date.now();
+    if (now - this.lastUpdate > this.updateInterval) {
+      await this.initializeCache();
+    }
+  }
+
+  async getContent(): Promise<TextContent[]> {
+    try {
+      if (!this.isInitialized) {
+        await this.initializeCache();
+      } else {
+        await this.updateCacheIfNeeded();
+      }
 
-      // Convert to sorted response format
       const response: TagResponse = {
-        tags: Array.from(tagMap.entries())
+        tags: Array.from(this.tagCache.entries())
           .map(([name, files]) => ({
             name,
             count: files.size,
@@ -58,18 +99,24 @@ export class TagResource {
           }))
           .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name)),
         metadata: {
-          totalOccurrences,
-          uniqueTags: tagMap.size,
-          scannedFiles
+          totalOccurrences: Array.from(this.tagCache.values())
+            .reduce((sum, files) => sum + files.size, 0),
+          uniqueTags: this.tagCache.size,
+          scannedFiles: new Set(
+            Array.from(this.tagCache.values())
+              .flatMap(files => Array.from(files))
+          ).size,
+          lastUpdate: this.lastUpdate
         }
       };
 
       return [{
         type: "text",
-        text: JSON.stringify(response, null, 2)
+        text: JSON.stringify(response, null, 2),
+        uri: this.getResourceDescription().uri
       }];
     } catch (error) {
-      console.error("Failed to fetch tags:", error);
+      console.error("Failed to get tags:", error);
       throw error;
     }
   }

package/src/tools.ts

@@ -714,7 +714,8 @@ export class GetTagsToolHandler extends BaseToolHandler<GetTagsArgs> {
         metadata: {
           totalOccurrences,
           uniqueTags: tagMap.size,
-          scannedFiles
+          scannedFiles,
+          lastUpdate: Date.now()
         }
       };
 

package/src/types.ts

@@ -15,7 +15,7 @@ export interface ObsidianServerConfig {
 }
 
 export const DEFAULT_OBSIDIAN_CONFIG: ObsidianServerConfig = {
-  protocol: "https",
+  protocol: "https", // HTTPS required by default in Obsidian REST API plugin
   host: "127.0.0.1",
   port: 27124
 } as const;
@@ -129,6 +129,7 @@ export interface TagMetadata {
   totalOccurrences: number;
   uniqueTags: number;
   scannedFiles: number;
+  lastUpdate: number;  // Timestamp of last cache update
 }
 
 export interface TagResponse {