@soulcraft/brainy 3.0.0 → 3.1.0

package/dist/brainyData.d.ts

@@ -8,10 +8,10 @@ import { DistanceFunction, GraphVerb, EmbeddingFunction, HNSWConfig, SearchResul
 import { MetadataIndexConfig } from './utils/metadataIndex.js';
 import { CleanupConfig } from './utils/periodicCleanup.js';
 import { NounType, VerbType } from './types/graphTypes.js';
-import { WebSocketConnection } from './types/augmentations.js';
 import { BrainyDataInterface } from './types/brainyDataInterface.js';
 import { DistributedConfig } from './types/distributedTypes.js';
 import { SearchCacheConfig } from './utils/searchCache.js';
+import { ImprovedNeuralAPI } from './neural/improvedNeuralAPI.js';
 import { TripleQuery, TripleResult } from './triple/TripleIntelligence.js';
 export interface BrainyDataConfig {
     /**
@@ -332,7 +332,7 @@ export interface BrainyDataConfig {
     intelligentVerbScoring?: {
         /**
          * Whether to enable intelligent verb scoring
-         * Default: false (off by default)
+         * Default: true (enabled by default for better relationship quality)
          */
         enabled?: boolean;
         /**
@@ -416,6 +416,7 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
     private allowDirectReads;
     private storageConfig;
     private config;
+    private rawConfig;
     private useOptimizedIndex;
     private _dimensions;
     private loggingConfig;
@@ -449,6 +450,15 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
     private partitioner;
     private operationalMode;
     private domainDetector;
+    private networkTransport;
+    private coordinator;
+    private shardManager;
+    private cacheSync;
+    private readWriteSeparation;
+    private httpTransport;
+    private storageDiscovery;
+    private queryPlanner;
+    private shardMigrationManager;
     private get cache();
     private get index();
     private get metadataIndex();
@@ -472,8 +482,10 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
     get initialized(): boolean;
     /**
      * Create a new vector database
+     * @param config - Zero-config string ('production', 'development', 'minimal'),
+     *                 simplified config object, or legacy full config
      */
-    constructor(config?: BrainyDataConfig);
+    constructor(config?: BrainyDataConfig | string | any);
     /**
      * Check if the database is in read-only mode and throw an error if it is
      * @throws Error if the database is in read-only mode
@@ -609,53 +621,31 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      */
     private handleDistributedConfigUpdate;
     /**
-     * Get distributed health status
-     * @returns Health status if distributed mode is enabled
+     * Initialize NEW distributed components for Brainy 3.0
+     * This enables true multi-node operation with consensus and sharding
      */
-    getHealthStatus(): any;
+    private initializeDistributedComponents;
     /**
-     * Connect to a remote Brainy server for search operations
-     * @param serverUrl WebSocket URL of the remote Brainy server
-     * @param protocols Optional WebSocket protocols to use
-     * @returns The connection object
+     * Execute a query on local shards
      */
-    connectToRemoteServer(serverUrl: string, protocols?: string | string[]): Promise<WebSocketConnection>;
+    private executeLocalQuery;
     /**
-     * Add data to the database with intelligent processing
-     *
-     * @param vectorOrData Vector or data to add
-     * @param metadata Optional metadata to associate with the data
-     * @param options Additional options for processing
-     * @returns The ID of the added data
-     *
-     * @example
-     * // Auto mode - intelligently decides processing
-     * await brainy.add("Customer feedback: Great product!")
-     *
-     * @example
-     * // Explicit literal mode for sensitive data
-     * await brainy.add("API_KEY=secret123", null, { process: 'literal' })
-     *
-     * @example
-     * // Force neural processing
-     * await brainy.add("John works at Acme Corp", null, { process: 'neural' })
+     * Set up distributed operation handlers
      */
-    add(vectorOrData: Vector | any, metadata?: T, options?: {
-        forceEmbed?: boolean;
-        addToRemote?: boolean;
-        id?: string;
-        service?: string;
-        process?: 'auto' | 'literal' | 'neural';
-    }): Promise<string>;
+    private setupDistributedOperations;
     /**
-     * Add a vector to the remote server
-     * @param id ID of the vector to add
-     * @param vector Vector to add
-     * @param metadata Optional metadata to associate with the vector
-     * @returns True if successful, false otherwise
-     * @private
+     * Local add operation (without distribution)
+     */
+    private localAdd;
+    /**
+     * Local find operation (potentially for a specific shard)
      */
-    private addToRemote;
+    private localFind;
+    /**
+     * Get distributed health status
+     * @returns Health status if distributed mode is enabled
+     */
+    getHealthStatus(): any;
     /**
      * Add multiple vectors or data items to the database
      * @param items Array of items to add
@@ -663,13 +653,14 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * @returns Array of IDs for the added items
      */
     /**
-     * Add multiple nouns in batch
-     * @param items Array of nouns to add
+     * Add multiple nouns in batch with required types
+     * @param items Array of nouns to add (all must have types)
      * @param options Batch processing options
      * @returns Array of generated IDs
      */
     addNouns(items: Array<{
         vectorOrData: Vector | any;
+        nounType: NounType | string;
         metadata?: T;
     }>, options?: {
         forceEmbed?: boolean;
@@ -677,19 +668,6 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
         concurrency?: number;
         batchSize?: number;
     }): Promise<string[]>;
-    /**
-     * Add multiple vectors or data items to both local and remote databases
-     * @param items Array of items to add
-     * @param options Additional options
-     * @returns Array of IDs for the added items
-     */
-    addBatchToBoth(items: Array<{
-        vectorOrData: Vector | any;
-        metadata?: T;
-    }>, options?: {
-        forceEmbed?: boolean;
-        concurrency?: number;
-    }): Promise<string[]>;
     /**
      * Filter search results by service
      * @param results Search results to filter
@@ -1023,6 +1001,12 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * @returns Array of verbs of the specified type
      */
     getVerbsByType(type: string): Promise<GraphVerb[]>;
+    /**
+     * Get all verbs associated with a specific noun (both as source and target)
+     * @param nounId The ID of the noun
+     * @returns Array of verbs where the noun is either source or target
+     */
+    getVerbsForNoun(nounId: string): Promise<GraphVerb[]>;
     /**
      * Delete a verb
      * @param id The ID of the verb to delete
@@ -1287,48 +1271,6 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
         searchMode?: 'local' | 'remote' | 'combined';
         metadata?: any;
     }): Promise<SearchResult<T>[]>;
-    /**
-     * Search a remote Brainy server for similar vectors
-     * @param queryVectorOrData Query vector or data to search for
-     * @param k Number of results to return
-     * @param options Additional options
-     * @returns Array of search results
-     */
-    searchRemote(queryVectorOrData: Vector | any, k?: number, options?: {
-        forceEmbed?: boolean;
-        nounTypes?: string[];
-        includeVerbs?: boolean;
-        storeResults?: boolean;
-        service?: string;
-        searchField?: string;
-        offset?: number;
-    }): Promise<SearchResult<T>[]>;
-    /**
-     * Search both local and remote Brainy instances, combining the results
-     * @param queryVectorOrData Query vector or data to search for
-     * @param k Number of results to return
-     * @param options Additional options
-     * @returns Array of search results
-     */
-    searchCombined(queryVectorOrData: Vector | any, k?: number, options?: {
-        forceEmbed?: boolean;
-        nounTypes?: string[];
-        includeVerbs?: boolean;
-        localFirst?: boolean;
-        service?: string;
-        searchField?: string;
-        offset?: number;
-    }): Promise<SearchResult<T>[]>;
-    /**
-     * Check if the instance is connected to a remote server
-     * @returns True if connected to a remote server, false otherwise
-     */
-    isConnectedToRemoteServer(): boolean;
-    /**
-     * Disconnect from the remote server
-     * @returns True if successfully disconnected, false if not connected
-     */
-    disconnectFromRemoteServer(): Promise<boolean>;
     /**
      * Ensure the database is initialized
      */
@@ -1526,14 +1468,21 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * @returns Created noun ID
      */
     /**
-     * Add a noun to the database
+     * Add a noun to the database with required type
      * Clean 2.0 API - primary method for adding data
      *
      * @param vectorOrData Vector array or data to embed
-     * @param metadata Metadata to store with the noun
+     * @param nounType Required noun type (one of 31 types)
+     * @param metadata Optional metadata object
      * @returns The generated ID
      */
-    addNoun(vectorOrData: Vector | any, metadata?: T): Promise<string>;
+    addNoun(vectorOrData: Vector | any, nounType: NounType | string, metadata?: T, options?: {
+        forceEmbed?: boolean;
+        addToRemote?: boolean;
+        id?: string;
+        service?: string;
+        process?: 'auto' | 'literal' | 'neural';
+    }): Promise<string>;
     /**
      * Add Verb - Unified relationship creation between nouns
      * Creates typed relationships with proper vector embeddings from metadata
@@ -1702,23 +1651,19 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * - brain.neural.clusterStream() - Progressive streaming
      * - brain.neural.getLOD() - Level-of-detail for scale
      */
-    get neural(): any;
+    get neural(): ImprovedNeuralAPI;
     /**
      * Simple similarity check (shorthand for neural.similar)
      */
-    similar(a: any, b: any): Promise<number>;
+    similar(a: any, b: any, options?: any): Promise<number>;
     /**
      * Get semantic clusters (shorthand for neural.clusters)
      */
-    clusters(options?: any): Promise<any[]>;
+    clusters(items?: any, options?: any): Promise<any[]>;
     /**
      * Get related items (shorthand for neural.neighbors)
      */
-    related(id: string, limit?: number): Promise<any[]>;
-    /**
-     * Get visualization data (shorthand for neural.visualize)
-     */
-    visualize(options?: any): Promise<any>;
+    related(id: string, options?: any): Promise<any[]>;
     /**
      * 🚀 TRIPLE INTELLIGENCE SEARCH - Natural Language & Complex Queries
      * The revolutionary search that combines vector, graph, and metadata intelligence!