Slotting Optimization AI

Intelligent zone placement recommendations and warehouse optimization using heuristic algorithms.

Overview

The Slotting Optimization AI module analyzes inventory movement patterns, zone utilization, and warehouse layout to provide intelligent recommendations for optimal item placement. It uses heuristic algorithms (no external AI required) to calculate zone suitability scores and reorganization plans.

Features

• Zone Suitability Scoring: Multi-factor analysis for zone placement
• Reorganization Recommendations: Actionable plans for item movement
• Heatmap Generation: Visual representation of zone activity
• Movement Velocity Analysis: Tracks item movement frequency
• Turnover Rate Calculation: Analyzes item turnover patterns
• Congestion Factor: Identifies overloaded zones
• Travel Cost Optimization: Minimizes movement distances

Architecture

graph TB
    A[Inventory Data] --> B[Slotting AI Engine]
    C[Stock Movements] --> B
    D[Zone Data] --> B
    E[Pick Lists] --> B
    
    B --> F[Velocity Analysis]
    B --> G[Turnover Calculation]
    B --> H[Congestion Analysis]
    
    F --> I[Zone Scoring]
    G --> I
    H --> I
    
    I --> J[Recommendations]
    I --> K[Heatmap]
    
    style B fill:#3b82f6
    style I fill:#10b981
    style J fill:#f59e0b

Data Sources

The AI analyzes:

1. Inventory Items: Current locations, quantities
2. Stock Movements: Movement frequency, patterns
3. Pick Lists: Picking frequency by zone
4. Zone Data: Coordinates, capacity, utilization
5. Historical Data: Movement trends over time

API Functions

Get Zone Suitability Scores

import { getZoneSuitabilityScores } from '@/lib/slottingAI';

const { data, error } = await getZoneSuitabilityScores('item-uuid');
// Returns: ZoneSuitabilityScore[]

Returns:

interface ZoneSuitabilityScore {
  zoneId: string;
  zoneCode: string;
  score: number; // 0-100
  velocityScore: number;
  turnoverScore: number;
  congestionScore: number;
  travelCostScore: number;
}

Get Reorganization Recommendations

import { getReorganizationRecommendations } from '@/lib/slottingAI';

const { data, error } = await getReorganizationRecommendations();
// Returns: ReorganizationRecommendation[]

Returns:

interface ReorganizationRecommendation {
  itemId: string;
  sku: string;
  itemName: string;
  fromZoneId: string | null;
  fromZoneCode: string | null;
  toZoneId: string;
  toZoneCode: string;
  walkingTimeSaved: number; // seconds
  impactScore: number; // 0-100
  reason: string;
}

Get Heatmap Data

import { getHeatmapData } from '@/lib/slottingAI';

const { data, error } = await getHeatmapData();
// Returns: HeatmapData[]

Returns:

interface HeatmapData {
  zoneId: string;
  zoneCode: string;
  heatValue: number; // 0-100
  movementCount: number;
  pickFrequency: number;
  congestionFactor: number;
}

Get Item Recommendation

import { getItemRecommendation } from '@/lib/slottingAI';

const { data, error } = await getItemRecommendation('item-uuid');
// Returns: ItemRecommendation

Returns:

interface ItemRecommendation {
  itemId: string;
  sku: string;
  itemName: string;
  currentZoneId: string | null;
  currentZoneCode: string | null;
  recommendedZoneId: string;
  recommendedZoneCode: string;
  impactScore: number;
  velocityScore: number;
  turnoverScore: number;
  explanation: string;
}

Scoring Algorithm

Velocity Score

Measures how frequently an item moves:

velocityScore = (movementCount / timePeriod) * weight

Factors:

• Movement count in time period
• Time period length (default: 30 days)
• Weight factor (configurable)

Turnover Score

Measures item turnover rate:

turnoverScore = (totalMovements / averageQuantity) * weight

Factors:

• Total movements
• Average quantity on hand
• Weight factor

Congestion Score

Measures zone congestion:

congestionScore = (itemsInZone / zoneCapacity) * weight

Factors:

• Number of items in zone
• Zone capacity
• Weight factor

Travel Cost Score

Measures movement distance cost:

travelCostScore = (averageDistance * movementFrequency) * weight

Factors:

• Average distance to pick locations
• Movement frequency
• Weight factor

Combined Score

totalScore = (
  velocityScore * 0.3 +
  turnoverScore * 0.25 +
  congestionScore * 0.2 +
  travelCostScore * 0.25
)

Optimization Flow

sequenceDiagram
    participant User
    participant AI
    participant DB
    participant Routing
    
    User->>AI: Get Recommendations
    AI->>DB: Load Inventory Data
    AI->>DB: Load Movement History
    AI->>DB: Load Zone Data
    DB->>AI: Return Data
    AI->>AI: Calculate Scores
    AI->>Routing: Get Zone Distances
    Routing->>AI: Return Distances
    AI->>AI: Generate Recommendations
    AI->>User: Return Results

Best Practices

1. Regular Analysis

Run recommendations regularly:

// Weekly analysis
const recommendations = await getReorganizationRecommendations();
// Review and implement high-impact recommendations

2. Focus on High Impact

Prioritize recommendations with high impact scores:

const highImpact = recommendations.filter(r => r.impactScore > 70);
// Implement these first

3. Consider Travel Time

Use walking time saved metric:

const timeSavings = recommendations
  .filter(r => r.walkingTimeSaved > 60) // More than 1 minute
  .sort((a, b) => b.walkingTimeSaved - a.walkingTimeSaved);

4. Monitor Heatmaps

Regularly review heatmap data:

const heatmap = await getHeatmapData();
// Identify overloaded zones (high congestionFactor)
// Identify underused zones (low heatValue)

Integration

Warehouse Map Integration

Heatmap data is visualized on the warehouse floor plan:

// Floor plan shows:
// - Heat values per zone
// - Congestion indicators
// - Movement frequency

Inventory Integration

Recommendations can trigger inventory transfers:

// When recommendation is accepted:
await transfer({
  item_id: recommendation.itemId,
  from_zone_id: recommendation.fromZoneId,
  to_zone_id: recommendation.toZoneId,
  qty: item.quantity,
  reason: `Slotting optimization: ${recommendation.reason}`,
});

Routing Integration

Uses routing engine for distance calculations:

import { computeDistance } from '@/lib/routingEngine';

const distance = computeDistance(fromZone, toZone);
// Used in travel cost calculations

Performance Optimization

Caching

The AI module uses intelligent caching:

// Cache duration: 5 minutes
// Cache keys: based on data timestamps
// Auto-invalidation on data changes

Batch Processing

Loads data in batches to minimize queries:

// Single query for all zones
// Single query for all movements
// Single query for all items

Troubleshooting

Issue: No Recommendations

Symptom: getReorganizationRecommendations() returns empty array.

Solution:

1. Verify sufficient movement history (at least 7 days)
2. Check zones have coordinates
3. Verify inventory items exist

Issue: Low Scores

Symptom: All zone scores are low.

Solution:

1. Check movement data is being recorded
2. Verify zone capacity is set correctly
3. Review scoring weights in configuration

Issue: Recommendations Not Accurate

Symptom: Recommendations don't match expectations.

Solution:

1. Review movement history quality
2. Check zone coordinates accuracy
3. Adjust scoring weights if needed

Related Documentation

• Inventory Module - Provides item data
• Routing Engine - Provides distance calculations
• Warehouse Map Module - Visualizes heatmaps
• Pick & Pack Module - Provides picking data