# Migration Guide: v3.36.0

## Overview

Brainy v3.36.0 introduces **enterprise-grade adaptive memory sizing** and **sync fast path optimizations** for production-scale deployments. These are **internal optimizations** that improve performance and resource efficiency with **zero breaking changes** to your existing code.

**TL;DR**: Your code continues to work exactly as before. These improvements are automatic and require no migration.

---

## What's New in v3.36.0

### 1. Adaptive Memory Sizing

**Automatic resource-aware cache allocation from 2GB to 128GB+ systems.**

**Before v3.36.0:**
```typescript
// Fixed cache sizes, manual tuning required
const brain = new Brainy()
// Cache size: ~512MB (hardcoded default)
```

**After v3.36.0:**
```typescript
// Automatic adaptive sizing - no code changes needed!
const brain = new Brainy()
// Cache adapts:
// - 2GB system → 400MB cache (after 150MB model reservation)
// - 16GB system → 4GB cache
// - 128GB system → 32GB+ cache (logarithmic scaling)
```

**Features:**
- ✅ Container-aware (Docker/K8s cgroups v1/v2 detection)
- ✅ Environment-smart (dev 25%, container 40%, production 50%)
- ✅ Model memory accounting (150MB Q8, 250MB FP32)
- ✅ Memory pressure monitoring with actionable warnings

### 2. Sync Fast Path Optimization

**Zero async overhead when vectors are in memory.**

**Before v3.36.0:**
```typescript
// Every distance calculation was async (overhead even when cached)
const results = await brain.search("query")  // Always async
```

**After v3.36.0:**
```typescript
// Same API, but internally optimized
const results = await brain.search("query")
// - Sync path: Vector in UnifiedCache → zero overhead
// - Async path: Vector needs loading → minimal overhead
// Your code: Unchanged! ✅
```

**Performance Impact:**
- 🚀 Hot paths (cached vectors): **30-50% faster** (no async overhead)
- 🔥 Cold paths (storage loading): Same as before (async when needed)
- 📊 Production workloads: **15-25% overall speedup** (assuming 70%+ cache hit rate)

### 3. Production Monitoring

**New diagnostics for capacity planning and performance tuning.**

```typescript
import { Brainy } from '@soulcraft/brainy'

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

// NEW: Comprehensive cache performance statistics
const stats = brain.hnsw.getCacheStats()

console.log(`
Caching Strategy: ${stats.cachingStrategy}
Cache Hit Rate: ${stats.unifiedCache.hitRatePercent}%
Memory: ${stats.hnswCache.estimatedMemoryMB}MB HNSW cache
Recommendations: ${stats.recommendations.join(', ')}
`)

// Example output:
// Caching Strategy: on-demand
// Cache Hit Rate: 89.2%
// Memory: 245.3MB HNSW cache
// Recommendations: All metrics healthy - no action needed
```

---

## Breaking Changes

### ✅ Zero Breaking Changes

**All changes are internal optimizations.** Your existing code continues to work without modification.

**Public API:**
- ✅ `brain.add()` - Unchanged
- ✅ `brain.search()` - Unchanged
- ✅ `brain.find()` - Unchanged
- ✅ `brain.relate()` - Unchanged
- ✅ All storage adapters - Unchanged

**The only visible change:** Better performance and automatic memory sizing.

---

## Upgrading

### Step 1: Update Package

```bash
npm install @soulcraft/brainy@latest
```

### Step 2: Restart Your Application

```bash
# Development
npm run dev

# Production
npm run start
```

**That's it!** No code changes required.

---

## Verification

### Check Adaptive Sizing is Working

