logistics-expert

name	logistics-expert
version	1.0.0
description	Expert-level supply chain management, logistics optimization, warehouse systems, and fleet management
category	domains
tags	["logistics","supply-chain","warehouse","fleet","optimization"]
allowed-tools	["Read","Write","Edit"]

Logistics Expert

Expert guidance for supply chain management, logistics optimization, warehouse management systems, and transportation planning.

Core Concepts

Supply Chain Management

• Inventory management
• Demand forecasting
• Procurement and sourcing
• Warehouse management (WMS)
• Transportation management (TMS)
• Order fulfillment
• Last-mile delivery

Optimization

• Route optimization
• Load planning
• Inventory optimization
• Network design
• Cost minimization
• Delivery scheduling

Technologies

• RFID and barcode scanning
• GPS tracking
• IoT sensors
• Predictive analytics
• Automated warehouses
• Drone delivery

Warehouse Management System

from dataclasses import dataclass
from typing import List, Optional
from datetime import datetime
from enum import Enum

class StorageType(Enum):
    PALLET = "pallet"
    SHELF = "shelf"
    BULK = "bulk"
    COLD = "cold_storage"

@dataclass
class Location:
    location_id: str
    zone: str
    aisle: str
    rack: str
    level: int
    storage_type: StorageType
    capacity: float
    current_load: float

@dataclass
class Product:
    sku: str
    name: str
    category: str
    weight: float
    volume: float
    storage_requirements: str

@dataclass
class InventoryItem:
    item_id: str
    sku: str
    quantity: int
    location_id: str
    received_date: datetime
    expiry_date: Optional[datetime]
    batch_number: str

class WMS:
    """Warehouse Management System"""

    def ():
        .db = db

     ():
        
        items_received = []

         item  shipment.items:
            
            location = .find_optimal_location(item)

            
            inventory_item = InventoryItem(
                item_id=generate_id(),
                sku=item.sku,
                quantity=item.quantity,
                location_id=location.location_id,
                received_date=datetime.now(),
                expiry_date=item.expiry_date,
                batch_number=item.batch_number
            )

            .db.save_inventory(inventory_item)
            .update_location_capacity(location, item)

            items_received.append(inventory_item)

         {
            : shipment.shipment_id,
            : (items_received),
            : 
        }

     ():
        
        product = .db.get_product(item.sku)
        available_locations = .db.get_available_locations(
            storage_type=product.storage_requirements,
            min_capacity=product.volume * item.quantity
        )

        
        
        
        

        same_sku_locations = [
            loc  loc  available_locations
             .has_same_sku(loc, item.sku)
        ]

         same_sku_locations:
             same_sku_locations[]

        
         product.category == :
             (available_locations, key= l: l.distance_to_shipping)

        
         (available_locations, key= l: l.utilization_score)

     ():
        
        order = .db.get_order(order_id)
        picking_list = []

         line_item  order.line_items:
            inventory = .db.find_inventory(
                sku=line_item.sku,
                quantity=line_item.quantity
            )

            picking_list.append({
                : line_item.sku,
                : line_item.quantity,
                : inventory.location_id,
                : inventory.batch_number
            })

        
        optimized_route = .optimize_picking_route(picking_list)

         {
            : order_id,
            : optimized_route,
            : .estimate_picking_time(optimized_route)
        }

     ():
        
        
        sorted_picks = (
            picking_list,
            key= x: (
                .get_location_zone(x[]),
                .get_location_aisle(x[]),
                .get_location_rack(x[])
            )
        )

         sorted_picks

     ():
        
        total_quantity = .db.sum_quantity_by_sku(sku)
        product = .db.get_product(sku)

        status = 
         total_quantity <= product.reorder_point:
            status = 
         total_quantity <= product.safety_stock:
            status = 

         {
            : sku,
            : total_quantity,
            : status,
            : product.reorder_point
        }

Route Optimization

import numpy as np
from scipy.spatial.distance import cdist
from ortools.constraint_solver import routing_enums_pb2
from ortools.constraint_solver import pywrapcp

class RouteOptimizer:
    """Vehicle routing optimization"""

    def optimize_delivery_routes(self, depot, deliveries, vehicles):
        """Optimize delivery routes using OR-Tools"""
        # Create distance matrix
        locations = [depot] + deliveries
        distance_matrix = self.create_distance_matrix(locations)

        # Create routing model
        manager = pywrapcp.RoutingIndexManager(
            len(distance_matrix),
            len(vehicles),
            0  # depot index
        )

        routing = pywrapcp.RoutingModel(manager)

        # Distance callback
        def distance_callback(from_index, to_index):
            from_node = manager.IndexToNode(from_index)
            to_node = manager.IndexToNode(to_index)
            return distance_matrix[from_node][to_node]

        transit_callback_index = routing.RegisterTransitCallback(distance_callback)
        routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)

        # Add capacity constraints
        def demand_callback(from_index):
            from_node = manager.IndexToNode(from_index)
            return deliveries[from_node - 1].weight if from_node > 0 else 0

        demand_callback_index = routing.RegisterUnaryTransitCallback(demand_callback)

        routing.AddDimensionWithVehicleCapacity(
            demand_callback_index,
            ,  
            [v.capacity  v  vehicles],
            ,  
            
        )

        
        search_parameters = pywrapcp.DefaultRoutingSearchParameters()
        search_parameters.first_solution_strategy = (
            routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC
        )

        solution = routing.SolveWithParameters(search_parameters)

         solution:
             .extract_routes(manager, routing, solution, locations)

         

     ():
        
        coords = np.array([(loc.lat, loc.lon)  loc  locations])
         cdist(coords, coords, metric=)

     ():
        
        routes = []

         vehicle_id  (routing.vehicles()):
            route = []
            index = routing.Start(vehicle_id)

              routing.IsEnd(index):
                node = manager.IndexToNode(index)
                route.append(locations[node])
                index = solution.Value(routing.NextVar(index))

            routes.append({
                : vehicle_id,
                : route,
                : solution.ObjectiveValue()
            })

         routes

