**feat(core, statistics, storage): enhance service-level statistics tracking and result filtering**

- **Core**: Introduced a `getCurrentAugmentation` method for detecting active augmentation names. Updated metadata handling to include `createdBy`, `createdAt`, and `updatedAt` attributes for improved tracking.
- **Storage**: Added support for service-based statistics tracking with new methods such as `incrementStatistic`, `decrementStatistic`, and `updateHnswIndexSize`. Implemented persistence for statistics in storage adapters.
- **Statistics**: Enhanced `getStatistics` functionality to provide service-specific breakdowns and support filtering by services. Improved noun, verb, and metadata tracking mechanisms.
- **Search**: Added `service` option to filter results during searches for nouns, verbs, and metadata, ensuring accurate service-based query results.
- **Refactor**: Simplified search logic by integrating HNSW index filtering for better performance when retrieving service-specific results.
- **Tests**: Added comprehensive test coverage for service-level statistics and filtering by service.

**Purpose**: Improve service-level data tracking and analytics while enhancing functionality for filtering and maintaining metadata accuracy to support detailed insights for diverse use cases.

src/brainyData.ts

@@ -35,8 +35,9 @@ import {
     ServerSearchConduitAugmentation,
     createServerSearchAugmentations
 } from './augmentations/serverSearchAugmentations.js'
-import {WebSocketConnection} from './types/augmentations.js'
+import {WebSocketConnection, AugmentationType, IAugmentation} from './types/augmentations.js'
 import {BrainyDataInterface} from './types/brainyDataInterface.js'
