@soulcraft/brainy 2.15.0 → 3.0.1

package/dist/neural/entityExtractor.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Neural Entity Extractor using Brainy's NounTypes
+ * Uses embeddings and similarity matching for accurate type detection
+ */
+import { NounType } from '../types/graphTypes.js';
+import { Vector } from '../coreTypes.js';
+import type { Brainy } from '../brainy.js';
+export interface ExtractedEntity {
+    text: string;
+    type: NounType;
+    position: {
+        start: number;
+        end: number;
+    };
+    confidence: number;
+    vector?: Vector;
+    metadata?: any;
+}
+export declare class NeuralEntityExtractor {
+    private brain;
+    private typeEmbeddings;
+    private initialized;
+    constructor(brain: Brainy | Brainy<any>);
+    /**
+     * Initialize type embeddings for neural matching
+     */
+    private initializeTypeEmbeddings;
+    /**
+     * Extract entities from text using neural matching
+     */
+    extract(text: string, options?: {
+        types?: NounType[];
+        confidence?: number;
+        includeVectors?: boolean;
+        neuralMatching?: boolean;
+    }): Promise<ExtractedEntity[]>;
+    /**
+     * Extract candidate entities using patterns
+     */
+    private extractCandidates;
+    /**
+     * Get context-based confidence boost for type matching
+     */
+    private getContextBoost;
+    /**
+     * Rule-based classification fallback
+     */
+    private classifyByRules;
+    /**
+     * Get embedding for text
+     */
+    private getEmbedding;
+    /**
+     * Calculate cosine similarity between vectors
+     */
+    private cosineSimilarity;
+    /**
+     * Simple hash function for fallback
+     */
+    private simpleHash;
+    /**
+     * Remove duplicate and overlapping entities
+     */
+    private deduplicateEntities;
+}

package/dist/neural/entityExtractor.js

