@soulcraft/brainy 1.5.0 → 2.0.0

package/dist/examples/basicUsage.js

@@ -36,13 +36,13 @@ async function runExample() {
     // Add vectors to the database
     const ids = {};
     for (const [word, vector] of Object.entries(wordEmbeddings)) {
-        ids[word] = await db.add(vector, metadata[word]);
+        ids[word] = await db.addNoun(vector, metadata[word]);
         console.log(`Added "${word}" with ID: ${ids[word]}`);
     }
     console.log('\nDatabase size:', db.size());
     // Search for similar vectors
     console.log('\nSearching for vectors similar to "cat"...');
-    const catResults = await db.search(wordEmbeddings['cat'], 3);
+    const catResults = await db.search(wordEmbeddings['cat'], { limit: 3 });
     console.log('Results:');
     for (const result of catResults) {
         const word = Object.entries(ids).find(([_, id]) => id === result.id)?.[0] || 'unknown';
@@ -50,7 +50,7 @@ async function runExample() {
     }
     // Search for similar vectors
     console.log('\nSearching for vectors similar to "fish"...');
-    const fishResults = await db.search(wordEmbeddings['fish'], 3);
+    const fishResults = await db.search(wordEmbeddings['fish'], { limit: 3 });
     console.log('Results:');
     for (const result of fishResults) {
         const word = Object.entries(ids).find(([_, id]) => id === result.id)?.[0] || 'unknown';
@@ -58,20 +58,20 @@ async function runExample() {
     }
     // Update metadata
     console.log('\nUpdating metadata for "bird"...');
-    await db.updateMetadata(ids['bird'], {
+    await db.updateNounMetadata(ids['bird'], {
         ...metadata['bird'],
         notes: 'Can fly'
     });
     // Get the updated document
-    const birdDoc = await db.get(ids['bird']);
+    const birdDoc = await db.getNoun(ids['bird']);
     console.log('Updated bird document:', birdDoc);
     // Delete a vector
     console.log('\nDeleting "shark"...');
-    await db.delete(ids['shark']);
+    await db.deleteNoun(ids['shark']);
     console.log('Database size after deletion:', db.size());
     // Search again to verify shark is gone
     console.log('\nSearching for vectors similar to "fish" after deletion...');
-    const fishResultsAfterDeletion = await db.search(wordEmbeddings['fish'], 3);
+    const fishResultsAfterDeletion = await db.search(wordEmbeddings['fish'], { limit: 3 });
     console.log('Results:');
     for (const result of fishResultsAfterDeletion) {
         const word = Object.entries(ids).find(([_, id]) => id === result.id)?.[0] || 'unknown';

package/dist/graph/pathfinding.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Advanced Graph Pathfinding Algorithms
+ * Provides shortest path, multi-hop traversal, and path ranking
+ */
+export interface GraphNode {
+    id: string;
+    [key: string]: any;
+}
+export interface GraphEdge {
+    source: string;
+    target: string;
+    type: string;
+    weight: number;
+    metadata?: any;
+}
+export interface Path {
+    nodes: string[];
+    edges: GraphEdge[];
+    totalWeight: number;
+    length: number;
+}
+export interface PathfindingOptions {
+    maxDepth?: number;
+    maxPaths?: number;
+    bidirectional?: boolean;
+    weightField?: string;
+    relationshipTypes?: string[];
+    nodeFilter?: (node: GraphNode) => boolean;
+    edgeFilter?: (edge: GraphEdge) => boolean;
+}
+export declare class GraphPathfinding {
+    private adjacencyList;
+    private nodes;
+    /**
+     * Add a node to the graph
+     */
+    addNode(node: GraphNode): void;
+    /**
+     * Add an edge to the graph
+     */
+    addEdge(edge: GraphEdge): void;
+    /**
+     * Find shortest path using Dijkstra's algorithm
+     * O((V + E) log V) with binary heap
+     */
+    shortestPath(start: string, end: string, options?: PathfindingOptions): Path | null;
+    /**
+     * Find all paths between two nodes
+     * Uses DFS with cycle detection
+     */
+    allPaths(start: string, end: string, options?: PathfindingOptions): Path[];
+    /**
+     * Bidirectional search for faster pathfinding
+     * Searches from both start and end simultaneously
+     */
+    bidirectionalSearch(start: string, end: string, options?: PathfindingOptions): Path | null;
+    /**
+     * Multi-hop traversal (e.g., friends of friends)
+     * Returns all nodes within N hops
+     */
+    multiHopTraversal(start: string, hops: number, options?: PathfindingOptions): Map<string, {
+        distance: number;
+        paths: Path[];
+    }>;
+    /**
+     * Find connected components using DFS
+     */
+    connectedComponents(): Array<Set<string>>;
+    /**
+     * Calculate PageRank for all nodes
+     * Useful for ranking importance in the graph
+     */
+    pageRank(iterations?: number, damping?: number): Map<string, number>;
+    /**
+     * Clear the graph
+     */
+    clear(): void;
+}

package/dist/graph/pathfinding.js

@@ -0,0 +1,393 @@
+/**
+ * Advanced Graph Pathfinding Algorithms
+ * Provides shortest path, multi-hop traversal, and path ranking
+ */
+export class GraphPathfinding {
+    constructor() {
+        this.adjacencyList = new Map();
+        this.nodes = new Map();
+    }
+    /**
+     * Add a node to the graph
+     */
+    addNode(node) {
+        this.nodes.set(node.id, node);
+        if (!this.adjacencyList.has(node.id)) {
+            this.adjacencyList.set(node.id, new Map());
+        }
+    }
+    /**
+     * Add an edge to the graph
+     */
+    addEdge(edge) {
+        // Ensure nodes exist
+        if (!this.adjacencyList.has(edge.source)) {
+            this.adjacencyList.set(edge.source, new Map());
+        }
+        if (!this.adjacencyList.has(edge.target)) {
+            this.adjacencyList.set(edge.target, new Map());
+        }
+        // Add edge to adjacency list
+        const sourceEdges = this.adjacencyList.get(edge.source);
+        if (!sourceEdges.has(edge.target)) {
+            sourceEdges.set(edge.target, []);
+        }
+        sourceEdges.get(edge.target).push(edge);
+    }
+    /**
+     * Find shortest path using Dijkstra's algorithm
+     * O((V + E) log V) with binary heap
+     */
+    shortestPath(start, end, options = {}) {
+        const { maxDepth = Infinity, relationshipTypes, edgeFilter } = options;
+        // Priority queue: [nodeId, distance, path]
+        const pq = [[start, 0, [start], []]];
+        const visited = new Set();
+        const distances = new Map([[start, 0]]);
+        while (pq.length > 0) {
+            // Sort by distance (simple array, could optimize with heap)
+            pq.sort((a, b) => a[1] - b[1]);
+            const [current, distance, path, edges] = pq.shift();
+            if (visited.has(current))
+                continue;
+            visited.add(current);
+            // Found target
+            if (current === end) {
+                return {
+                    nodes: path,
+                    edges,
+                    totalWeight: distance,
+                    length: path.length - 1
+                };
+            }
+            // Max depth reached
+            if (path.length > maxDepth)
+                continue;
+            // Explore neighbors
+            const neighbors = this.adjacencyList.get(current);
+            if (!neighbors)
+                continue;
+            for (const [neighbor, edgeList] of neighbors) {
+                if (visited.has(neighbor))
+                    continue;
+                // Find best edge to neighbor
+                let bestEdge = null;
+                let bestWeight = Infinity;
+                for (const edge of edgeList) {
+                    // Apply filters
+                    if (relationshipTypes && !relationshipTypes.includes(edge.type))
+                        continue;
+                    if (edgeFilter && !edgeFilter(edge))
+                        continue;
+                    if (edge.weight < bestWeight) {
+                        bestWeight = edge.weight;
+                        bestEdge = edge;
+                    }
+                }
+                if (!bestEdge)
+                    continue;
+                const newDistance = distance + bestWeight;
+                const currentBest = distances.get(neighbor) ?? Infinity;
+                if (newDistance < currentBest) {
+                    distances.set(neighbor, newDistance);
+                    pq.push([
+                        neighbor,
+                        newDistance,
+                        [...path, neighbor],
+                        [...edges, bestEdge]
+                    ]);
+                }
+            }
+        }
+        return null; // No path found
+    }
+    /**
+     * Find all paths between two nodes
+     * Uses DFS with cycle detection
+     */
+    allPaths(start, end, options = {}) {
+        const { maxDepth = 10, maxPaths = 100, relationshipTypes, edgeFilter } = options;
+        const paths = [];
+        const visited = new Set();
+        const dfs = (current, path, edges, weight) => {
+            if (paths.length >= maxPaths)
+                return;
+            if (path.length > maxDepth)
+                return;
+            if (current === end && path.length > 1) {
+                paths.push({
+                    nodes: [...path],
+                    edges: [...edges],
+                    totalWeight: weight,
+                    length: path.length - 1
+                });
+                return;
+            }
+            visited.add(current);
+            const neighbors = this.adjacencyList.get(current);
+            if (neighbors) {
+                for (const [neighbor, edgeList] of neighbors) {
+                    if (visited.has(neighbor))
+                        continue;
+                    for (const edge of edgeList) {
+                        // Apply filters
+                        if (relationshipTypes && !relationshipTypes.includes(edge.type))
+                            continue;
+                        if (edgeFilter && !edgeFilter(edge))
+                            continue;
+                        dfs(neighbor, [...path, neighbor], [...edges, edge], weight + edge.weight);
+                    }
+                }
+            }
+            visited.delete(current);
+        };
+        dfs(start, [start], [], 0);
+        // Sort paths by weight
+        paths.sort((a, b) => a.totalWeight - b.totalWeight);
+        return paths;
+    }
+    /**
+     * Bidirectional search for faster pathfinding
+     * Searches from both start and end simultaneously
+     */
+    bidirectionalSearch(start, end, options = {}) {
+        const { maxDepth = 10 } = options;
+        // Two search frontiers
+        const forwardVisited = new Map();
+        const backwardVisited = new Map();
+        forwardVisited.set(start, { path: [start], edges: [], weight: 0 });
+        backwardVisited.set(end, { path: [end], edges: [], weight: 0 });
+        const forwardQueue = [start];
+        const backwardQueue = [end];
+        let depth = 0;
+        while ((forwardQueue.length > 0 || backwardQueue.length > 0) &&
+            depth < maxDepth) {
+            // Expand forward frontier
+            const forwardNext = [];
+            for (const current of forwardQueue) {
+                const currentData = forwardVisited.get(current);
+                const neighbors = this.adjacencyList.get(current);
+                if (neighbors) {
+                    for (const [neighbor, edges] of neighbors) {
+                        if (forwardVisited.has(neighbor))
+                            continue;
+                        const bestEdge = edges[0]; // TODO: Select best edge
+                        forwardVisited.set(neighbor, {
+                            path: [...currentData.path, neighbor],
+                            edges: [...currentData.edges, bestEdge],
+                            weight: currentData.weight + bestEdge.weight
+                        });
+                        // Check if we met the backward search
+                        if (backwardVisited.has(neighbor)) {
+                            const forward = forwardVisited.get(neighbor);
+                            const backward = backwardVisited.get(neighbor);
+                            // Combine paths
+                            const fullPath = [
+                                ...forward.path,
+                                ...backward.path.slice(1).reverse()
+                            ];
+                            // Reverse backward edges and combine
+                            const backwardEdgesReversed = backward.edges
+                                .map(e => ({
+                                ...e,
+                                source: e.target,
+                                target: e.source
+                            }))
+                                .reverse();
+                            return {
+                                nodes: fullPath,
+                                edges: [...forward.edges, ...backwardEdgesReversed],
+                                totalWeight: forward.weight + backward.weight,
+                                length: fullPath.length - 1
+                            };
+                        }
+                        forwardNext.push(neighbor);
+                    }
+                }
+            }
+            // Expand backward frontier
+            const backwardNext = [];
+            for (const current of backwardQueue) {
+                const currentData = backwardVisited.get(current);
+                // For backward search, we need to look at incoming edges
+                for (const [nodeId, neighbors] of this.adjacencyList) {
+                    const edges = neighbors.get(current);
+                    if (!edges)
+                        continue;
+                    if (backwardVisited.has(nodeId))
+                        continue;
+                    const bestEdge = edges[0]; // TODO: Select best edge
+                    backwardVisited.set(nodeId, {
+                        path: [...currentData.path, nodeId],
+                        edges: [...currentData.edges, bestEdge],
+                        weight: currentData.weight + bestEdge.weight
+                    });
+                    // Check if we met the forward search
+                    if (forwardVisited.has(nodeId)) {
+                        const forward = forwardVisited.get(nodeId);
+                        const backward = backwardVisited.get(nodeId);
+                        // Combine paths
+                        const fullPath = [
+                            ...forward.path,
+                            ...backward.path.slice(1).reverse()
+                        ];
+                        // Reverse backward edges and combine
+                        const backwardEdgesReversed = backward.edges
+                            .map(e => ({
+                            ...e,
+                            source: e.target,
+                            target: e.source
+                        }))
+                            .reverse();
+                        return {
+                            nodes: fullPath,
+                            edges: [...forward.edges, ...backwardEdgesReversed],
+                            totalWeight: forward.weight + backward.weight,
+                            length: fullPath.length - 1
+                        };
+                    }
+                    backwardNext.push(nodeId);
+                }
+            }
+            forwardQueue.splice(0, forwardQueue.length, ...forwardNext);
+            backwardQueue.splice(0, backwardQueue.length, ...backwardNext);
+            depth++;
+        }
+        return null;
+    }
+    /**
+     * Multi-hop traversal (e.g., friends of friends)
+     * Returns all nodes within N hops
+     */
+    multiHopTraversal(start, hops, options = {}) {
+        const { relationshipTypes, nodeFilter, edgeFilter } = options;
+        const results = new Map();
+        const visited = new Set();
+        const queue = [
+            { node: start, distance: 0, path: [start], edges: [] }
+        ];
+        while (queue.length > 0) {
+            const { node, distance, path, edges } = queue.shift();
+            if (distance > hops)
+                continue;
+            // Record this node
+            if (!results.has(node)) {
+                results.set(node, { distance, paths: [] });
+            }
+            results.get(node).paths.push({
+                nodes: path,
+                edges,
+                totalWeight: edges.reduce((sum, e) => sum + e.weight, 0),
+                length: path.length - 1
+            });
+            if (distance === hops)
+                continue;
+            // Explore neighbors
+            const neighbors = this.adjacencyList.get(node);
+            if (neighbors) {
+                for (const [neighbor, edgeList] of neighbors) {
+                    // Apply node filter
+                    if (nodeFilter) {
+                        const neighborNode = this.nodes.get(neighbor);
+                        if (neighborNode && !nodeFilter(neighborNode))
+                            continue;
+                    }
+                    for (const edge of edgeList) {
+                        // Apply filters
+                        if (relationshipTypes && !relationshipTypes.includes(edge.type))
+                            continue;
+                        if (edgeFilter && !edgeFilter(edge))
+                            continue;
+                        queue.push({
+                            node: neighbor,
+                            distance: distance + 1,
+                            path: [...path, neighbor],
+                            edges: [...edges, edge]
+                        });
+                    }
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * Find connected components using DFS
+     */
+    connectedComponents() {
+        const visited = new Set();
+        const components = [];
+        const dfs = (node, component) => {
+            visited.add(node);
+            component.add(node);
+            const neighbors = this.adjacencyList.get(node);
+            if (neighbors) {
+                for (const neighbor of neighbors.keys()) {
+                    if (!visited.has(neighbor)) {
+                        dfs(neighbor, component);
+                    }
+                }
+            }
+        };
+        for (const node of this.adjacencyList.keys()) {
+            if (!visited.has(node)) {
+                const component = new Set();
+                dfs(node, component);
+                components.push(component);
+            }
+        }
+        return components;
+    }
+    /**
+     * Calculate PageRank for all nodes
+     * Useful for ranking importance in the graph
+     */
+    pageRank(iterations = 100, damping = 0.85) {
+        const nodes = Array.from(this.adjacencyList.keys());
+        const n = nodes.length;
+        if (n === 0)
+            return new Map();
+        // Initialize ranks
+        const ranks = new Map();
+        for (const node of nodes) {
+            ranks.set(node, 1 / n);
+        }
+        // Calculate outgoing edge counts
+        const outDegree = new Map();
+        for (const [node, neighbors] of this.adjacencyList) {
+            let count = 0;
+            for (const edges of neighbors.values()) {
+                count += edges.length;
+            }
+            outDegree.set(node, count);
+        }
+        // Iterate PageRank algorithm
+        for (let i = 0; i < iterations; i++) {
+            const newRanks = new Map();
+            for (const node of nodes) {
+                let rank = (1 - damping) / n;
+                // Sum contributions from incoming edges
+                for (const [source, neighbors] of this.adjacencyList) {
+                    if (neighbors.has(node)) {
+                        const sourceRank = ranks.get(source) ?? 0;
+                        const sourceOutDegree = outDegree.get(source) ?? 1;
+                        rank += damping * (sourceRank / sourceOutDegree);
+                    }
+                }
+                newRanks.set(node, rank);
+            }
+            // Update ranks
+            for (const [node, rank] of newRanks) {
+                ranks.set(node, rank);
+            }
+        }
+        return ranks;
+    }
+    /**
+     * Clear the graph
+     */
+    clear() {
+        this.adjacencyList.clear();
+        this.nodes.clear();
+    }
+}
+//# sourceMappingURL=pathfinding.js.map

package/dist/hnsw/hnswIndex.d.ts

@@ -91,6 +91,19 @@ export declare class HNSWIndex {
      * Get the configuration
      */
     getConfig(): HNSWConfig;
+    /**
+     * Get all nodes at a specific level for clustering
+     * This enables O(n) clustering using HNSW's natural hierarchy
+     */
+    getNodesAtLevel(level: number): HNSWNoun[];
+    /**
+     * Get level statistics for understanding the hierarchy
+     */
+    getLevelStats(): Array<{
+        level: number;
+        nodeCount: number;
+        avgConnections: number;
+    }>;
     /**
      * Get index health metrics
      */

package/dist/hnsw/hnswIndex.js

@@ -427,6 +427,41 @@ export class HNSWIndex {
     getConfig() {
         return { ...this.config };
     }
+    /**
+     * Get all nodes at a specific level for clustering
+     * This enables O(n) clustering using HNSW's natural hierarchy
+     */
+    getNodesAtLevel(level) {
+        const nodesAtLevel = [];
+        for (const noun of this.nouns.values()) {
+            // A noun exists at level L if it has connections at that level or higher
+            if (noun.level >= level) {
+                nodesAtLevel.push(noun);
+            }
+        }
+        return nodesAtLevel;
+    }
+    /**
+     * Get level statistics for understanding the hierarchy
+     */
+    getLevelStats() {
+        const levelStats = new Map();
+        for (const noun of this.nouns.values()) {
+            for (let level = 0; level <= noun.level; level++) {
+                if (!levelStats.has(level)) {
+                    levelStats.set(level, { count: 0, totalConnections: 0 });
+                }
+                const stats = levelStats.get(level);
+                stats.count++;
+                stats.totalConnections += noun.connections.get(level)?.size || 0;
+            }
+        }
+        return Array.from(levelStats.entries()).map(([level, stats]) => ({
+            level,
+            nodeCount: stats.count,
+            avgConnections: stats.count > 0 ? stats.totalConnections / stats.count : 0
+        })).sort((a, b) => a.level - b.level);
+    }
     /**
      * Get index health metrics
      */

package/dist/hnsw/hnswIndexOptimized.d.ts

@@ -95,6 +95,7 @@ export declare class HNSWIndexOptimized extends HNSWIndex {
     private memoryUsage;
     private vectorCount;
     private memoryUpdateLock;
+    private unifiedCache;
     constructor(config: Partial<HNSWOptimizedConfig> | undefined, distanceFunction: DistanceFunction, storage?: StorageAdapter | null);
     /**
      * Thread-safe method to update memory usage

package/dist/hnsw/hnswIndexOptimized.js

@@ -4,6 +4,7 @@
  * Uses product quantization for dimensionality reduction and disk-based storage when needed
  */
 import { HNSWIndex } from './hnswIndex.js';
+import { getGlobalCache } from '../utils/unifiedCache.js';
 // Default configuration for the optimized HNSW index
 const DEFAULT_OPTIMIZED_CONFIG = {
     M: 16,
@@ -232,6 +233,8 @@ export class HNSWIndexOptimized extends HNSWIndex {
         }
         // Set disk-based index flag
         this.useDiskBasedIndex = this.optimizedConfig.useDiskBasedIndex || false;
+        // Get global unified cache for coordinated memory management
+        this.unifiedCache = getGlobalCache();
     }
     /**
      * Thread-safe method to update memory usage

package/dist/index.d.ts

@@ -30,30 +30,28 @@ import { OPFSStorage, MemoryStorage, R2Storage, S3CompatibleStorage, createStora
 export { OPFSStorage, MemoryStorage, R2Storage, S3CompatibleStorage, createStorage };
 export { FileSystemStorage } from './storage/adapters/fileSystemStorage.js';
 import { Pipeline, pipeline, augmentationPipeline, ExecutionMode, PipelineOptions, PipelineResult, createPipeline, createStreamingPipeline, StreamlinedExecutionMode, StreamlinedPipelineOptions, StreamlinedPipelineResult } from './pipeline.js';
-import { createSenseAugmentation, addWebSocketSupport, executeAugmentation, loadAugmentationModule, AugmentationOptions } from './augmentationFactory.js';
-export { Pipeline, pipeline, augmentationPipeline, ExecutionMode, createPipeline, createStreamingPipeline, StreamlinedExecutionMode, createSenseAugmentation, addWebSocketSupport, executeAugmentation, loadAugmentationModule };
-export type { PipelineOptions, PipelineResult, StreamlinedPipelineOptions, StreamlinedPipelineResult, AugmentationOptions };
+export { Pipeline, pipeline, augmentationPipeline, ExecutionMode, createPipeline, createStreamingPipeline, StreamlinedExecutionMode, };
+export type { PipelineOptions, PipelineResult, StreamlinedPipelineOptions, StreamlinedPipelineResult };
 import { availableAugmentations, registerAugmentation, initializeAugmentationPipeline, setAugmentationEnabled, getAugmentationsByType } from './augmentationRegistry.js';
 export { availableAugmentations, registerAugmentation, initializeAugmentationPipeline, setAugmentationEnabled, getAugmentationsByType };
 import { loadAugmentationsFromModules, createAugmentationRegistryPlugin, createAugmentationRegistryRollupPlugin } from './augmentationRegistryLoader.js';
 import type { AugmentationRegistryLoaderOptions, AugmentationLoadResult } from './augmentationRegistryLoader.js';
 export { loadAugmentationsFromModules, createAugmentationRegistryPlugin, createAugmentationRegistryRollupPlugin };
 export type { AugmentationRegistryLoaderOptions, AugmentationLoadResult };
-import { MemoryStorageAugmentation, FileSystemStorageAugmentation, OPFSStorageAugmentation, createMemoryAugmentation } from './augmentations/memoryAugmentations.js';
-import { WebSocketConduitAugmentation, WebRTCConduitAugmentation, createConduitAugmentation } from './augmentations/conduitAugmentations.js';
+import { StorageAugmentation, DynamicStorageAugmentation, createStorageAugmentationFromConfig } from './augmentations/storageAugmentation.js';
+import { MemoryStorageAugmentation, FileSystemStorageAugmentation, OPFSStorageAugmentation, S3StorageAugmentation, R2StorageAugmentation, GCSStorageAugmentation, createAutoStorageAugmentation } from './augmentations/storageAugmentations.js';
+import { WebSocketConduitAugmentation } from './augmentations/conduitAugmentations.js';
 import { ServerSearchConduitAugmentation, ServerSearchActivationAugmentation, createServerSearchAugmentations } from './augmentations/serverSearchAugmentations.js';
-export { MemoryStorageAugmentation, FileSystemStorageAugmentation, OPFSStorageAugmentation, createMemoryAugmentation, WebSocketConduitAugmentation, WebRTCConduitAugmentation, createConduitAugmentation, ServerSearchConduitAugmentation, ServerSearchActivationAugmentation, createServerSearchAugmentations };
+export { StorageAugmentation, DynamicStorageAugmentation, MemoryStorageAugmentation, FileSystemStorageAugmentation, OPFSStorageAugmentation, S3StorageAugmentation, R2StorageAugmentation, GCSStorageAugmentation, createAutoStorageAugmentation, createStorageAugmentationFromConfig };
+export { WebSocketConduitAugmentation, ServerSearchConduitAugmentation, ServerSearchActivationAugmentation, createServerSearchAugmentations };
 import type { Vector, VectorDocument, SearchResult, DistanceFunction, EmbeddingFunction, EmbeddingModel, HNSWNoun, HNSWVerb, HNSWConfig, StorageAdapter } from './coreTypes.js';
 import { HNSWIndex } from './hnsw/hnswIndex.js';
 import { HNSWIndexOptimized, HNSWOptimizedConfig } from './hnsw/hnswIndexOptimized.js';
 export { HNSWIndex, HNSWIndexOptimized };
 export type { Vector, VectorDocument, SearchResult, DistanceFunction, EmbeddingFunction, EmbeddingModel, HNSWNoun, HNSWVerb, HNSWConfig, HNSWOptimizedConfig, StorageAdapter };
-import type { IAugmentation, AugmentationResponse, IWebSocketSupport, ISenseAugmentation, IConduitAugmentation, ICognitionAugmentation, IMemoryAugmentation, IPerceptionAugmentation, IDialogAugmentation, IActivationAugmentation } from './types/augmentations.js';
-import { AugmentationType, BrainyAugmentations } from './types/augmentations.js';
+import type { AugmentationResponse, BrainyAugmentation, BaseAugmentation, AugmentationContext } from './types/augmentations.js';
 export { AugmentationManager, type AugmentationInfo } from './augmentationManager.js';
-export type { IAugmentation, AugmentationResponse, IWebSocketSupport };
-export { AugmentationType, BrainyAugmentations, ISenseAugmentation, IConduitAugmentation, ICognitionAugmentation, IMemoryAugmentation, IPerceptionAugmentation, IDialogAugmentation, IActivationAugmentation };
-export type { IWebSocketCognitionAugmentation, IWebSocketSenseAugmentation, IWebSocketPerceptionAugmentation, IWebSocketActivationAugmentation, IWebSocketDialogAugmentation, IWebSocketConduitAugmentation, IWebSocketMemoryAugmentation } from './types/augmentations.js';
+export type { AugmentationResponse, BrainyAugmentation, BaseAugmentation, AugmentationContext };
 import type { GraphNoun, GraphVerb, EmbeddedGraphVerb, Person, Location, Thing, Event, Concept, Content, Collection, Organization, Document, Media, File, Message, Dataset, Product, Service, User, Task, Project, Process, State, Role, Topic, Language, Currency, Measurement } from './types/graphTypes.js';
 import { NounType, VerbType } from './types/graphTypes.js';
 export type { GraphNoun, GraphVerb, EmbeddedGraphVerb, Person, Location, Thing, Event, Concept, Content, Collection, Organization, Document, Media, File, Message, Dataset, Product, Service, User, Task, Project, Process, State, Role, Topic, Language, Currency, Measurement };