+import {augmentationPipeline} from './augmentationPipeline.js'
 
 export interface BrainyDataConfig {
     /**
@@ -263,6 +264,36 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
         }
     }
     
+    /**
+     * Get the current augmentation name if available
+     * This is used to auto-detect the service performing data operations
+     * @returns The name of the current augmentation or 'default' if none is detected
+     */
+    private getCurrentAugmentation(): string {
+        try {
+            // Get all registered augmentations
+            const augmentationTypes = augmentationPipeline.getAvailableAugmentationTypes()
+            
+            // Check each type of augmentation
+            for (const type of augmentationTypes) {
+                const augmentations = augmentationPipeline.getAugmentationsByType(type)
+                
+                // Find the first enabled augmentation
+                for (const augmentation of augmentations) {
+                    if (augmentation.enabled) {
+                        return augmentation.name
+                    }
+                }
+            }
+            
+            return 'default'
+        } catch (error) {
+            // If there's any error in detection, return default
+            console.warn('Failed to detect current augmentation:', error)
+            return 'default'
+        }
+    }
+
     /**
      * Initialize the database
      * Loads existing data from storage if available
@@ -452,6 +483,7 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
             forceEmbed?: boolean // Force using the embedding function even if input is a vector
             addToRemote?: boolean // Whether to also add to the remote server if connected
             id?: string // Optional ID to use instead of generating a new one
+            service?: string // The service that is inserting the data
         } = {}
     ): Promise<string> {
         await this.ensureInitialized()
@@ -509,6 +541,10 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
             // Save noun to storage
             await this.storage!.saveNoun(noun)
 
+            // Track noun statistics
+            const service = options.service || this.getCurrentAugmentation()
+            await this.storage!.incrementStatistic('noun', service)
+
             // Save metadata if provided
             if (metadata !== undefined) {
                 // Validate noun type if metadata is for a GraphNoun
@@ -525,6 +561,33 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
                         // Set a default noun type
                         ;(metadata as unknown as GraphNoun).noun = NounType.Concept
                     }
+                    
+                    // Ensure createdBy field is populated for GraphNoun
+                    const service = options.service || this.getCurrentAugmentation()
+                    const graphNoun = metadata as unknown as GraphNoun
+                    
+                    // Only set createdBy if it doesn't exist or is being explicitly updated
+                    if (!graphNoun.createdBy || options.service) {
+                        graphNoun.createdBy = {
+                            augmentation: service,
+                            version: '1.0' // TODO: Get actual version from augmentation
+                        }
+                    }
+                    
+                    // Update timestamps
+                    const now = new Date()
+                    const timestamp = {
+                        seconds: Math.floor(now.getTime() / 1000),
+                        nanoseconds: (now.getTime() % 1000) * 1000000
+                    }
+                    
+                    // Set createdAt if it doesn't exist
+                    if (!graphNoun.createdAt) {
+                        graphNoun.createdAt = timestamp
+                    }
+                    
+                    // Always update updatedAt
+                    graphNoun.updatedAt = timestamp
                 }
 
                 // Ensure metadata has the correct id field
@@ -534,8 +597,15 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
                 }
 
                 await this.storage!.saveMetadata(id, metadataToSave)
+                
+                // Track metadata statistics
+                const metadataService = options.service || this.getCurrentAugmentation()
+                await this.storage!.incrementStatistic('metadata', metadataService)
             }
 
+            // Update HNSW index size (excluding verbs)
+            await this.storage!.updateHnswIndexSize(await this.getNounCount())
+
             // If addToRemote is true and we're connected to a remote server, add to remote as well
             if (options.addToRemote && this.isConnectedToRemoteServer()) {
                 try {
@@ -791,6 +861,30 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
         return this.addBatch(items, {...options, addToRemote: true})
     }
 
+    /**
+     * Filter search results by service
+     * @param results Search results to filter
+     * @param service Service to filter by
+     * @returns Filtered search results
+     * @private
+     */
+    private filterResultsByService<R extends SearchResult<T>>(
+        results: R[],
+        service?: string
+    ): R[] {
+        if (!service) return results
+        
+        return results.filter(result => {
+            if (!result.metadata || typeof result.metadata !== 'object') return false
+            if (!('createdBy' in result.metadata)) return false
+            
+            const createdBy = result.metadata.createdBy as any
+            if (!createdBy) return false
+            
+            return createdBy.augmentation === service
+        })
+    }
+    
     /**
      * Search for similar vectors within specific noun types
      * @param queryVectorOrData Query vector or data to search for
@@ -805,8 +899,22 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
         nounTypes: string[] | null = null,
         options: {
             forceEmbed?: boolean // Force using the embedding function even if input is a vector
+            service?: string // Filter results by the service that created the data
         } = {}
     ): Promise<SearchResult<T>[]> {
+        // Helper function to filter results by service
+        const filterByService = (metadata: any): boolean => {
+            if (!options.service) return true // No filter, include all
+            
+            // Check if metadata has createdBy field with matching service
+            if (!metadata || typeof metadata !== 'object') return false
+            if (!('createdBy' in metadata)) return false
+            
+            const createdBy = metadata.createdBy as any
+            if (!createdBy) return false
+            
+            return createdBy.augmentation === options.service
+        }
         if (!this.isInitialized) {
             throw new Error('BrainyData must be initialized before searching. Call init() first.')
         }
@@ -870,7 +978,8 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
                     })
                 }
 
-                return searchResults
+                // Filter results by service if specified
+                return this.filterResultsByService(searchResults, options.service)
             } else {
                 // Get nouns for each noun type in parallel
                 const nounPromises = nounTypes.map((nounType) =>
@@ -929,7 +1038,8 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
                     })
                 }
 
-                return searchResults
+                // Filter results by service if specified
+                return this.filterResultsByService(searchResults, options.service)
             }
         } catch (error) {
             console.error('Failed to search vectors by noun types:', error)
@@ -956,6 +1066,7 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
             verbTypes?: string[] // Optional array of verb types to search within or filter by
             searchConnectedNouns?: boolean // Whether to search for nouns connected by verbs
             verbDirection?: 'outgoing' | 'incoming' | 'both' // Direction of verbs to consider when searching connected nouns
+            service?: string // Filter results by the service that created the data
         } = {}
     ): Promise<SearchResult<T>[]> {
         if (!this.isInitialized) {
@@ -1018,6 +1129,7 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
             forceEmbed?: boolean // Force using the embedding function even if input is a vector
             nounTypes?: string[] // Optional array of noun types to search within
             includeVerbs?: boolean // Whether to include associated GraphVerbs in the results
+            service?: string // Filter results by the service that created the data
         } = {}
     ): Promise<SearchResult<T>[]> {
         if (!this.isInitialized) {
@@ -1038,13 +1150,15 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
                 k,
                 options.nounTypes,
                 {
-                    forceEmbed: options.forceEmbed
+                    forceEmbed: options.forceEmbed,
+                    service: options.service
                 }
             )
         } else {
             // Otherwise, search all GraphNouns
             searchResults = await this.searchByNounTypes(queryToUse, k, null, {
-                forceEmbed: options.forceEmbed
+                forceEmbed: options.forceEmbed,
+                service: options.service
             })
         }
 
@@ -1171,8 +1285,16 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
 
     /**
      * Delete a vector by ID
+     * @param id The ID of the vector to delete
+     * @param options Additional options
+     * @returns Promise that resolves to true if the vector was deleted, false otherwise
      */
-    public async delete(id: string): Promise<boolean> {
+    public async delete(
+        id: string,
+        options: {
+            service?: string // The service that is deleting the data
+        } = {}
+    ): Promise<boolean> {
         await this.ensureInitialized()
 
         // Check if database is in read-only mode
@@ -1188,9 +1310,14 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
             // Remove from storage
             await this.storage!.deleteNoun(id)
 
+            // Track deletion statistics
+            const service = options.service || 'default'
+            await this.storage!.decrementStatistic('noun', service)
+
             // Try to remove metadata (ignore errors)
             try {
                 await this.storage!.saveMetadata(id, null)
+                await this.storage!.decrementStatistic('metadata', service)
             } catch (error) {
                 // Ignore
             }
@@ -1204,8 +1331,18 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
 
     /**
      * Update metadata for a vector
+     * @param id The ID of the vector to update metadata for
+     * @param metadata The new metadata
+     * @param options Additional options
+     * @returns Promise that resolves to true if the metadata was updated, false otherwise
      */
-    public async updateMetadata(id: string, metadata: T): Promise<boolean> {
+    public async updateMetadata(
+        id: string, 
+        metadata: T,
+        options: {
+            service?: string // The service that is updating the data
+        } = {}
+    ): Promise<boolean> {
         await this.ensureInitialized()
 
         // Check if database is in read-only mode
@@ -1232,11 +1369,56 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
                     // Set a default noun type
                     ;(metadata as unknown as GraphNoun).noun = NounType.Concept
                 }
+                
+                // Get the service that's updating the metadata
+                const service = options.service || this.getCurrentAugmentation()
+                const graphNoun = metadata as unknown as GraphNoun
+                
+                // Preserve existing createdBy and createdAt if they exist
+                const existingMetadata = await this.storage!.getMetadata(id) as any
+                
+                if (existingMetadata && 
+                    typeof existingMetadata === 'object' && 
+                    'createdBy' in existingMetadata) {
+                    // Preserve the original creator information
+                    graphNoun.createdBy = existingMetadata.createdBy
+                    
+                    // Also preserve creation timestamp if it exists
+                    if ('createdAt' in existingMetadata) {
+                        graphNoun.createdAt = existingMetadata.createdAt
+                    }
+                } else if (!graphNoun.createdBy) {
+                    // If no existing createdBy and none in the update, set it
+                    graphNoun.createdBy = {
+                        augmentation: service,
+                        version: '1.0' // TODO: Get actual version from augmentation
+                    }
+                    
+                    // Set createdAt if it doesn't exist
+                    if (!graphNoun.createdAt) {
+                        const now = new Date()
+                        graphNoun.createdAt = {
+                            seconds: Math.floor(now.getTime() / 1000),
+                            nanoseconds: (now.getTime() % 1000) * 1000000
+                        }
+                    }
+                }
+                
+                // Always update the updatedAt timestamp
+                const now = new Date()
+                graphNoun.updatedAt = {
+                    seconds: Math.floor(now.getTime() / 1000),
+                    nanoseconds: (now.getTime() % 1000) * 1000000
+                }
             }
 
             // Update metadata
             await this.storage!.saveMetadata(id, metadata)
             
+            // Track metadata statistics
+            const service = options.service || this.getCurrentAugmentation()
+            await this.storage!.incrementStatistic('metadata', service)
+
             return true
         } catch (error) {
             console.error(`Failed to update metadata for vector ${id}:`, error)
@@ -1305,6 +1487,7 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
             id?: string // Optional ID to use instead of generating a new one
             autoCreateMissingNouns?: boolean // Automatically create missing nouns
             missingNounMetadata?: any // Metadata to use when auto-creating missing nouns
+            service?: string // The service that is inserting the data
         } = {}
     ): Promise<string> {
         await this.ensureInitialized()
@@ -1324,10 +1507,22 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
                     const placeholderVector = new Array(this._dimensions).fill(0)
 
                     // Add metadata if provided
+                    const service = options.service || this.getCurrentAugmentation()
+                    const now = new Date()
+                    const timestamp = {
+                        seconds: Math.floor(now.getTime() / 1000),
+                        nanoseconds: (now.getTime() % 1000) * 1000000
+                    }
+                    
                     const metadata = options.missingNounMetadata || {
                         autoCreated: true,
-                        createdAt: new Date().toISOString(),
+                        createdAt: timestamp,
-                        noun: NounType.Concept
+                        updatedAt: timestamp,
+                        noun: NounType.Concept,
+                        createdBy: {
+                            augmentation: service,
+                            version: '1.0' // TODO: Get actual version from augmentation
+                        }
                     }
 
                     // Add the missing noun
@@ -1349,10 +1544,22 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
                     const placeholderVector = new Array(this._dimensions).fill(0)
 
                     // Add metadata if provided
+                    const service = options.service || this.getCurrentAugmentation()
+                    const now = new Date()
+                    const timestamp = {
+                        seconds: Math.floor(now.getTime() / 1000),
+                        nanoseconds: (now.getTime() % 1000) * 1000000
+                    }
+                    
                     const metadata = options.missingNounMetadata || {
                         autoCreated: true,
-                        createdAt: new Date().toISOString(),
+                        createdAt: timestamp,
-                        noun: NounType.Concept
+                        updatedAt: timestamp,
+                        noun: NounType.Concept,
+                        createdBy: {
+                            augmentation: service,
+                            version: '1.0' // TODO: Get actual version from augmentation
+                        }
                     }
 
                     // Add the missing noun
@@ -1479,6 +1686,13 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
             // Save verb to storage
             await this.storage!.saveVerb(verb)
 
+            // Track verb statistics
+            const service = options.service || 'default'
+            await this.storage!.incrementStatistic('verb', service)
+
+            // Update HNSW index size (excluding verbs)
+            await this.storage!.updateHnswIndexSize(await this.getNounCount())
+
             return id
         } catch (error) {
             console.error('Failed to add verb:', error)
@@ -1558,8 +1772,16 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
 
     /**
      * Delete a verb
+     * @param id The ID of the verb to delete
+     * @param options Additional options
+     * @returns Promise that resolves to true if the verb was deleted, false otherwise
      */
-    public async deleteVerb(id: string): Promise<boolean> {
+    public async deleteVerb(
+        id: string,
+        options: {
+            service?: string // The service that is deleting the data
+        } = {}
+    ): Promise<boolean> {
         await this.ensureInitialized()
 
         // Check if database is in read-only mode
@@ -1575,6 +1797,10 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
             // Remove from storage
             await this.storage!.deleteVerb(id)
 
+            // Track deletion statistics
+            const service = options.service || 'default'
+            await this.storage!.decrementStatistic('verb', service)
+
             return true
         } catch (error) {
             console.error(`Failed to delete verb ${id}:`, error)
@@ -1610,39 +1836,115 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
         return this.index.size()
     }
     
+    /**
+     * Get the number of nouns in the database (excluding verbs)
+     * This is used for statistics reporting to match the expected behavior in tests
+     * @private
+     */
+    private async getNounCount(): Promise<number> {
+        // Get all verbs from storage
+        const allVerbs = await this.storage!.getAllVerbs()
+        
+        // Create a set of verb IDs for faster lookup
+        const verbIds = new Set(allVerbs.map(verb => verb.id))
+        
+        // Get all nouns from the index
+        const nouns = this.index.getNouns()
+        
+        // Count nouns that are not verbs
+        let nounCount = 0
+        for (const [id] of nouns.entries()) {
+            if (!verbIds.has(id)) {
+                nounCount++
+            }
+        }
+        
+        return nounCount
+    }
+
     /**
      * Get statistics about the current state of the database
+     * @param options Additional options for retrieving statistics
      * @returns Object containing counts of nouns, verbs, metadata entries, and HNSW index size
      */
-    public async getStatistics(): Promise<{
+    public async getStatistics(options: {
+        service?: string | string[] // Filter statistics by service(s)
+    } = {}): Promise<{
         nounCount: number
         verbCount: number
         metadataCount: number
         hnswIndexSize: number
+        serviceBreakdown?: {
+            [service: string]: {
+                nounCount: number
+                verbCount: number
+                metadataCount: number
+            }
+        }
     }> {
         await this.ensureInitialized()
 
         try {
+            // Get statistics from storage
+            const stats = await this.storage!.getStatistics()
+
+            // If statistics are available, use them
+            if (stats) {
+                // Initialize result
+                const result = {
+                    nounCount: 0,
+                    verbCount: 0,
+                    metadataCount: 0,
+                    hnswIndexSize: stats.hnswIndexSize,
+                    serviceBreakdown: {} as {
+                        [service: string]: {
+                            nounCount: number
+                            verbCount: number
+                            metadataCount: number
+                        }
+                    }
+                }
+
+                // Filter by service if specified
+                const services = options.service 
+                    ? (Array.isArray(options.service) ? options.service : [options.service])
+                    : Object.keys({...stats.nounCount, ...stats.verbCount, ...stats.metadataCount})
+
+                // Calculate totals and service breakdown
+                for (const service of services) {
+                    const nounCount = stats.nounCount[service] || 0
+                    const verbCount = stats.verbCount[service] || 0
+                    const metadataCount = stats.metadataCount[service] || 0
+
+                    // Add to totals
+                    result.nounCount += nounCount
+                    result.verbCount += verbCount
+                    result.metadataCount += metadataCount
+
+                    // Add to service breakdown
+                    result.serviceBreakdown[service] = {
+                        nounCount,
+                        verbCount,
+                        metadataCount
+                    }
+                }
+
+                return result
+            }
+
+            // If statistics are not available, fall back to calculating them on-demand
+            console.warn('Persistent statistics not available, calculating on-demand')
+            
             // Get all verbs from storage
             const allVerbs = await this.storage!.getAllVerbs()
             const verbCount = allVerbs.length
             
-            // Create a set of verb IDs for faster lookup
+            // Get the noun count using the helper method
-            const verbIds = new Set(allVerbs.map(verb => verb.id))
+            const nounCount = await this.getNounCount()
-            
-            // Get all nouns from the index
-            const nouns = this.index.getNouns()
-            
-            // Count nouns that are not verbs
-            let nounCount = 0
-            for (const [id] of nouns.entries()) {
-                if (!verbIds.has(id)) {
-                    nounCount++
-                }
-            }
 
             // Count metadata entries by checking each noun for metadata
             let metadataCount = 0
+            const nouns = this.index.getNouns()
             for (const [id] of nouns.entries()) {
                 try {
                     const metadata = await this.storage!.getMetadata(id)
@@ -1656,15 +1958,29 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
             }
 
             // Get HNSW index size (excluding verbs)
-            // The test expects this to be the same as the noun count
+            // The HNSW index includes both nouns and verbs, but for statistics we want to report
+            // only the number of actual nouns (excluding verbs) to match the expected behavior in tests
             const hnswIndexSize = nounCount
 
-            return {
+            // Create default statistics
+            const defaultStats = {
                 nounCount,
                 verbCount,
                 metadataCount,
                 hnswIndexSize
             }
+
+            // Initialize persistent statistics
+            const service = 'default'
+            await this.storage!.saveStatistics({
+                nounCount: { [service]: nounCount },
+                verbCount: { [service]: verbCount },
+                metadataCount: { [service]: metadataCount },
+                hnswIndexSize,
+                lastUpdated: new Date().toISOString()
+            })
+
+            return defaultStats
         } catch (error) {
             console.error('Failed to get statistics:', error)
             throw new Error(`Failed to get statistics: ${error}`)
@@ -1718,6 +2034,7 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
         options: {
             forceEmbed?: boolean // Force using the embedding function even if input is a vector
             verbTypes?: string[] // Optional array of verb types to search within
+            service?: string // Filter results by the service that created the data
         } = {}
     ): Promise<Array<GraphVerb & { similarity: number }>> {
         await this.ensureInitialized()
@@ -1742,51 +2059,85 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
                 }
             }
 
-            // Get verbs to search through
+            // First use the HNSW index to find similar vectors efficiently
-            let verbs: GraphVerb[] = []
+            const searchResults = await this.index.search(queryVector, k * 2)
             
-            // If verb types are specified, get verbs of those types
+            // Get all verbs for filtering
-            if (options.verbTypes && options.verbTypes.length > 0) {
+            const allVerbs = await this.storage!.getAllVerbs()
-                // Get verbs for each verb type in parallel
-                const verbPromises = options.verbTypes.map((verbType) =>
-                    this.getVerbsByType(verbType)
-                )
-                const verbArrays = await Promise.all(verbPromises)
             
-                // Combine all verbs
+            // Create a map of verb IDs for faster lookup
-                for (const verbArray of verbArrays) {
+            const verbMap = new Map<string, GraphVerb>()
-                    verbs.push(...verbArray)
+            for (const verb of allVerbs) {
-                }
+                verbMap.set(verb.id, verb)
-            } else {
-                // Get all verbs
-                verbs = await this.storage!.getAllVerbs()
             }
             
-            // Filter out verbs without embeddings
+            // Filter search results to only include verbs
-            verbs = verbs.filter(
+            const verbResults: Array<GraphVerb & { similarity: number }> = []
-                (verb) => verb.embedding && verb.embedding.length > 0
-            )
             
-            // Calculate similarity for each verb
+            for (const result of searchResults) {
-            const results: Array<GraphVerb & { similarity: number }> = []
+                // Search results are [id, distance] tuples
-            for (const verb of verbs) {
+                const [id, distance] = result
-                if (verb.embedding) {
+                const verb = verbMap.get(id)
-                    const distance = this.index.getDistanceFunction()(
+                if (verb) {
-                        queryVector,
+                    // If verb types are specified, check if this verb matches
-                        verb.embedding
+                    if (options.verbTypes && options.verbTypes.length > 0) {
-                    )
+                        if (!verb.type || !options.verbTypes.includes(verb.type)) {
-                    results.push({
+                            continue
+                        }
+                    }
+                    
+                    verbResults.push({
                         ...verb,
                         similarity: distance
                     })
                 }
             }
             
+            // If we didn't get enough results from the index, fall back to the old method
+            if (verbResults.length < k) {
+                console.warn('Not enough verb results from HNSW index, falling back to manual search')
+                
+                // Get verbs to search through
+                let verbs: GraphVerb[] = []
+                
+                // If verb types are specified, get verbs of those types
+                if (options.verbTypes && options.verbTypes.length > 0) {
+                    // Get verbs for each verb type in parallel
+                    const verbPromises = options.verbTypes.map((verbType) =>
+                        this.getVerbsByType(verbType)
+                    )
+                    const verbArrays = await Promise.all(verbPromises)
+                    
+                    // Combine all verbs
+                    for (const verbArray of verbArrays) {
+                        verbs.push(...verbArray)
+                    }
+                } else {
+                    // Use all verbs
+                    verbs = allVerbs
+                }
+                
+                // Calculate similarity for each verb not already in results
+                const existingIds = new Set(verbResults.map(v => v.id))
+                for (const verb of verbs) {
+                    if (!existingIds.has(verb.id) && verb.vector && verb.vector.length > 0) {
+                        const distance = this.index.getDistanceFunction()(
+                            queryVector,
+                            verb.vector
+                        )
+                        verbResults.push({
+                            ...verb,
+                            similarity: distance
+                        })
+                    }
+                }
+            }
+            
             // Sort by similarity (ascending distance)
-            results.sort((a, b) => a.similarity - b.similarity)
+            verbResults.sort((a, b) => a.similarity - b.similarity)
             
             // Take top k results
-            return results.slice(0, k)
+            return verbResults.slice(0, k)
         } catch (error) {
             console.error('Failed to search verbs:', error)
             throw new Error(`Failed to search verbs: ${error}`)
@@ -1962,6 +2313,7 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
             nounTypes?: string[] // Optional array of noun types to search within
             includeVerbs?: boolean // Whether to include associated GraphVerbs in the results
             storeResults?: boolean // Whether to store the results in the local database (default: true)
+            service?: string // Filter results by the service that created the data
         } = {}
     ): Promise<SearchResult<T>[]> {
         await this.ensureInitialized()
@@ -2023,6 +2375,7 @@ export class BrainyData<T = any> implements BrainyDataInterface<T> {
             nounTypes?: string[] // Optional array of noun types to search within
             includeVerbs?: boolean // Whether to include associated GraphVerbs in the results
             localFirst?: boolean // Whether to search local first (default: true)
+            service?: string // Filter results by the service that created the data
         } = {}
     ): Promise<SearchResult<T>[]> {
         await this.ensureInitialized()

src/coreTypes.ts

@@ -97,6 +97,36 @@ export interface HNSWConfig {
 /**
  * Storage interface for persistence
  */
+/**
+ * Statistics data structure for tracking counts by service
+ */
+export interface StatisticsData {
+  /**
+   * Count of nouns by service
+   */
+  nounCount: Record<string, number>
+  
+  /**
+   * Count of verbs by service
+   */
+  verbCount: Record<string, number>
+  
+  /**
+   * Count of metadata entries by service
+   */
+  metadataCount: Record<string, number>
+  
+  /**
+   * Size of the HNSW index
+   */
+  hnswIndexSize: number
+  
+  /**
+   * Last updated timestamp
+   */
+  lastUpdated: string
+}
+
 export interface StorageAdapter {
   init(): Promise<void>
 
@@ -160,4 +190,38 @@ export interface StorageAdapter {
      */
     details?: Record<string, any>
   }>
+
+  /**
+   * Save statistics data
+   * @param statistics The statistics data to save
+   */
+  saveStatistics(statistics: StatisticsData): Promise<void>
+
+  /**
+   * Get statistics data
+   * @returns Promise that resolves to the statistics data
+   */
+  getStatistics(): Promise<StatisticsData | null>
+
+  /**
+   * Increment a statistic counter
+   * @param type The type of statistic to increment ('noun', 'verb', 'metadata')
+   * @param service The service that inserted the data
+   * @param amount The amount to increment by (default: 1)
+   */
+  incrementStatistic(type: 'noun' | 'verb' | 'metadata', service: string, amount?: number): Promise<void>
+
+  /**
+   * Decrement a statistic counter
+   * @param type The type of statistic to decrement ('noun', 'verb', 'metadata')
+   * @param service The service that inserted the data
+   * @param amount The amount to decrement by (default: 1)
+   */
+  decrementStatistic(type: 'noun' | 'verb' | 'metadata', service: string, amount?: number): Promise<void>
+
+  /**
+   * Update the HNSW index size statistic
+   * @param size The new size of the HNSW index
+   */
+  updateHnswIndexSize(size: number): Promise<void>
 }