@@ -0,0 +1,316 @@
+/**
+ * Neural Entity Extractor using Brainy's NounTypes
+ * Uses embeddings and similarity matching for accurate type detection
+ */
+import { NounType } from '../types/graphTypes.js';
+export class NeuralEntityExtractor {
+    constructor(brain) {
+        // Type embeddings for similarity matching
+        this.typeEmbeddings = new Map();
+        this.initialized = false;
+        this.brain = brain;
+    }
+    /**
+     * Initialize type embeddings for neural matching
+     */
+    async initializeTypeEmbeddings() {
+        if (this.initialized)
+            return;
+        // Create representative embeddings for each NounType
+        const typeExamples = {
+            [NounType.Person]: ['John Smith', 'Jane Doe', 'person', 'individual', 'human'],
+            [NounType.Organization]: ['Microsoft Corporation', 'company', 'organization', 'business', 'enterprise'],
+            [NounType.Location]: ['New York City', 'location', 'place', 'address', 'geography'],
+            [NounType.Document]: ['document', 'file', 'report', 'paper', 'text'],
+            [NounType.Event]: ['conference', 'meeting', 'event', 'occurrence', 'happening'],
+            [NounType.Product]: ['iPhone', 'product', 'item', 'merchandise', 'goods'],
+            [NounType.Service]: ['consulting', 'service', 'offering', 'provision'],
+            [NounType.Concept]: ['idea', 'concept', 'theory', 'principle', 'notion'],
+            [NounType.Media]: ['image', 'video', 'audio', 'media', 'content'],
+            [NounType.Message]: ['email', 'message', 'communication', 'note'],
+            [NounType.Task]: ['task', 'todo', 'assignment', 'job', 'work'],
+            [NounType.Project]: ['project', 'initiative', 'program', 'endeavor'],
+            [NounType.Process]: ['workflow', 'process', 'procedure', 'method'],
+            [NounType.User]: ['user', 'account', 'profile', 'member'],
+            [NounType.Role]: ['manager', 'role', 'position', 'title', 'responsibility'],
+            [NounType.Topic]: ['subject', 'topic', 'theme', 'matter'],
+            [NounType.Language]: ['English', 'language', 'tongue', 'dialect'],
+            [NounType.Currency]: ['dollar', 'currency', 'money', 'USD', 'EUR'],
+            [NounType.Measurement]: ['meter', 'measurement', 'unit', 'quantity'],
+            [NounType.Contract]: ['agreement', 'contract', 'deal', 'treaty'],
+            [NounType.Regulation]: ['law', 'regulation', 'rule', 'policy'],
+            [NounType.Resource]: ['resource', 'asset', 'material', 'supply'],
+            [NounType.Dataset]: ['database', 'dataset', 'data', 'records'],
+            [NounType.Interface]: ['API', 'interface', 'endpoint', 'connection'],
+            [NounType.Thing]: ['thing', 'object', 'item', 'entity'],
+            [NounType.Content]: ['content', 'material', 'information'],
+            [NounType.Collection]: ['collection', 'group', 'set', 'list'],
+            [NounType.File]: ['file', 'document', 'archive'],
+            [NounType.State]: ['state', 'status', 'condition'],
+            [NounType.Hypothesis]: ['hypothesis', 'theory', 'assumption'],
+            [NounType.Experiment]: ['experiment', 'test', 'trial', 'study']
+        };
+        // Generate embeddings for each type
+        for (const [type, examples] of Object.entries(typeExamples)) {
+            const combinedText = examples.join(' ');
+            const embedding = await this.getEmbedding(combinedText);
+            this.typeEmbeddings.set(type, embedding);
+        }
+        this.initialized = true;
+    }
+    /**
+     * Extract entities from text using neural matching
+     */
+    async extract(text, options) {
+        await this.initializeTypeEmbeddings();
+        const entities = [];
+        const minConfidence = options?.confidence || 0.6;
+        const targetTypes = options?.types || Object.values(NounType);
+        const useNeuralMatching = options?.neuralMatching !== false; // Default true
+        // Step 1: Extract potential entities using patterns
+        const candidates = await this.extractCandidates(text);
+        // Step 2: Classify each candidate using neural matching
+        for (const candidate of candidates) {
+            let bestType = NounType.Thing;
+            let bestConfidence = 0;
+            if (useNeuralMatching) {
+                // Get embedding for the candidate
+                const candidateVector = await this.getEmbedding(candidate.text);
+                // Find best matching NounType
+                for (const type of targetTypes) {
+                    const typeVector = this.typeEmbeddings.get(type);
+                    if (!typeVector)
+                        continue;
+                    const similarity = this.cosineSimilarity(candidateVector, typeVector);
+                    // Apply context-based boosting
+                    const contextBoost = this.getContextBoost(candidate.text, candidate.context, type);
+                    const adjustedConfidence = similarity * (1 + contextBoost);
+                    if (adjustedConfidence > bestConfidence) {
+                        bestConfidence = adjustedConfidence;
+                        bestType = type;
+                    }
+                }
+            }
+            else {
+                // Fallback to rule-based classification
+                const classification = this.classifyByRules(candidate);
+                bestType = classification.type;
+                bestConfidence = classification.confidence;
+            }
+            if (bestConfidence >= minConfidence) {
+                const entity = {
+                    text: candidate.text,
+                    type: bestType,
+                    position: candidate.position,
+                    confidence: bestConfidence
+                };
+                if (options?.includeVectors) {
+                    entity.vector = await this.getEmbedding(candidate.text);
+                }
+                entities.push(entity);
+            }
+        }
+        // Remove duplicates and overlaps
+        return this.deduplicateEntities(entities);
+    }
+    /**
+     * Extract candidate entities using patterns
+     */
+    async extractCandidates(text) {
+        const candidates = [];
+        // Enhanced patterns for entity detection
+        const patterns = [
+            // Capitalized words (potential names, places, organizations)
+            /\b([A-Z][a-zA-Z]+(?:\s+[A-Z][a-zA-Z]+)*)\b/g,
+            // Email addresses
+            /\b([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})\b/g,
+            // URLs
+            /\b(https?:\/\/[^\s]+|www\.[^\s]+)\b/g,
+            // Phone numbers
+            /\b(\+?\d{1,3}?[- .]?\(?\d{1,4}\)?[- .]?\d{1,4}[- .]?\d{1,4})\b/g,
+            // Dates
+            /\b(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{2,4}|\d{4}[\/\-]\d{1,2}[\/\-]\d{1,2})\b/g,
+            // Money amounts
+            /\b(\$[\d,]+(?:\.\d{2})?|[\d,]+(?:\.\d{2})?\s*(?:USD|EUR|GBP|JPY|CNY))\b/gi,
+            // Percentages
+            /\b(\d+(?:\.\d+)?%)\b/g,
+            // Hashtags and mentions
+            /([#@][a-zA-Z0-9_]+)/g,
+            // Product versions
+            /\b([A-Z][a-zA-Z0-9]+\s+v?\d+(?:\.\d+)*)\b/g,
+            // Quoted strings (potential names, titles)
+            /"([^"]+)"/g,
+            /'([^']+)'/g
+        ];
+        for (const pattern of patterns) {
+            let match;
+            while ((match = pattern.exec(text)) !== null) {
+                const extractedText = match[1] || match[0];
+                // Skip too short or too long
+                if (extractedText.length < 2 || extractedText.length > 100)
+                    continue;
+                // Get context (surrounding text)
+                const contextStart = Math.max(0, match.index - 30);
+                const contextEnd = Math.min(text.length, match.index + match[0].length + 30);
+                const context = text.substring(contextStart, contextEnd);
+                candidates.push({
+                    text: extractedText,
+                    position: {
+                        start: match.index,
+                        end: match.index + match[0].length
+                    },
+                    context
+                });
+            }
+        }
+        return candidates;
+    }
+    /**
+     * Get context-based confidence boost for type matching
+     */
+    getContextBoost(text, context, type) {
+        const contextLower = context.toLowerCase();
+        let boost = 0;
+        // Context clues for each type
+        const contextClues = {
+            [NounType.Person]: ['mr', 'ms', 'mrs', 'dr', 'prof', 'said', 'told', 'wrote'],
+            [NounType.Organization]: ['inc', 'corp', 'llc', 'ltd', 'company', 'announced'],
+            [NounType.Location]: ['in', 'at', 'from', 'to', 'near', 'located', 'city', 'country'],
+            [NounType.Document]: ['file', 'document', 'report', 'paper', 'pdf', 'doc'],
+            [NounType.Event]: ['event', 'conference', 'meeting', 'summit', 'on', 'at'],
+            [NounType.Product]: ['product', 'version', 'release', 'model', 'buy', 'sell'],
+            [NounType.Currency]: ['$', '€', '£', '¥', 'usd', 'eur', 'price', 'cost'],
+            [NounType.Message]: ['email', 'message', 'sent', 'received', 'wrote', 'reply'],
+            // Add more context clues as needed
+        };
+        const clues = contextClues[type] || [];
+        for (const clue of clues) {
+            if (contextLower.includes(clue)) {
+                boost += 0.1;
+            }
+        }
+        return Math.min(boost, 0.3); // Cap boost at 0.3
+    }
+    /**
+     * Rule-based classification fallback
+     */
+    classifyByRules(candidate) {
+        const text = candidate.text;
+        // Email
+        if (text.includes('@')) {
+            return { type: NounType.Message, confidence: 0.9 };
+        }
+        // URL
+        if (text.startsWith('http') || text.startsWith('www.')) {
+            return { type: NounType.Resource, confidence: 0.9 };
+        }
+        // Money
+        if (text.startsWith('$') || /\d+\.\d{2}/.test(text)) {
+            return { type: NounType.Currency, confidence: 0.85 };
+        }
+        // Percentage
+        if (text.endsWith('%')) {
+            return { type: NounType.Measurement, confidence: 0.85 };
+        }
+        // Date pattern
+        if (/\d{1,2}[\/\-]\d{1,2}/.test(text)) {
+            return { type: NounType.Event, confidence: 0.7 };
+        }
+        // Hashtag
+        if (text.startsWith('#')) {
+            return { type: NounType.Topic, confidence: 0.8 };
+        }
+        // Mention
+        if (text.startsWith('@')) {
+            return { type: NounType.User, confidence: 0.8 };
+        }
+        // Capitalized words (likely proper nouns)
+        if (/^[A-Z]/.test(text)) {
+            // Multiple words - likely organization or person
+            const words = text.split(/\s+/);
+            if (words.length > 1) {
+                // Check for organization suffixes
+                if (/\b(Inc|Corp|LLC|Ltd|Co|Group|Foundation|University)\b/i.test(text)) {
+                    return { type: NounType.Organization, confidence: 0.75 };
+                }
+                // Likely a person's name
+                return { type: NounType.Person, confidence: 0.65 };
+            }
+            // Single capitalized word - could be location
+            return { type: NounType.Location, confidence: 0.5 };
+        }
+        // Default to Thing with low confidence
+        return { type: NounType.Thing, confidence: 0.3 };
+    }
+    /**
+     * Get embedding for text
+     */
+    async getEmbedding(text) {
+        if ('embed' in this.brain && typeof this.brain.embed === 'function') {
+            return await this.brain.embed(text);
+        }
+        else {
+            // Fallback - create simple hash-based vector
+            const vector = new Array(384).fill(0);
+            for (let i = 0; i < text.length; i++) {
+                vector[i % 384] += text.charCodeAt(i) / 255;
+            }
+            return vector.map(v => v / text.length);
+        }
+    }
+    /**
+     * Calculate cosine similarity between vectors
+     */
+    cosineSimilarity(a, b) {
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        normA = Math.sqrt(normA);
+        normB = Math.sqrt(normB);
+        if (normA === 0 || normB === 0)
+            return 0;
+        return dotProduct / (normA * normB);
+    }
+    /**
+     * Simple hash function for fallback
+     */
+    simpleHash(text) {
+        let hash = 0;
+        for (let i = 0; i < text.length; i++) {
+            const char = text.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32-bit integer
+        }
+        return Math.abs(hash);
+    }
+    /**
+     * Remove duplicate and overlapping entities
+     */
+    deduplicateEntities(entities) {
+        // Sort by position and confidence
+        entities.sort((a, b) => {
+            if (a.position.start !== b.position.start) {
+                return a.position.start - b.position.start;
+            }
+            return b.confidence - a.confidence; // Higher confidence first
+        });
+        const result = [];
+        for (const entity of entities) {
+            // Check for overlap with already added entities
+            const hasOverlap = result.some(existing => (entity.position.start >= existing.position.start &&
+                entity.position.start < existing.position.end) ||
+                (entity.position.end > existing.position.start &&
+                    entity.position.end <= existing.position.end));
+            if (!hasOverlap) {
+                result.push(entity);
+            }
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=entityExtractor.js.map

package/dist/neural/improvedNeuralAPI.js

@@ -394,13 +394,9 @@ export class ImprovedNeuralAPI {
             let offset = 0;
             while (hasMoreVerbs && processedCount < maxRelationships) {
                 // Get batch of verbs using proper pagination API
-                const verbResult = await this.brain.getVerbs({
-                    pagination: {
-                        offset: offset,
-                        limit: batchSize
-                    }
-                });
-                const verbBatch = verbResult.data;
+                // Get all items and process in chunks (simplified approach)
+                const allItems = await this.brain.find({ query: '', limit: Math.min(1000, maxRelationships) });
+                const verbBatch = allItems.slice(offset, offset + batchSize);
                 if (verbBatch.length === 0) {
                     hasMoreVerbs = false;
                     break;
@@ -523,10 +519,10 @@ export class ImprovedNeuralAPI {
             const limit = options.limit || 10;
             const minSimilarity = options.minSimilarity || 0.1;
             // Use HNSW index for efficient neighbor search
-            const searchResults = await this.brain.search('', {
-                ...options,
+            const searchResults = await this.brain.find({
+                query: '',
                 limit: limit * 2, // Get more than needed for filtering
-                metadata: options.includeMetadata ? {} : undefined
+                where: options.includeMetadata ? {} : undefined
             });
             // Filter and sort neighbors
             const neighbors = [];
@@ -574,7 +570,7 @@ export class ImprovedNeuralAPI {
                 return this.hierarchyCache.get(cacheKey);
             }
             // Get item data
-            const item = await this.brain.getNoun(id);
+            const item = await this.brain.get(id);
             if (!item) {
                 throw new Error(`Item with ID ${id} not found`);
             }
@@ -1134,8 +1130,8 @@ export class ImprovedNeuralAPI {
     // Similarity implementation methods
     async _similarityById(id1, id2, options) {
         // Get vectors for both items
-        const item1 = await this.brain.getNoun(id1);
-        const item2 = await this.brain.getNoun(id2);
+        const item1 = await this.brain.get(id1);
+        const item2 = await this.brain.get(id2);
         if (!item1 || !item2) {
             return 0;
         }
@@ -1189,7 +1185,7 @@ export class ImprovedNeuralAPI {
             return input;
         }
         else if (this._isId(input)) {
-            const item = await this.brain.getNoun(input);
+            const item = await this.brain.get(input);
             return item?.vector || [];
         }
         else if (typeof input === 'string') {
@@ -1283,7 +1279,7 @@ export class ImprovedNeuralAPI {
         };
         // Get all verbs connecting the items
         for (const sourceId of itemIds) {
-            const sourceVerbs = await this.brain.getVerbsForNoun(sourceId);
+            const sourceVerbs = await this.brain.getRelations(sourceId);
             for (const verb of sourceVerbs) {
                 const targetId = verb.target;
                 if (nodes.has(targetId) && sourceId !== targetId) {
@@ -1416,17 +1412,20 @@ export class ImprovedNeuralAPI {
      */
     async _getItemsWithMetadata(itemIds) {
         const items = await Promise.all(itemIds.map(async (id) => {
-            const noun = await this.brain.getNoun(id);
+            const noun = await this.brain.get(id);
+            if (!noun) {
+                return null;
+            }
             return {
                 id,
-                vector: noun?.vector || [],
-                metadata: noun?.data || {},
-                nounType: noun?.noun || 'concept',
-                label: noun?.label || id,
-                data: noun?.data
+                vector: noun.vector || [],
+                metadata: noun.metadata || {},
+                nounType: noun.metadata?.noun || noun.metadata?.nounType || 'content',
+                label: noun.metadata?.label || noun.metadata?.data || id,
+                data: noun.metadata
             };
         }));
-        return items.filter(item => item.vector.length > 0);
+        return items.filter((item) => item !== null);
     }
     /**
      * Group items by their semantic noun types
@@ -1445,18 +1444,25 @@ export class ImprovedNeuralAPI {
     // Placeholder implementations for complex operations
     async _getAllItemIds() {
         // Get all noun IDs from the brain
-        const stats = await this.brain.getStatistics();
-        if (!stats.totalNodes || stats.totalNodes === 0) {
+        // Get total item count using find with empty query
+        const allItems = await this.brain.find({ query: '', limit: Number.MAX_SAFE_INTEGER });
+        const stats = { totalNouns: allItems.length || 0 };
+        if (!stats.totalNouns || stats.totalNouns === 0) {
             return [];
         }
-        // Use a simple approach: get recent items or sample
-        // In practice, this could be optimized with pagination
-        const items = await this.brain.getRecent(Math.min(stats.totalNodes, 10000));
-        return items.map((item) => item.id);
+        // Get nouns with pagination (limit to 10000 for performance)
+        const limit = Math.min(stats.totalNouns, 10000);
+        const result = await this.brain.find({
+            query: '',
+            limit
+        });
+        return result.map((item) => item.id).filter((id) => id);
     }
     async _getTotalItemCount() {
-        const stats = await this.brain.getStatistics();
-        return stats.totalNodes || 0;
+        // Get total item count using find with empty query
+        const allItems = await this.brain.find({ query: '', limit: Number.MAX_SAFE_INTEGER });
+        const stats = { totalNouns: allItems.length || 0 };
+        return stats.totalNouns || 0;
     }
     // ===== GRAPH ALGORITHM SUPPORTING METHODS =====
     _calculateTotalWeight(edges) {
@@ -1582,13 +1588,13 @@ export class ImprovedNeuralAPI {
      */
     async _getItemsWithVectors(itemIds) {
         const items = await Promise.all(itemIds.map(async (id) => {
-            const noun = await this.brain.getNoun(id);
+            const noun = await this.brain.get(id);
             return {
                 id,
                 vector: noun?.vector || []
             };
         }));
-        return items.filter(item => item.vector.length > 0);
+        return items.filter((item) => item !== null && item.vector.length > 0);
     }
     /**
      * Calculate centroid from items using existing distance functions
@@ -1844,47 +1850,8 @@ export class ImprovedNeuralAPI {
     async _generateIntelligentClusterLabel(members, algorithm) {
         if (members.length === 0)
             return `${algorithm}-cluster`;
-        try {
-            // Lazy load Triple Intelligence if available
-            const TripleIntelligenceEngine = await import('../triple/TripleIntelligence.js')
-                .then(m => m.TripleIntelligenceEngine)
-                .catch(() => null);
-            if (!TripleIntelligenceEngine) {
-                return this._generateClusterLabel(members, algorithm);
-            }
-            const intelligence = new TripleIntelligenceEngine(this.brain);
-            // Extract key features from cluster members
-            const memberData = members.map(m => ({
-                id: m.id,
-                type: m.nounType,
-                label: m.label,
-                data: m.data
-            }));
-            // Use Triple Intelligence to analyze the cluster and generate label
-            const prompt = `Analyze this cluster of ${memberData.length} related items and provide a concise, descriptive label (2-4 words):
-
-Items:
-${memberData.map(item => `- ${item.label || item.id} (${item.type})`).join('\n')}
-
-The items were grouped using ${algorithm} clustering. What is the most appropriate label that captures their common theme or relationship?`;
-            const response = await intelligence.find({
-                like: prompt,
-                limit: 1
-            });
-            // Extract clean label from response
-            const firstResult = response[0];
-            const label = (firstResult?.metadata?.content || firstResult?.id || `${algorithm}-cluster`)
-                .toString()
-                .replace(/^(Label:|Cluster:|Theme:)/i, '')
-                .trim()
-                .replace(/['"]/g, '')
-                .slice(0, 50);
-            return label || `${algorithm}-cluster`;
-        }
-        catch (error) {
-            // Fallback to simple labeling
-            return this._generateClusterLabel(members, algorithm);
-        }
+        // Use simple labeling - Triple Intelligence doesn't generate labels from prompts
+        return this._generateClusterLabel(members, algorithm);
     }
     /**
      * Generate simple cluster labels based on semantic analysis
@@ -2148,7 +2115,7 @@ The items were grouped using ${algorithm} clustering. What is the most appropria
      */
     async _getRecentSample(itemIds, sampleSize) {
         const items = await Promise.all(itemIds.map(async (id) => {
-            const noun = await this.brain.getNoun(id);
+            const noun = await this.brain.get(id);
             return {
                 id,
                 createdAt: noun?.createdAt || new Date(0)
@@ -2163,8 +2130,8 @@ The items were grouped using ${algorithm} clustering. What is the most appropria
      */
     async _getImportantSample(itemIds, sampleSize) {
         const items = await Promise.all(itemIds.map(async (id) => {
-            const verbs = await this.brain.getVerbsForNoun(id);
-            const noun = await this.brain.getNoun(id);
+            const verbs = await this.brain.getRelations(id);
+            const noun = await this.brain.get(id);
             // Calculate importance score
             const connectionScore = verbs.length;
             const dataScore = noun?.data ? Object.keys(noun.data).length : 0;
@@ -2246,7 +2213,15 @@ The items were grouped using ${algorithm} clustering. What is the most appropria
     }
     _calculateDomainConfidence(cluster, domainItems) {
         // Calculate how well this cluster represents the domain
-        return 0.8; // Placeholder
+        // Based on cluster density and coherence
+        const density = cluster.members.length / (cluster.members.length + 10); // Normalize
+        const coherence = cluster.cohesion || 0.5; // Use cluster's cohesion if available
+        // Domain relevance: what fraction of cluster members are from this domain
+        const domainMemberCount = cluster.members.filter(id => domainItems.some(item => item.id === id)).length;
+        const domainRelevance = cluster.members.length > 0
+            ? domainMemberCount / cluster.members.length
+            : 0;
+        return (density * 0.3 + coherence * 0.3 + domainRelevance * 0.4); // Weighted average
     }
     async _findCrossDomainMembers(cluster, threshold) {
         // Find members that might belong to multiple domains
@@ -2282,11 +2257,47 @@ The items were grouped using ${algorithm} clustering. What is the most appropria
     }
     async _calculateItemToClusterSimilarity(itemId, cluster) {
         // Calculate similarity between an item and a cluster centroid
-        return 0.5; // Placeholder
+        const item = await this.brain.get(itemId);
+        if (!item || !item.vector || !cluster.centroid) {
+            return 0; // No similarity if vectors missing
+        }
+        // Calculate cosine similarity
+        const dotProduct = item.vector.reduce((sum, val, i) => sum + val * cluster.centroid[i], 0);
+        const itemMagnitude = Math.sqrt(item.vector.reduce((sum, val) => sum + val * val, 0));
+        const centroidMagnitude = Math.sqrt(cluster.centroid.reduce((sum, val) => sum + val * val, 0));
+        if (itemMagnitude === 0 || centroidMagnitude === 0) {
+            return 0;
+        }
+        return dotProduct / (itemMagnitude * centroidMagnitude);
     }
     async _recalculateClusterCentroid(cluster) {
         // Recalculate centroid after adding new members
-        return cluster.centroid;
+        if (cluster.members.length === 0) {
+            return cluster.centroid; // Keep existing if no members
+        }
+        // Get all member vectors
+        const memberVectors = [];
+        for (const memberId of cluster.members) {
+            const member = await this.brain.get(memberId);
+            if (member && member.vector) {
+                memberVectors.push(member.vector);
+            }
+        }
+        if (memberVectors.length === 0) {
+            return cluster.centroid; // Keep existing if no valid vectors
+        }
+        // Calculate mean vector (centroid)
+        const dimensions = memberVectors[0].length;
+        const newCentroid = new Array(dimensions).fill(0);
+        for (const vector of memberVectors) {
+            for (let i = 0; i < dimensions; i++) {
+                newCentroid[i] += vector[i];
+            }
+        }
+        for (let i = 0; i < dimensions; i++) {
+            newCentroid[i] /= memberVectors.length;
+        }
+        return newCentroid;
     }
     async _calculateSimilarity(id1, id2) {
         return await this.similar(id1, id2);