Neural API

import { Brainy } from '@soulcraft/brainy'

const brain = new Brainy()
await brain.init()

// Access Neural API
const neural = brain.neural

// Cluster similar items
const clusters = await neural.clusters()

// Find nearest neighbors
const neighbors = await neural.neighbors(entityId, 10)

// Detect outliers
const outliers = await neural.outliers(0.2)

neural.clusters(options?: {
  algorithm?: 'kmeans' | 'hierarchical' | 'sample',
  maxClusters?: number,
  threshold?: number
}): Promise<Cluster[]>

// Basic clustering
const clusters = await neural.clusters()

for (const cluster of clusters) {
  console.log(`Cluster: ${cluster.label}`)
  console.log(`Members: ${cluster.members.length}`)
  console.log(`Cohesion: ${cluster.cohesion}`)
}

// K-means with specific cluster count
const kmeansClusters = await neural.clusters({
  algorithm: 'kmeans',
  maxClusters: 5
})

// Hierarchical clustering with high similarity
const hierarchical = await neural.clusters({
  algorithm: 'hierarchical',
  threshold: 0.9  // Only very similar items
})

// Sample-based for large datasets
const sampled = await neural.clusters({
  algorithm: 'sample'  // Fast approximation
})

neural.clusterFast(options?: ClusterOptions): Promise<Cluster[]>

neural.clusterLarge(options?: ClusterOptions): Promise<Cluster[]>

neural.similar(id1: string, id2: string): Promise<number>

// Compare two entities
const score = await neural.similar(entityA, entityB)
console.log(`Similarity: ${score}`) // 0.0 to 1.0

if (score > 0.9) {
  console.log('Very similar!')
} else if (score > 0.7) {
  console.log('Related')
} else {
  console.log('Different topics')
}

neural.neighbors(id: string, count?: number): Promise<Neighbor[]>

// Find 10 nearest neighbors
const neighbors = await neural.neighbors(documentId, 10)

for (const neighbor of neighbors) {
  console.log(`${neighbor.id}: ${neighbor.score.toFixed(3)}`)
}

// Output:
// doc_abc: 0.954
// doc_def: 0.921
// doc_ghi: 0.897

neural.hierarchy(id: string, options?: {
  depth?: number,
  breadth?: number
}): Promise<HierarchyNode>

// Build hierarchy from a concept
const tree = await neural.hierarchy(conceptId, {
  depth: 3,
  breadth: 5
})

// tree = {
//   id: 'concept_123',
//   label: 'Machine Learning',
//   children: [
//     { id: 'concept_456', label: 'Deep Learning', children: [...] },
//     { id: 'concept_789', label: 'Supervised Learning', children: [...] }
//   ]
// }

neural.outliers(threshold?: number): Promise<Outlier[]>

// Detect outliers with default threshold
const outliers = await neural.outliers()
console.log(`Found ${outliers.length} outliers`)

// Stricter threshold (more outliers)
const moreOutliers = await neural.outliers(0.3)

// Looser threshold (fewer outliers)
const fewerOutliers = await neural.outliers(0.1)

// Analyze outliers
for (const outlier of outliers) {
  console.log(`ID: ${outlier.id}`)
  console.log(`Score: ${outlier.outlierScore}`)
  console.log(`Nearest cluster: ${outlier.nearestCluster}`)
}

neural.visualize(options?: {
  maxNodes?: number,
  dimensions?: 2 | 3,
  algorithm?: 'force' | 'tsne' | 'umap'
}): Promise<VisualizationData>

// Generate 2D visualization
const viz2d = await neural.visualize({
  maxNodes: 100,
  dimensions: 2,
  algorithm: 'force'
})

// Result structure
// {
//   nodes: [{ id, x, y, label, cluster }],
//   edges: [{ source, target, weight }]
// }

// Generate 3D visualization with t-SNE
const viz3d = await neural.visualize({
  maxNodes: 200,
  dimensions: 3,
  algorithm: 'tsne'
})

// Use with D3.js
const svg = d3.select('svg')
svg.selectAll('circle')
  .data(viz2d.nodes)
  .enter()
  .append('circle')
  .attr('cx', d => d.x)
  .attr('cy', d => d.y)
  .attr('r', 5)

// Extract entities from text
const entities = await brain.neural.extractor.extract(text, {
  types: ['person', 'organization', 'technology'],
  confidence: 0.7,
  cache: {
    enabled: true,
    ttl: 7 * 24 * 60 * 60 * 1000,  // 7 days
    invalidateOn: 'mtime'
  }
})

// Check cache performance
const stats = brain.neural.extractor.getCacheStats()
console.log(`Cache hit rate: ${(stats.hitRate * 100).toFixed(1)}%`)

import { Brainy, NounType } from '@soulcraft/brainy'

const brain = new Brainy()
await brain.init()

// Add some documents
const docs = [
  "Machine learning is a subset of AI",
  "Deep learning uses neural networks",
  "Natural language processing handles text",
  "Computer vision processes images",
  "Reinforcement learning learns from rewards",
  "This is about cooking recipes",  // Outlier
]

for (const doc of docs) {
  await brain.add({ data: doc, nounType: NounType.Document })
}

const neural = brain.neural

// Cluster the documents
const clusters = await neural.clusters({
  algorithm: 'kmeans',
  maxClusters: 3
})

console.log('Clusters:')
for (const cluster of clusters) {
  console.log(`  ${cluster.label}: ${cluster.members.length} members`)
}

// Find outliers
const outliers = await neural.outliers(0.2)
console.log(`\nFound ${outliers.length} outliers`)

// Generate visualization data
const vizData = await neural.visualize({
  maxNodes: 50,
  algorithm: 'force'
})

console.log(`\nVisualization: ${vizData.nodes.length} nodes, ${vizData.edges.length} edges`)