Ensure Knowledge Graphs performs optimally (ensuring the content you are looking can be found with ease!)

Author: embium

CHANGES.txt

@@ -55,7 +55,12 @@
 
 - Enhance the prompt used when Smart Hubs are included in a user's reponse
 
-
 ## 0.1.0
 
 - Integrate Knowledge Graphs using Neo4j
+
+## 0.1.1
+
+- Update current note's state when title is updated
+- Align chevron icons properly when listing folders in Notes Tab
+- Ensure Knowledge Graphs performs optimally (ensuring the content you are looking can be found with ease!)

package.json

@@ -1,7 +1,7 @@
 {
   "name": "notebit",
   "description": "Notebit is a cross-platform desktop note-taking application built with Electron, React, and TypeScript.",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "author": {
     "email": "mikeymooney1991@gmail.com",
     "name": "Michael Mooney"

src/shared/routers/notes.ts

@@ -474,6 +474,12 @@ export const notesRouter = router({
     return await deleteNote(input);
   }),
 
+  deleteNoteVectors: publicProcedure
+    .input(z.string())
+    .mutation(async ({ input }) => {
+      await deleteNoteVectors(input);
+    }),
+
   // Move note or folder
   moveItem: publicProcedure
     .input(

src/shared/routers/smartHubs.ts

@@ -13,6 +13,7 @@ import fs from 'fs';
 import neo4jService from '../services/neo4jService';
 import smartHubsKnowledgeGraphService from '../services/smartHubsKnowledgeGraphService';
 import { EntityType } from '../services/entityExtractor';
+import vectorStorageService from '../services/vectorStorageService';
 
 // Import electron dialog conditionally in main process only
 let dialog: any;
@@ -359,23 +360,21 @@ export const smartHubsRouter = router({
   hybridSearch: publicProcedure
     .input(
       z.object({
+        queryText: z.string(),
         queryEmbedding: z.array(z.number()),
         smartHubIds: z.array(z.string()),
         similarityThreshold: z.number().min(0).max(1).optional().default(0.7),
         limit: z.number().optional().default(5),
-        graphDepth: z.number().optional().default(2),
-        graphResultCount: z.number().optional().default(5),
       })
     )
     .query(async ({ input }) => {
       try {
         const results = await smartHubsKnowledgeGraphService.hybridSearch(
+          input.queryText,
           input.queryEmbedding,
           input.smartHubIds,
           input.similarityThreshold,
-          input.limit,
-          input.graphDepth,
-          input.graphResultCount
+          input.limit
         );
 
         return results;
@@ -385,6 +384,35 @@ export const smartHubsRouter = router({
       }
     }),
 
+  /**
+   * Knowledge graph search
+   */
+  knowledgeGraphSearch: publicProcedure
+    .input(
+      z.object({
+        query: z.string(),
+        smartHubIds: z.array(z.string()),
+        similarityThreshold: z.number().min(0).max(1).optional().default(0.7),
+        limit: z.number().optional().default(5),
+      })
+    )
+    .query(async ({ input }) => {
+      try {
+        const results =
+          await smartHubsKnowledgeGraphService.knowledgeGraphSearch(
+            input.query,
+            input.smartHubIds,
+            input.similarityThreshold,
+            input.limit
+          );
+
+        return results;
+      } catch (error) {
+        console.error('Error performing hybrid search:', error);
+        return [];
+      }
+    }),
+
   /**
    * Get content for hybrid search results
    */
@@ -515,4 +543,39 @@ export const smartHubsRouter = router({
         return false;
       }
     }),
+
+  /**
+   * Check Neo4j connection status
+   * Returns detailed information about the Neo4j connection
+   */
+  checkNeo4jStatus: publicProcedure.query(async () => {
+    try {
+      return await neo4jService.checkNeo4jStatus();
+    } catch (error) {
+      console.error('Error checking Neo4j status:', error);
+      return {
+        isConfigured: false,
+        isConnected: false,
+        message: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      };
+    }
+  }),
+
+  /**
+   * Get all documents for a smart hub
+   * Used for rebuilding knowledge graph
+   */
+  getAllDocuments: publicProcedure
+    .input(z.string())
+    .query(async ({ input: smartHubId }) => {
+      try {
+        return await vectorStorageService.getAllDocuments(smartHubId);
+      } catch (error) {
+        console.error(
+          `Error getting documents for smart hub ${smartHubId}:`,
+          error
+        );
+        return [];
+      }
+    }),
 });

src/shared/services/entityExtractor.ts

@@ -85,7 +85,6 @@ export class EntityExtractor {
     }
 
     try {
-      const entities: ExtractedEntity[] = [];
       const entityMap = new Map<string, ExtractedEntity>();
 
       // Use compromise for entity extraction
@@ -190,7 +189,8 @@ export class EntityExtractor {
               entityMap.set(key, {
                 type: 'Concept',
                 name,
-                confidence: 0.5, // Lower confidence for general concepts
+                // Give higher confidence to important concepts
+                confidence: 0.5,
                 mentions: 1,
               });
             }
@@ -199,13 +199,15 @@ export class EntityExtractor {
       }
 
       // Convert map to array and sort by confidence and mentions
-      return Array.from(entityMap.values()).sort((a, b) => {
+      const result = Array.from(entityMap.values()).sort((a, b) => {
         // Sort by confidence first, then by mentions
         if (b.confidence !== a.confidence) {
           return b.confidence - a.confidence;
         }
         return b.mentions - a.mentions;
       });
+
+      return result;
     } catch (error) {
       console.error('Error extracting entities:', error);
       return [];
@@ -220,6 +222,11 @@ export class EntityExtractor {
   private extractTechnologyTerms(text: string): string[] {
     const techTerms: string[] = [];
 
+    // Helper function to escape special regex characters
+    const escapeRegExp = (string: string): string => {
+      return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    };
+
     // Common technology keywords
     const techKeywords = [
       'api',
@@ -323,50 +330,67 @@ export class EntityExtractor {
 
     // Check for tech names (specific technologies)
     for (const tech of techNames) {
-      const regex = new RegExp(`\\b${tech}\\b`, 'gi');
-      if (regex.test(text)) {
-        techTerms.push(tech);
+      // Escape special regex characters
+      const escapedTech = escapeRegExp(tech);
+      try {
+        const regex = new RegExp(`\\b${escapedTech}\\b`, 'gi');
+        if (regex.test(text)) {
+          techTerms.push(tech);
+        }
+      } catch (error) {
+        console.error(
+          `Error creating regex for technology term "${tech}":`,
+          error
+        );
+        // Continue with other terms even if one fails
       }
     }
 
     // Extract phrases containing tech keywords
     const sentences = text.split(/[.!?]+/);
     for (const sentence of sentences) {
       for (const keyword of techKeywords) {
-        const regex = new RegExp(`\\b${keyword}\\b`, 'i');
-        if (regex.test(sentence)) {
-          // Extract noun phrases around the keyword
-          const words = sentence.split(/\s+/);
-          const keywordIndex = words.findIndex((word) =>
-            word.toLowerCase().includes(keyword)
-          );
-
-          if (keywordIndex >= 0) {
-            // Try to extract a meaningful phrase (up to 3 words)
-            let phrase = words[keywordIndex];
-
-            // Add preceding word if it looks like an adjective or proper noun
-            if (
-              keywordIndex > 0 &&
-              !words[keywordIndex - 1].match(
-                /^(the|a|an|this|that|these|those|my|your|our|their)$/i
-              )
-            ) {
-              phrase = words[keywordIndex - 1] + ' ' + phrase;
+        try {
+          // Escape special regex characters
+          const escapedKeyword = escapeRegExp(keyword);
+          const regex = new RegExp(`\\b${escapedKeyword}\\b`, 'i');
+          if (regex.test(sentence)) {
+            // Extract noun phrases around the keyword
+            const words = sentence.split(/\s+/);
+            const keywordIndex = words.findIndex((word) =>
+              word.toLowerCase().includes(keyword)
+            );
+
+            if (keywordIndex >= 0) {
+              // Try to extract a meaningful phrase (up to 3 words)
+              let phrase = words[keywordIndex];
+
+              // Add preceding word if it looks like an adjective or proper noun
+              if (
+                keywordIndex > 0 &&
+                !words[keywordIndex - 1].match(
+                  /^(the|a|an|this|that|these|those|my|your|our|their)$/i
+                )
+              ) {
+                phrase = words[keywordIndex - 1] + ' ' + phrase;
+              }
+
+              // Add following word if it looks like it could be part of the phrase
+              if (
+                keywordIndex < words.length - 1 &&
+                !words[keywordIndex + 1].match(
+                  /^(is|are|was|were|will|would|could|should|and|or|but)$/i
+                )
+              ) {
+                phrase = phrase + ' ' + words[keywordIndex + 1];
+              }
+
+              techTerms.push(phrase.trim());
             }
-
-            // Add following word if it looks like it could be part of the phrase
-            if (
-              keywordIndex < words.length - 1 &&
-              !words[keywordIndex + 1].match(
-                /^(is|are|was|were|will|would|could|should|and|or|but)$/i
-              )
-            ) {
-              phrase = phrase + ' ' + words[keywordIndex + 1];
-            }
-
-            techTerms.push(phrase.trim());
           }
+        } catch (error) {
+          console.error(`Error processing keyword "${keyword}":`, error);
+          // Continue with other keywords even if one fails
         }
       }
     }