@soulcraft/brainy 4.10.2 → 4.10.4

package/dist/brainy.js

@@ -1517,6 +1517,16 @@ export class Brainy {
      */
     async addMany(params) {
         await this.ensureInitialized();
+        // Get optimal batch configuration from storage adapter (v4.11.0)
+        // This automatically adapts to storage characteristics:
+        // - GCS: 50 batch size, 100ms delay, sequential
+        // - S3/R2: 100 batch size, 50ms delay, parallel
+        // - Memory: 1000 batch size, 0ms delay, parallel
+        const storageConfig = this.storage.getBatchConfig();
+        // Use storage preferences (allow explicit user override)
+        const batchSize = params.chunkSize ?? storageConfig.maxBatchSize;
+        const parallel = params.parallel ?? storageConfig.supportsParallelWrites;
+        const delayMs = storageConfig.batchDelayMs;
         const result = {
             successful: [],
             failed: [],
@@ -1524,10 +1534,10 @@ export class Brainy {
             duration: 0
         };
         const startTime = Date.now();
-        const chunkSize = params.chunkSize || 100;
-        // Process in chunks
-        for (let i = 0; i < params.items.length; i += chunkSize) {
-            const chunk = params.items.slice(i, i + chunkSize);
+        let lastBatchTime = Date.now();
+        // Process in batches
+        for (let i = 0; i < params.items.length; i += batchSize) {
+            const chunk = params.items.slice(i, i + batchSize);
             const promises = chunk.map(async (item) => {
                 try {
                     const id = await this.add(item);
@@ -1543,18 +1553,29 @@ export class Brainy {
                     }
                 }
             });
-            if (params.parallel !== false) {
+            // Parallel vs Sequential based on storage preference
+            if (parallel) {
                 await Promise.allSettled(promises);
             }
             else {
+                // Sequential processing for rate-limited storage
                 for (const promise of promises) {
                     await promise;
                 }
             }
-            // Report progress
+            // Progress callback
             if (params.onProgress) {
                 params.onProgress(result.successful.length + result.failed.length, result.total);
             }
+            // Adaptive delay between batches
+            if (i + batchSize < params.items.length && delayMs > 0) {
+                const batchDuration = Date.now() - lastBatchTime;
+                // If batch was too fast, add delay to respect rate limits
+                if (batchDuration < delayMs) {
+                    await new Promise(resolve => setTimeout(resolve, delayMs - batchDuration));
+                }
+                lastBatchTime = Date.now();
+            }
         }
         result.duration = Date.now() - startTime;
         return result;
@@ -1655,6 +1676,13 @@ export class Brainy {
      */
     async relateMany(params) {
         await this.ensureInitialized();
+        // Get optimal batch configuration from storage adapter (v4.11.0)
+        // Automatically adapts to storage characteristics
+        const storageConfig = this.storage.getBatchConfig();
+        // Use storage preferences (allow explicit user override)
+        const batchSize = params.chunkSize ?? storageConfig.maxBatchSize;
+        const parallel = params.parallel ?? storageConfig.supportsParallelWrites;
+        const delayMs = storageConfig.batchDelayMs;
         const result = {
             successful: [],
             failed: [],
@@ -1662,11 +1690,11 @@ export class Brainy {
             duration: 0
         };
         const startTime = Date.now();
-        const chunkSize = params.chunkSize || 100;
-        for (let i = 0; i < params.items.length; i += chunkSize) {
-            const chunk = params.items.slice(i, i + chunkSize);
-            if (params.parallel) {
-                // Process chunk in parallel
+        let lastBatchTime = Date.now();
+        for (let i = 0; i < params.items.length; i += batchSize) {
+            const chunk = params.items.slice(i, i + batchSize);
+            if (parallel) {
+                // Parallel processing
                 const promises = chunk.map(async (item) => {
                     try {
                         const relationId = await this.relate(item);
@@ -1682,10 +1710,10 @@ export class Brainy {
                         }
                     }
                 });
-                await Promise.all(promises);
+                await Promise.allSettled(promises);
             }
             else {
-                // Process chunk sequentially
+                // Sequential processing
                 for (const item of chunk) {
                     try {
                         const relationId = await this.relate(item);
@@ -1702,10 +1730,18 @@ export class Brainy {
                     }
                 }
             }
-            // Report progress
+            // Progress callback
             if (params.onProgress) {
                 params.onProgress(result.successful.length + result.failed.length, result.total);
             }
+            // Adaptive delay
+            if (i + batchSize < params.items.length && delayMs > 0) {
+                const batchDuration = Date.now() - lastBatchTime;
+                if (batchDuration < delayMs) {
+                    await new Promise(resolve => setTimeout(resolve, delayMs - batchDuration));
+                }
+                lastBatchTime = Date.now();
+            }
         }
         result.duration = Date.now() - startTime;
         return result.successful;

package/dist/import/ImportCoordinator.js

@@ -499,17 +499,114 @@ export class ImportCoordinator {
             });
             console.log(`✅ Document entity created: ${documentEntityId}`);
         }
-        // Create entities in graph
-        for (const row of rows) {
-            const entity = row.entity || row;
-            // Find corresponding VFS file
-            const vfsFile = vfsResult.files.find((f) => f.entityId === entity.id);
-            // Create or merge entity
-            try {
-                const importSource = vfsResult.rootPath;
-                let entityId;
-                let wasMerged = false;
-                if (actuallyEnableDeduplication) {
+        // ============================================
+        // v4.11.0: Batch entity creation using addMany()
+        // Replaces entity-by-entity loop for 10-100x performance improvement on cloud storage
+        // ============================================
+        if (!actuallyEnableDeduplication) {
+            // FAST PATH: Batch creation without deduplication (recommended for imports > 100 entities)
+            const importSource = vfsResult.rootPath;
+            // Prepare all entity parameters upfront
+            const entityParams = rows.map((row) => {
+                const entity = row.entity || row;
+                const vfsFile = vfsResult.files.find((f) => f.entityId === entity.id);
+                return {
+                    data: entity.description || entity.name,
+                    type: entity.type,
+                    metadata: {
+                        ...entity.metadata,
+                        name: entity.name,
+                        confidence: entity.confidence,
+                        vfsPath: vfsFile?.path,
+                        importedFrom: 'import-coordinator',
+                        imports: [importSource],
+                        ...(trackingContext && {
+                            importIds: [trackingContext.importId],
+                            projectId: trackingContext.projectId,
+                            importedAt: trackingContext.importedAt,
+                            importFormat: trackingContext.importFormat,
+                            importSource: trackingContext.importSource,
+                            sourceRow: row.rowNumber,
+                            sourceSheet: row.sheet,
+                            ...trackingContext.customMetadata
+                        })
+                    }
+                };
+            });
+            // Batch create all entities (storage-aware batching handles rate limits automatically)
+            const addResult = await this.brain.addMany({
+                items: entityParams,
+                continueOnError: true,
+                onProgress: (done, total) => {
+                    options.onProgress?.({
+                        stage: 'storing-graph',
+                        message: `Creating entities: ${done}/${total}`,
+                        processed: done,
+                        total,
+                        entities: done
+                    });
+                }
+            });
+            // Map results to entities array and update rows with new IDs
+            for (let i = 0; i < addResult.successful.length; i++) {
+                const entityId = addResult.successful[i];
+                const row = rows[i];
+                const entity = row.entity || row;
+                const vfsFile = vfsResult.files.find((f) => f.entityId === entity.id);
+                entity.id = entityId;
+                entities.push({
+                    id: entityId,
+                    name: entity.name,
+                    type: entity.type,
+                    vfsPath: vfsFile?.path
+                });
+                newCount++;
+            }
+            // Handle failed entities
+            if (addResult.failed.length > 0) {
+                console.warn(`⚠️  ${addResult.failed.length} entities failed to create`);
+            }
+            // Create provenance links in batch
+            if (documentEntityId && options.createProvenanceLinks !== false && entities.length > 0) {
+                const provenanceParams = entities.map((entity, idx) => {
+                    const row = rows[idx];
+                    return {
+                        from: documentEntityId,
+                        to: entity.id,
+                        type: VerbType.Contains,
+                        metadata: {
+                            relationshipType: 'provenance',
+                            evidence: `Extracted from ${sourceInfo?.sourceFilename}`,
+                            sheet: row?.sheet,
+                            rowNumber: row?.rowNumber,
+                            extractedAt: Date.now(),
+                            format: sourceInfo?.format,
+                            ...(trackingContext && {
+                                importIds: [trackingContext.importId],
+                                projectId: trackingContext.projectId,
+                                createdAt: Date.now(),
+                                importFormat: trackingContext.importFormat,
+                                ...trackingContext.customMetadata
+                            })
+                        }
+                    };
+                });
+                await this.brain.relateMany({
+                    items: provenanceParams,
+                    continueOnError: true
+                });
+                provenanceCount = provenanceParams.length;
+            }
+        }
+        else {
+            // SLOW PATH: Entity-by-entity with deduplication (only for small imports < 100 entities)
+            for (const row of rows) {
+                const entity = row.entity || row;
+                const vfsFile = vfsResult.files.find((f) => f.entityId === entity.id);
+                try {
+                    const importSource = vfsResult.rootPath;
+                    let entityId;
+                    let wasMerged = false;
                     // Use deduplicator to check for existing entities
                     const mergeResult = await this.deduplicator.createOrMerge({
                         id: entity.id,
@@ -546,181 +643,154 @@ export class ImportCoordinator {
                     else {
                         newCount++;
                     }
-                }
-                else {
-                    // Direct creation without deduplication
-                    entityId = await this.brain.add({
-                        data: entity.description || entity.name,
+                    // Update entity ID in extraction result
+                    entity.id = entityId;
+                    entities.push({
+                        id: entityId,
+                        name: entity.name,
                         type: entity.type,
-                        metadata: {
-                            ...entity.metadata,
-                            name: entity.name,
-                            confidence: entity.confidence,
-                            vfsPath: vfsFile?.path,
-                            importedFrom: 'import-coordinator',
-                            imports: [importSource],
-                            // v4.10.0: Import tracking metadata
-                            ...(trackingContext && {
-                                importIds: [trackingContext.importId],
-                                projectId: trackingContext.projectId,
-                                importedAt: trackingContext.importedAt,
-                                importFormat: trackingContext.importFormat,
-                                importSource: trackingContext.importSource,
-                                sourceRow: row.rowNumber,
-                                sourceSheet: row.sheet,
-                                ...trackingContext.customMetadata
-                            })
-                        }
+                        vfsPath: vfsFile?.path
                     });
-                    newCount++;
-                }
-                // Update entity ID in extraction result
-                entity.id = entityId;
-                entities.push({
-                    id: entityId,
-                    name: entity.name,
-                    type: entity.type,
-                    vfsPath: vfsFile?.path
-                });
-                // ============================================
-                // v4.9.0: Create provenance relationship (document → entity)
-                // ============================================
-                if (documentEntityId && options.createProvenanceLinks !== false) {
-                    await this.brain.relate({
-                        from: documentEntityId,
-                        to: entityId,
-                        type: VerbType.Contains,
-                        metadata: {
-                            relationshipType: 'provenance',
-                            evidence: `Extracted from ${sourceInfo?.sourceFilename}`,
-                            sheet: row.sheet,
-                            rowNumber: row.rowNumber,
-                            extractedAt: Date.now(),
-                            format: sourceInfo?.format,
-                            // v4.10.0: Import tracking metadata
-                            ...(trackingContext && {
-                                importIds: [trackingContext.importId],
-                                projectId: trackingContext.projectId,
-                                createdAt: Date.now(),
-                                importFormat: trackingContext.importFormat,
-                                ...trackingContext.customMetadata
-                            })
-                        }
-                    });
-                    provenanceCount++;
-                }
-                // Collect relationships for batch creation
-                if (options.createRelationships && row.relationships) {
-                    for (const rel of row.relationships) {
-                        try {
-                            // CRITICAL FIX (v3.43.2): Prevent infinite placeholder creation loop
-                            // Find or create target entity using EXACT matching only
-                            let targetEntityId;
-                            // STEP 1: Check if target already exists in entities list (includes placeholders)
-                            // This prevents creating duplicate placeholders - the root cause of Bug #1
-                            const existingTarget = entities.find(e => e.name.toLowerCase() === rel.to.toLowerCase());
-                            if (existingTarget) {
-                                targetEntityId = existingTarget.id;
+                    // ============================================
+                    // v4.9.0: Create provenance relationship (document → entity)
+                    // ============================================
+                    if (documentEntityId && options.createProvenanceLinks !== false) {
+                        await this.brain.relate({
+                            from: documentEntityId,
+                            to: entityId,
+                            type: VerbType.Contains,
+                            metadata: {
+                                relationshipType: 'provenance',
+                                evidence: `Extracted from ${sourceInfo?.sourceFilename}`,
+                                sheet: row.sheet,
+                                rowNumber: row.rowNumber,
+                                extractedAt: Date.now(),
+                                format: sourceInfo?.format,
+                                // v4.10.0: Import tracking metadata
+                                ...(trackingContext && {
+                                    importIds: [trackingContext.importId],
+                                    projectId: trackingContext.projectId,
+                                    createdAt: Date.now(),
+                                    importFormat: trackingContext.importFormat,
+                                    ...trackingContext.customMetadata
+                                })
                             }
-                            else {
-                                // STEP 2: Try to find in extraction results (rows)
-                                // FIX: Use EXACT matching instead of fuzzy .includes()
-                                // Fuzzy matching caused false matches (e.g., "Entity_29" matching "Entity_297")
-                                for (const otherRow of rows) {
-                                    const otherEntity = otherRow.entity || otherRow;
-                                    if (otherEntity.name.toLowerCase() === rel.to.toLowerCase()) {
-                                        targetEntityId = otherEntity.id;
-                                        break;
-                                    }
+                        });
+                        provenanceCount++;
+                    }
+                    // Collect relationships for batch creation
+                    if (options.createRelationships && row.relationships) {
+                        for (const rel of row.relationships) {
+                            try {
+                                // CRITICAL FIX (v3.43.2): Prevent infinite placeholder creation loop
+                                // Find or create target entity using EXACT matching only
+                                let targetEntityId;
+                                // STEP 1: Check if target already exists in entities list (includes placeholders)
+                                // This prevents creating duplicate placeholders - the root cause of Bug #1
+                                const existingTarget = entities.find(e => e.name.toLowerCase() === rel.to.toLowerCase());
+                                if (existingTarget) {
+                                    targetEntityId = existingTarget.id;
                                 }
-                                // STEP 3: If still not found, create placeholder entity ONCE
-                                // The placeholder is added to entities array, so future searches will find it
-                                if (!targetEntityId) {
-                                    targetEntityId = await this.brain.add({
-                                        data: rel.to,
-                                        type: NounType.Thing,
-                                        metadata: {
-                                            name: rel.to,
-                                            placeholder: true,
-                                            inferredFrom: entity.name,
-                                            // v4.10.0: Import tracking metadata
-                                            ...(trackingContext && {
-                                                importIds: [trackingContext.importId],
-                                                projectId: trackingContext.projectId,
-                                                importedAt: trackingContext.importedAt,
-                                                importFormat: trackingContext.importFormat,
-                                                ...trackingContext.customMetadata
-                                            })
+                                else {
+                                    // STEP 2: Try to find in extraction results (rows)
+                                    // FIX: Use EXACT matching instead of fuzzy .includes()
+                                    // Fuzzy matching caused false matches (e.g., "Entity_29" matching "Entity_297")
+                                    for (const otherRow of rows) {
+                                        const otherEntity = otherRow.entity || otherRow;
+                                        if (otherEntity.name.toLowerCase() === rel.to.toLowerCase()) {
+                                            targetEntityId = otherEntity.id;
+                                            break;
                                         }
-                                    });
-                                    // CRITICAL: Add to entities array so future searches find it
-                                    entities.push({
-                                        id: targetEntityId,
-                                        name: rel.to,
-                                        type: NounType.Thing
-                                    });
+                                    }
+                                    // STEP 3: If still not found, create placeholder entity ONCE
+                                    // The placeholder is added to entities array, so future searches will find it
+                                    if (!targetEntityId) {
+                                        targetEntityId = await this.brain.add({
+                                            data: rel.to,
+                                            type: NounType.Thing,
+                                            metadata: {
+                                                name: rel.to,
+                                                placeholder: true,
+                                                inferredFrom: entity.name,
+                                                // v4.10.0: Import tracking metadata
+                                                ...(trackingContext && {
+                                                    importIds: [trackingContext.importId],
+                                                    projectId: trackingContext.projectId,
+                                                    importedAt: trackingContext.importedAt,
+                                                    importFormat: trackingContext.importFormat,
+                                                    ...trackingContext.customMetadata
+                                                })
+                                            }
+                                        });
+                                        // CRITICAL: Add to entities array so future searches find it
+                                        entities.push({
+                                            id: targetEntityId,
+                                            name: rel.to,
+                                            type: NounType.Thing
+                                        });
+                                    }
                                 }
+                                // Add to relationships array with target ID for batch processing
+                                relationships.push({
+                                    id: '', // Will be assigned after batch creation
+                                    from: entityId,
+                                    to: targetEntityId,
+                                    type: rel.type,
+                                    confidence: rel.confidence, // v4.2.0: Top-level field
+                                    weight: rel.weight || 1.0, // v4.2.0: Top-level field
+                                    metadata: {
+                                        evidence: rel.evidence,
+                                        // v4.10.0: Import tracking metadata (will be merged in batch creation)
+                                        ...(trackingContext && {
+                                            importIds: [trackingContext.importId],
+                                            projectId: trackingContext.projectId,
+                                            importedAt: trackingContext.importedAt,
+                                            importFormat: trackingContext.importFormat,
+                                            ...trackingContext.customMetadata
+                                        })
+                                    }
+                                });
+                            }
+                            catch (error) {
+                                // Skip relationship collection errors (entity might not exist, etc.)
+                                continue;
                             }
-                            // Add to relationships array with target ID for batch processing
-                            relationships.push({
-                                id: '', // Will be assigned after batch creation
-                                from: entityId,
-                                to: targetEntityId,
-                                type: rel.type,
-                                confidence: rel.confidence, // v4.2.0: Top-level field
-                                weight: rel.weight || 1.0, // v4.2.0: Top-level field
-                                metadata: {
-                                    evidence: rel.evidence,
-                                    // v4.10.0: Import tracking metadata (will be merged in batch creation)
-                                    ...(trackingContext && {
-                                        importIds: [trackingContext.importId],
-                                        projectId: trackingContext.projectId,
-                                        importedAt: trackingContext.importedAt,
-                                        importFormat: trackingContext.importFormat,
-                                        ...trackingContext.customMetadata
-                                    })
-                                }
-                            });
                         }
-                        catch (error) {
-                            // Skip relationship collection errors (entity might not exist, etc.)
-                            continue;
+                    }
+                    // Streaming import: Progressive flush with dynamic interval adjustment (v4.2.0+)
+                    entitiesSinceFlush++;
+                    if (entitiesSinceFlush >= currentFlushInterval) {
+                        const flushStart = Date.now();
+                        await this.brain.flush();
+                        const flushDuration = Date.now() - flushStart;
+                        totalFlushes++;
+                        // Reset counter
+                        entitiesSinceFlush = 0;
+                        // Recalculate flush interval based on current entity count
+                        const newInterval = this.getProgressiveFlushInterval(entities.length);
+                        if (newInterval !== currentFlushInterval) {
+                            console.log(`📊 Flush interval adjusted: ${currentFlushInterval} → ${newInterval}\n` +
+                                `   Reason: Reached ${entities.length} entities (threshold for next tier)\n` +
+                                `   Impact: ${newInterval > currentFlushInterval ? 'Fewer' : 'More'} flushes = ${newInterval > currentFlushInterval ? 'Better performance' : 'More frequent updates'}`);
+                            currentFlushInterval = newInterval;
                         }
+                        // Notify progress callback that data is now queryable
+                        await options.onProgress?.({
+                            stage: 'storing-graph',
+                            message: `Flushed indexes (${entities.length}/${rows.length} entities, ${flushDuration}ms)`,
+                            processed: entities.length,
+                            total: rows.length,
+                            entities: entities.length,
+                            queryable: true // ← Indexes are flushed, data is queryable!
+                        });
                     }
                 }
-                // Streaming import: Progressive flush with dynamic interval adjustment (v4.2.0+)
-                entitiesSinceFlush++;
-                if (entitiesSinceFlush >= currentFlushInterval) {
-                    const flushStart = Date.now();
-                    await this.brain.flush();
-                    const flushDuration = Date.now() - flushStart;
-                    totalFlushes++;
-                    // Reset counter
-                    entitiesSinceFlush = 0;
-                    // Recalculate flush interval based on current entity count
-                    const newInterval = this.getProgressiveFlushInterval(entities.length);
-                    if (newInterval !== currentFlushInterval) {
-                        console.log(`📊 Flush interval adjusted: ${currentFlushInterval} → ${newInterval}\n` +
-                            `   Reason: Reached ${entities.length} entities (threshold for next tier)\n` +
-                            `   Impact: ${newInterval > currentFlushInterval ? 'Fewer' : 'More'} flushes = ${newInterval > currentFlushInterval ? 'Better performance' : 'More frequent updates'}`);
-                        currentFlushInterval = newInterval;
-                    }
-                    // Notify progress callback that data is now queryable
-                    await options.onProgress?.({
-                        stage: 'storing-graph',
-                        message: `Flushed indexes (${entities.length}/${rows.length} entities, ${flushDuration}ms)`,
-                        processed: entities.length,
-                        total: rows.length,
-                        entities: entities.length,
-                        queryable: true // ← Indexes are flushed, data is queryable!
-                    });
+                catch (error) {
+                    // Skip entity creation errors (might already exist, etc.)
+                    continue;
                 }
             }
-            catch (error) {
-                // Skip entity creation errors (might already exist, etc.)
-                continue;
-            }
-        }
+        } // End of deduplication else block
         // Final flush for any remaining entities
         if (entitiesSinceFlush > 0) {
             const flushStart = Date.now();

package/dist/storage/adapters/azureBlobStorage.d.ts

@@ -12,7 +12,7 @@
  * v4.0.0: Fully compatible with metadata/vector separation architecture
  */
 import { HNSWNoun, HNSWVerb, HNSWNounWithMetadata, HNSWVerbWithMetadata, StatisticsData } from '../../coreTypes.js';
-import { BaseStorage } from '../baseStorage.js';
+import { BaseStorage, StorageBatchConfig } from '../baseStorage.js';
 type HNSWNode = HNSWNoun;
 type Edge = HNSWVerb;
 /**
@@ -70,6 +70,20 @@ export declare class AzureBlobStorage extends BaseStorage {
         };
         readOnly?: boolean;
     });
+    /**
+     * Get Azure Blob-optimized batch configuration
+     *
+     * Azure Blob Storage has moderate rate limits between GCS and S3:
+     * - Medium batch sizes (75 items)
+     * - Parallel processing supported
+     * - Moderate delays (75ms)
+     *
+     * Azure can handle ~2000 operations/second with good performance
+     *
+     * @returns Azure Blob-optimized batch configuration
+     * @since v4.11.0
+     */
+    getBatchConfig(): StorageBatchConfig;
     /**
      * Initialize the storage adapter
      */

package/dist/storage/adapters/azureBlobStorage.js

@@ -83,6 +83,31 @@ export class AzureBlobStorage extends BaseStorage {
             prodLog.info('🚀 High-volume mode FORCED via BRAINY_FORCE_HIGH_VOLUME environment variable');
         }
     }
+    /**
+     * Get Azure Blob-optimized batch configuration
+     *
+     * Azure Blob Storage has moderate rate limits between GCS and S3:
+     * - Medium batch sizes (75 items)
+     * - Parallel processing supported
+     * - Moderate delays (75ms)
+     *
+     * Azure can handle ~2000 operations/second with good performance
+     *
+     * @returns Azure Blob-optimized batch configuration
+     * @since v4.11.0
+     */
+    getBatchConfig() {
+        return {
+            maxBatchSize: 75,
+            batchDelayMs: 75,
+            maxConcurrent: 75,
+            supportsParallelWrites: true, // Azure handles parallel reasonably
+            rateLimit: {
+                operationsPerSecond: 2000, // Moderate limits
+                burstCapacity: 500
+            }
+        };
+    }
     /**
      * Initialize the storage adapter
      */