```typescript
import { Brainy } from '@soulcraft/brainy'

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

// Check UnifiedCache allocation
const cacheStats = brain.hnsw.unifiedCache.getStats()
console.log(`Cache Size: ${cacheStats.maxSize / 1024 / 1024} MB`)
console.log(`Environment: ${cacheStats.memory.environment}`)
console.log(`Allocation Ratio: ${(cacheStats.memory.allocationRatio * 100).toFixed(0)}%`)

// Example output (2GB system):
// Cache Size: 400 MB
// Environment: development
// Allocation Ratio: 25%

// Example output (16GB production):
// Cache Size: 4000 MB
// Environment: production
// Allocation Ratio: 50%
```

### Monitor Performance Improvements

```typescript
// Before: Track baseline performance
console.time('search')
const results = await brain.search("query", { limit: 10 })
console.timeEnd('search')
// Before v3.36.0: ~15ms (with async overhead)
// After v3.36.0:  ~10ms (sync fast path when cached)
```

### Check Cache Performance Stats

```typescript
const stats = brain.hnsw.getCacheStats()

console.log('Cache Performance Stats:')
console.log(`  Strategy: ${stats.cachingStrategy}`)
console.log(`  Entity Count: ${stats.autoDetection.entityCount.toLocaleString()}`)
console.log(`  Cache Hit Rate: ${stats.unifiedCache.hitRatePercent}%`)
console.log(`  HNSW Memory: ${stats.hnswCache.estimatedMemoryMB}MB`)
console.log(`  Fairness: ${stats.fairness.fairnessViolation ? 'VIOLATION' : 'OK'}`)
console.log(`  Recommendations:`)
stats.recommendations.forEach(r => console.log(`    - ${r}`))
```

---

## Configuration (Optional)

### Manual Cache Sizing

If you need to override adaptive sizing:

```typescript
const brain = new Brainy({
  cache: {
    maxSize: 1024 * 1024 * 1024  // Force 1GB cache
  }
})
```

**Note:** Adaptive sizing is recommended. Manual sizing should only be used for specific deployment constraints.

### Disable Sync Fast Path (Not Recommended)

For debugging or compatibility testing:

```typescript
// Internal feature flag (not exposed in public API)
// Contact support if you need to disable sync fast path
```

**Why not recommended:** Sync fast path has zero breaking changes and significant performance benefits.

---

## Rollback

If you need to rollback to v3.35.0:

```bash
npm install @soulcraft/brainy@3.35.0
```

**Note:** We don't anticipate any issues, but rollback is straightforward if needed.

---

## Performance Tuning

### Scenario 1: Low Memory Environment (2GB-4GB)

```typescript
// Adaptive sizing automatically allocates 25% in development
const brain = new Brainy()
await brain.init()

// Monitor memory pressure
const memoryInfo = brain.hnsw.unifiedCache.getMemoryInfo()
console.log(memoryInfo.currentPressure)
// { pressure: 'moderate', warnings: [...] }
```

**Recommendation:**
- Let adaptive sizing handle allocation
- Monitor `getCacheStats()` for cache hit rate
- If hit rate < 50%, consider increasing available RAM

### Scenario 2: High Memory Environment (32GB-128GB+)

```typescript
// Adaptive sizing uses logarithmic scaling to prevent over-allocation
const brain = new Brainy()
await brain.init()

// Check allocation
const stats = brain.hnsw.unifiedCache.getStats()
console.log(`Allocated: ${stats.maxSize / 1024 / 1024 / 1024} GB`)
// 64GB system → ~32GB cache (50% production allocation)
// 128GB system → ~40GB cache (logarithmic scaling prevents waste)
```

**Recommendation:**
- Adaptive sizing prevents over-allocation on large systems
- Monitor fairness metrics to ensure HNSW doesn't dominate cache
- Use `getCacheStats()` to verify cache efficiency

### Scenario 3: Container Deployments (Docker/K8s)