Fleet Management

@dataclass
class Vehicle:
    vehicle_id: str
    type: str
    capacity_weight: float
    capacity_volume: float
    fuel_efficiency: float
    status: str
    current_location: dict
    maintenance_due: datetime

class FleetManagement:
    """Fleet tracking and management"""

    def __init__(self, db):
        self.db = db

    def assign_vehicle(self, delivery):
        """Assign optimal vehicle for delivery"""
        available_vehicles = self.db.get_available_vehicles(
            location=delivery.origin,
            min_capacity=delivery.total_weight
        )

        # Score vehicles based on:
        # - Distance from origin
        # - Capacity utilization
        # - Fuel efficiency
        # - Maintenance status

        best_vehicle = min(
            available_vehicles,
            key=lambda v: self.calculate_vehicle_score(v, delivery)
        )

        return best_vehicle

    def track_vehicle(self, vehicle_id):
        """Real-time vehicle tracking"""
        vehicle = self.db.get_vehicle(vehicle_id)
        current_route = self.db.get_current_route(vehicle_id)

        return {
            'vehicle_id': vehicle_id,
            : vehicle.current_location,
            : vehicle.status,
            : current_route.delivery_id  current_route  ,
            : .calculate_eta(vehicle, current_route)  current_route  ,
            : vehicle.fuel_level,
            : vehicle.daily_distance
        }

     ():
        
        vehicle = .db.get_vehicle(vehicle_id)
        maintenance_history = .db.get_maintenance_history(vehicle_id)

        
        
        
        
        

        next_maintenance = .predict_maintenance_date(
            vehicle,
            maintenance_history
        )

         {
            : vehicle_id,
            : next_maintenance,
            : ,
            : .estimate_maintenance_cost(vehicle)
        }

Inventory Forecasting

from sklearn.ensemble import RandomForestRegressor
import pandas as pd

class DemandForecasting:
    """Demand forecasting and inventory optimization"""

    def forecast_demand(self, sku, forecast_period_days=30):
        """Forecast product demand"""
        # Get historical sales data
        historical_data = self.db.get_sales_history(sku, days=365)

        # Features: day of week, month, seasonality, promotions
        df = pd.DataFrame(historical_data)
        df['day_of_week'] = pd.to_datetime(df['date']).dt.dayofweek
        df['month'] = pd.to_datetime(df['date']).dt.month
        df['is_promotion'] = df['promotion_id'].notna().astype(int)

        X = df[['day_of_week', 'month', 'is_promotion']]
        y = df['quantity_sold']

        # Train model
        model = RandomForestRegressor(n_estimators=100)
        model.fit(X, y)

        # Generate forecast
        future_dates = pd.date_range(
            start=pd.Timestamp.now(),
            periods=forecast_period_days,
            freq='D'
        )

        forecast_features = pd.DataFrame({
            'day_of_week': future_dates.dayofweek,
            'month': future_dates.month,
            'is_promotion': 0  # Assume no promotions unless specified
        })

        predicted_demand = model.predict(forecast_features)

        return {
            'sku': sku,
            : forecast_period_days,
            : predicted_demand.tolist(),
            : (predicted_demand),
            : .calculate_order_quantity(
                predicted_demand,
                sku
            )
        }

     ():
        
        product = .db.get_product(sku)
        total_demand = (forecast)

        
        eoq = np.sqrt(
            ( * total_demand * product.order_cost) /
            product.holding_cost
        )

         (eoq)

Best Practices

• Implement real-time tracking
• Use predictive analytics
• Optimize inventory levels
• Automate warehouse operations
• Enable multi-modal transportation
• Implement quality control
• Track KPIs (on-time delivery, accuracy)
• Use lean principles
• Enable reverse logistics
• Implement safety protocols

Anti-Patterns

❌ Manual inventory tracking ❌ No route optimization ❌ Overstocking or understocking ❌ Poor warehouse layout ❌ No real-time visibility ❌ Ignoring data analytics ❌ Inefficient picking processes

Resources

• Council of Supply Chain Management Professionals: https://cscmp.org/
• OR-Tools: https://developers.google.com/optimization
• Warehouse Management: https://www.mhi.org/
• Transportation Management: https://www.inboundlogistics.com/