```typescript
// Adaptive sizing detects cgroup limits automatically
const brain = new Brainy()
await brain.init()

// Verify container detection
const memoryInfo = brain.hnsw.unifiedCache.getMemoryInfo()
console.log(`Container: ${memoryInfo.memoryInfo.isContainer}`)
console.log(`Source: ${memoryInfo.memoryInfo.source}`)  // 'cgroup-v2' or 'cgroup-v1'
console.log(`Available: ${memoryInfo.memoryInfo.available / 1024 / 1024} MB`)
```

**Recommendation:**
- Set explicit memory limits in Docker/K8s (don't use unlimited)
- Adaptive sizing allocates 40% in container environments (vs 50% bare metal)
- Monitor warnings for container memory limit detection

---

## Troubleshooting

### Cache Size Too Small

**Symptom:** On-demand caching active but cache hit rate < 50%

**Solution:**
```typescript
const stats = brain.hnsw.getCacheStats()
console.log(stats.recommendations)
// Recommendation: "Low cache hit rate (42.3%). Consider increasing UnifiedCache size for better performance"
```

**Action:** Increase available system memory or reduce entity count.

### Memory Pressure Warnings

**Symptom:** Log warnings about memory utilization > 85%

**Solution:**
```typescript
const memoryInfo = brain.hnsw.unifiedCache.getMemoryInfo()
console.log(memoryInfo.currentPressure)
// { pressure: 'high', warnings: ['HIGH: Memory utilization at 87.2%...'] }
```

**Action:** Either:
1. Increase available system memory
2. Reduce cache size manually
3. Reduce dataset size (system automatically uses on-demand caching for large datasets)

### Fairness Violations

**Symptom:** HNSW using >90% of cache with <10% access

**Solution:**
```typescript
const stats = brain.hnsw.getCacheStats()
if (stats.fairness.fairnessViolation) {
  console.log(`HNSW cache: ${stats.fairness.hnswAccessPercent}% access`)
  console.log(`HNSW size: ${stats.hnswCache.estimatedMemoryMB}MB`)
}
```

**Action:** This indicates cache eviction policies need tuning. Contact support or file an issue.

---

## FAQ

### Q: Do I need to change my code?

**A:** No. All changes are internal optimizations. Your existing code works unchanged.

### Q: Will my application use more memory?

**A:** No. Adaptive sizing respects available system resources. On small systems (2GB), it allocates *less* than before (400MB vs 512MB) because it now accounts for model memory (150MB Q8).

### Q: What if I'm in a container with memory limits?

**A:** Adaptive sizing automatically detects Docker/K8s cgroup limits (v1 and v2) and allocates appropriately (40% vs 50% on bare metal).

### Q: Can I disable adaptive sizing?

**A:** Yes, set manual cache size in config. But adaptive sizing is recommended for production - it handles edge cases and automatically scales.

### Q: Will sync fast path break anything?

**A:** No. Public API remains async. Internally, it's sync when possible, async when needed. Your `await` statements work identically.

### Q: How do I know what caching strategy is being used?

**A:** Check `brain.hnsw.getCacheStats().cachingStrategy` (returns 'preloaded' or 'on-demand') or watch initialization logs.

### Q: What's the performance impact?

**A:** **15-25% overall speedup** in production workloads (assuming 70%+ cache hit rate). Hot paths (cached vectors) see **30-50% improvement**.

---

## Next Steps

1. ✅ **Upgrade:** `npm install @soulcraft/brainy@latest`
2. 📊 **Monitor:** Use `getCacheStats()` to verify performance improvements
3. 🎯 **Tune:** Adjust based on recommendations (if needed)
4. 📖 **Read:** [Operations Guide](../operations/capacity-planning.md) for capacity planning

---

## Support

**Issues or questions?**
- 📖 [Operations Guide](../operations/capacity-planning.md)
- 🐛 [GitHub Issues](https://github.com/soulcraftlabs/brainy/issues)
- 💬 [Discord Community](https://discord.gg/brainy)

---

**Built with ❤️ for production scale** | v3.36.0 | [Full Changelog](../../CHANGELOG.md)