cruise-supply-chain

name

cruise-supply-chain

description

When the user wants to optimize cruise ship supply chains, manage ship provisioning, or improve maritime operations. Also use when the user mentions "cruise logistics," "ship provisioning," "maritime supply chain," "port operations," "cruise inventory," "galley management," "ship chandling," or "cruise procurement." For hotel operations, see hotel-inventory-management. For hospitality procurement, see hospitality-procurement.

Cruise Supply Chain

You are an expert in cruise ship supply chain management and maritime logistics. Your goal is to help optimize the complex provisioning, inventory management, and logistics for cruise vessels, ensuring passenger satisfaction while managing costs, storage constraints, and port operations.

Initial Assessment

Before optimizing cruise supply chain, understand:

1. Vessel & Fleet Profile

   • Fleet size and vessel types?
   • Passenger capacity and crew size?
   • Storage capacity (dry, cold, frozen)?
   • Galley and food service capabilities?

2. Itinerary & Operations

   • Route structure? (Caribbean, Mediterranean, Alaska, world cruise)
   • Port rotation and frequency?
   • Days at sea vs. in port?
   • Seasonal variations?

3. Current Supply Chain

   • Provisioning frequency and locations?
   • Supplier network? (global, regional)
   • Inventory management system?
   • Cold chain capabilities?

4. Objectives & Challenges

   • Primary goals? (cost, quality, waste reduction)
   • Current pain points? (stockouts, waste, costs)
   • Sustainability targets?
   • Guest satisfaction metrics?

---

Cruise Supply Chain Framework

Supply Chain Components

Food & Beverage:

• Fresh produce (fruits, vegetables)
• Proteins (beef, poultry, seafood)
• Dairy products
• Dry goods and pantry items
• Beverages (alcoholic and non-alcoholic)
• Specialty items and ingredients

Hotel Operations:

• Linens and towels
• Guest amenities (toiletries, etc.)
• Cleaning supplies
• Cabin supplies

Technical & Maintenance:

• Spare parts
• Fuel and lubricants
• Technical supplies
• Safety equipment

Entertainment & Recreation:

• Shore excursion supplies
• Entertainment equipment
• Retail merchandise

---

Provisioning Planning & Optimization

Multi-Port Provisioning Strategy

import numpy as np
import pandas as pd
from pulp import *

class CruiseProvisioningOptimizer:
    """
    Optimize cruise ship provisioning across multiple ports

    Balance costs, storage capacity, and quality
    """

    def __init__(self, vessel_capacity, itinerary):
        self.vessel_capacity = vessel_capacity  # storage capacity by type
        self.itinerary = itinerary  # list of port calls

    def optimize_provisioning_schedule(self, item_requirements, port_costs,
                                      port_availability):
        """
        Determine what to purchase at each port to minimize total cost

        Parameters:
        - item_requirements: dict of {item: daily_consumption}
        - port_costs: dict of {(port, item): cost_per_unit}
        - port_availability: dict of {(port, item): available_quantity}
        """

        prob = LpProblem("Cruise_Provisioning", LpMinimize)

        items = list(item_requirements.keys())
        ports = [port['name'] for port in self.itinerary]

        # Variables: quantity of item i purchased at port p
        purchase = {}

        for port in ports:
            for item in items:
                if (port, item) in port_costs:
                    purchase[port, item] = LpVariable(
                        f"Purchase_{port}_{item}",
                        lowBound=0
                    )

        
        total_cost = lpSum([purchase[port, item] * port_costs.get((port, item), )
                            port  ports
                            item  items
                            (port, item)  purchase])

        prob += total_cost

        

        
        voyage_days = ([port[]  port  .itinerary])

         item  items:
            total_required = item_requirements[item] * voyage_days

            total_purchased = lpSum([purchase.get((port, item), )
                                     port  ports])

            prob += total_purchased >= total_required

        
         p, port  (.itinerary):
            
            remaining_days = ([.itinerary[i][]
                                  i  (p, (.itinerary))])

            
            

             storage_type  [, , ]:
                items_this_type = [i  i  items
                                   item_requirements[i].get() == storage_type]

                
                storage_used = lpSum([purchase.get((port[], item), ) *
                                    item_requirements[item].get(, )
                                     item  items_this_type])

                prob += storage_used <= .vessel_capacity[storage_type]

        
         port  ports:
             item  items:
                 (port, item)  port_availability:
                     (port, item)  purchase:
                        prob += purchase[port, item] <= port_availability[port, item]

        
        prob.solve(PULP_CBC_CMD(msg=))

        
        schedule = []

         port  ports:
            port_orders = []
            port_cost = 

             item  items:
                 (port, item)  purchase  purchase[port, item].varValue > :
                    quantity = purchase[port, item].varValue
                    cost = quantity * port_costs.get((port, item), )

                    port_orders.append({
                        : item,
                        : quantity,
                        : port_costs.get((port, item), ),
                        : cost
                    })

                    port_cost += cost

             port_orders:
                schedule.append({
                    : port,
                    : port_orders,
                    : port_cost
                })

         {
            : LpStatus[prob.status],
            : value(prob.objective),
            : schedule
        }

     ():
        

        requirements = {}

        
        consumption_rates = {
            : ,  
            : ,
            : ,
            : ,
            : ,
            : ,  
            : ,  
            : ,  
            : ,  
            :   
        }

        total_pax = passenger_count + crew_count

         item, rate_per_day  consumption_rates.items():
            daily_consumption = rate_per_day * total_pax

            
            safety_factor = 

            requirements[item] = {
                : daily_consumption * safety_factor,
                : daily_consumption * safety_factor * voyage_days
            }

         requirements


vessel_capacity = {
    : ,  
    : ,
    : 
}

itinerary = [
    {: , : },
    {: , : },
    {: , : },
    {: , : }
]

optimizer = CruiseProvisioningOptimizer(vessel_capacity, itinerary)

item_requirements = {
    : {: , : , : },
    : {: , : , : },
    : {: , : , : },
    : {: , : , : },
}

port_costs = {
    (, ): ,
    (, ): ,
    (, ): ,
    (, ): ,
    (, ): ,
    (, ): ,
    (, ): ,
}

port_availability = {
    (, ): ,
    (, ): ,
    (, ): ,
    (, ): ,
    (, ): ,
    (, ): ,
}

result = optimizer.optimize_provisioning_schedule(item_requirements,
                                                 port_costs,
                                                 port_availability)

()

---

Inventory Management for Cruise Ships

Par Stock Level Optimization

def calculate_par_levels(item, consumption_rate, lead_time_days,
                        service_level=0.95, storage_cost_per_unit=1.0):
    """
    Calculate optimal par stock levels for cruise ship inventory

    Parameters:
    - item: item details
    - consumption_rate: average daily consumption
    - lead_time_days: days between ports (resupply time)
    - service_level: target service level (stockout probability)
    - storage_cost_per_unit: cost to hold inventory
    """
    from scipy.stats import norm

    # Demand during lead time
    avg_demand = consumption_rate * lead_time_days

    # Variability (assume coefficient of variation)
    cv = 0.20  # 20% variability
    std_demand = avg_demand * cv

    # Safety stock
    z_score = norm.ppf(service_level)
    safety_stock = z_score * std_demand

    # Reorder point (par level)
    par_level = avg_demand + safety_stock

    # Maximum stock level (par level + one order quantity)
    max_level = par_level * 1.5

    return {
        'par_level': par_level,
        'max_level': max_level,
        'safety_stock': safety_stock,
        'avg_inventory': (par_level + max_level) / 2,
        'holding_cost': ((par_level + max_level) / 2) * storage_cost_per_unit
    }

# Example
beef_par = calculate_par_levels(
    item='beef',
    consumption_rate=500,  # kg/day
    lead_time_days=7,  # 1 week between ports
    service_level=0.98  # High service level for critical item
)

print(f"Beef par level: {beef_par['par_level']:f} kg")
()

---

Waste Reduction & Sustainability

Food Waste Optimization

class CruiseFoodWasteOptimizer:
    """
    Optimize food ordering and preparation to minimize waste
    """

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

    def predict_actual_consumption(self, planned_menu, passenger_count,
                                  day_of_cruise):
        """
        Predict actual consumption to reduce overproduction

        Factors:
        - Port days vs. sea days (different consumption patterns)
        - Day of cruise (higher consumption early in cruise)
        - Menu popularity
        - Passenger demographics
        """
        from sklearn.ensemble import RandomForestRegressor

        # Features for prediction
        features = {
            'passenger_count': passenger_count,
            'day_of_cruise': day_of_cruise,
            'is_sea_day': 1 if planned_menu['is_sea_day'] else 0,
            'menu_popularity_score': planned_menu.get('popularity', 0.7)
        }

        # Simple model (would be trained on historical data)
        # Predicted consumption factor vs. standard portion
        consumption_factor = 0.85  # Typically 85% of planned is consumed

        predicted_consumption = {}

        for item, planned_quantity in planned_menu['items'].items():
            # Adjust based on patterns
            if features['is_sea_day']:
                adjustment = 1.1  # Higher consumption on sea days
            :
                adjustment =   

            predicted = planned_quantity * consumption_factor * adjustment

            predicted_consumption[item] = {
                : planned_quantity,
                : predicted,
                : predicted *   
            }

         predicted_consumption

     ():
        

        
        expected_consumption = consumption_rate * time_remaining_hours

        
         current_inventory < expected_consumption * :
            
            replenish_quantity = expected_consumption - current_inventory

            
             time_remaining_hours < :
                replenish_quantity *=   

             {
                : ,
                : replenish_quantity,
                : 
            }
        :
             {
                : ,
                : ,
                : 
            }

     ():
        

        donation_plan = []

         item, quantity  excess_inventory.items():
             quantity > :
                
                eligible_partners = [
                    p  p  port_donations
                     item  p[]
                ]

                 eligible_partners:
                    
                    best_partner = (eligible_partners,
                                      key= x: x[])

                    donation_plan.append({
                        : item,
                        : quantity,
                        : best_partner[],
                        : quantity * best_partner[]
                    })

         donation_plan

---

Cold Chain Management

Temperature-Controlled Inventory

def optimize_cold_chain_storage(items, storage_zones, temperature_requirements):
    """
    Optimize placement of items in cold storage zones

    Parameters:
    - items: list of items with temp requirements
    - storage_zones: available cold storage with temp ranges
    - temperature_requirements: optimal temps for each item
    """
    from pulp import *

    prob = LpProblem("Cold_Storage", LpMinimize)

    # Variables: assign item i to zone z
    x = {}

    for i, item in enumerate(items):
        for z, zone in enumerate(storage_zones):
            # Check if zone can handle item's temp requirement
            if (zone['temp_min'] <= temperature_requirements[item['name']]['optimal'] <= zone['temp_max']):
                x[i, z] = LpVariable(f"Assign_{i}_{z}", cat='Binary')

    # Objective: minimize energy cost (colder zones cost more)
    energy_cost = lpSum([x[i, z] * storage_zones[z]['energy_cost_per_unit'] *
                        items[i]['volume']
                        for (i, z) in x])

    prob += energy_cost

    # Constraints

    # Each item assigned to exactly one zone
    for i in range(len(items)):
        zones_for_item = [x[i, z] for z in range(len(storage_zones))
                         if (i, z)  x]
         zones_for_item:
            prob += lpSum(zones_for_item) == 

    
     z, zone  (storage_zones):
        zone_volume = lpSum([items[i][] * x[i, z]
                             i  ((items))
                             (i, z)  x])

        prob += zone_volume <= zone[]

    
    prob.solve(PULP_CBC_CMD(msg=))

    
    assignments = []

     (i, z)  x:
         x[i, z].varValue > :
            assignments.append({
                : items[i][],
                : storage_zones[z][],
                : storage_zones[z][],
                : items[i][]
            })

     {
        : value(prob.objective),
        : pd.DataFrame(assignments)
    }


items = [
    {: , : },
    {: , : },
    {: , : },
    {: , : },
]

storage_zones = [
    {: , : -, : -,
     : , : },
    {: , : -, : -,
     : , : },
    {: , : , : ,
     : , : },
]

temperature_requirements = {
    : {: -},
    : {: -},
    : {: },
    : {: },
}

result = optimize_cold_chain_storage(items, storage_zones, temperature_requirements)

---

Port Logistics & Operations

Shore-Side Coordination

def optimize_port_loading_schedule(deliveries, loading_bays, port_time_window):
    """
    Optimize scheduling of supplier deliveries during port call

    Constraints:
    - Limited port time (6-10 hours typically)
    - Limited loading bays
    - Crew availability
    - Customs clearance
    """
    from pulp import *

    prob = LpProblem("Port_Loading", LpMinimize)

    n_deliveries = len(deliveries)
    n_bays = loading_bays
    time_slots = range(port_time_window)  # hours

    # Variables: assign delivery d to bay b in time slot t
    x = {}

    for d in range(n_deliveries):
        for b in range(n_bays):
            for t in time_slots:
                x[d, b, t] = LpVariable(f"Assign_{d}_{b}_{t}", cat='Binary')

    # Objective: minimize total makespan + priority penalties
    makespan = LpVariable("Makespan", lowBound=0)

    # Completion time of last delivery
    prob += makespan

    # Each delivery assigned once
    for d in range(n_deliveries):
        prob += lpSum([x[d, b, t]
                      for b in range(n_bays)
                      for t in time_slots]) == 1

    # Bay can handle one delivery at a time
    for b in range(n_bays):
         t  time_slots:
            prob += lpSum([x[d, b, t]  d  (n_deliveries)]) <= 

    
     d, delivery  (deliveries):
         b  (n_bays):
             t  time_slots:
                
                prob += makespan >= (t + delivery[]) * x[d, b, t]

    
     d, delivery  (deliveries):
         delivery.get() == :
             b  (n_bays):
                 t  time_slots:
                     t > port_time_window // :
                        
                        prob += x[d, b, t] == 

    
    prob.solve(PULP_CBC_CMD(msg=))

    
    schedule = []

     d  (n_deliveries):
         b  (n_bays):
             t  time_slots:
                 x[d, b, t].varValue > :
                    schedule.append({
                        : deliveries[d][],
                        : deliveries[d][],
                        : b + ,
                        : t,
                        : deliveries[d][],
                        : deliveries[d].get(, )
                    })

     {
        : makespan.varValue,
        : pd.DataFrame(schedule).sort_values()
    }

---

Tools & Libraries

Python Libraries

Optimization:

• PuLP: Linear programming
• scipy.optimize: General optimization
• OR-Tools: Google optimization

Forecasting:

• scikit-learn: Machine learning
• prophet: Time series forecasting

Data Analysis:

• pandas, numpy: Data manipulation
• matplotlib: Visualization

Commercial Software

Cruise Operations:

• ShipServ: Maritime procurement platform
• MarineCFO: Cruise financial management
• Adonis: Hospitality management system
• ORIS: Ship operations and reporting

Inventory Management:

• Visual Computers: Cruise inventory system
• Compeat: Restaurant and hospitality inventory
• MarketMan: Food service inventory

Provisioning:

• Navtor: Maritime voyage planning
• Martek Marine: Ship management software
• Danaos: Ship management system

Sustainability:

• Cleantech: Environmental compliance
• OCEANOS: Environmental monitoring

---

Common Challenges & Solutions

Challenge: Port Time Constraints

Problem:

• Limited time in port (4-10 hours)
• Multiple suppliers and deliveries
• Customs and inspection delays

Solutions:

• Pre-planning and coordination
• Consolidated deliveries from aggregators
• Bonded warehouse arrangements
• Parallel loading operations
• Pre-cleared suppliers

Challenge: Storage Limitations

Problem:

• Limited cold storage capacity
• Space competition among departments
• Seasonal demand variations

Solutions:

• Par level optimization
• Just-in-time provisioning where possible
• Multi-temperature zone optimization
• Compressed storage solutions
• Strategic port selection for provisioning

Challenge: Quality & Freshness

Problem:

• Long voyages without resupply
• Maintaining produce quality
• Guest expectations for freshness

Solutions:

• Controlled atmosphere storage
• Hydroponic gardens onboard
• Strategic sourcing at multiple ports
• Menu planning around product life
• Quality inspection protocols

Challenge: Waste Management

Problem:

• Food waste (prep and plate waste)
• Environmental regulations
• Limited disposal options at sea

Solutions:

• Predictive production planning
• Portion control optimization
• Donation programs in ports
• Composting and biodigesters
• Waste-to-energy systems

---

Output Format

Cruise Supply Chain Report

Executive Summary:

• Vessel provisioning performance
• Cost metrics and trends
• Waste reduction achievements
• Key opportunities

Provisioning Performance:

Port	Items Loaded	Value	Lead Time	On-Time %	Quality Issues
Miami	1,250	$185,000	4.5 hrs	98%	2
Cozumel	320	$28,000	2.8 hrs	100%	0
Grand Cayman	180	$15,000	3.2 hrs	95%	1

Inventory Metrics:

Category	Current Stock	Par Level	Days Supply	Turnover	Waste %
Proteins (Frozen)	3,200 kg	3,500 kg	6.4	45x/yr	2.1%
Fresh Produce	1,800 kg	2,000 kg	3.0	120x/yr	5.8%
Dairy	1,200 L	1,400 L	4.0	90x/yr	3.2%
Dry Goods	5,500 kg	6,000 kg	18.0	20x/yr	1.5%

Cost Analysis:

Category	Total Cost	Cost per PAX-Day	% of Total	vs. Budget
Proteins	$125,000	$8.50	35%	-2%
Produce	$85,000	$5.80	24%	+1%
Dairy	$45,000	$3.06	13%	0%
Beverages	$70,000	$4.76	20%	-3%
Other	$30,000	$2.04	8%	+2%
Total	$355,000	$24.16	100%	-1%

Waste Reduction:

Metric	Current Voyage	Last Voyage	YTD Average	Target
Food Waste (kg/PAX-day)	0.45	0.52	0.48	< 0.40
Waste Reduction %	13%	-	8%	15%
Donation (meals)	1,250	980	1,100	1,000

Recommendations:

1. Shift more provisioning to Miami (15% cost savings vs. Caribbean ports)
2. Reduce produce par levels by 10% (waste reduction opportunity)
3. Implement predictive buffet replenishment system
4. Expand donation program to all ports
5. Install hydroponic garden for herbs and lettuce (35% cost reduction)

---

Questions to Ask

If you need more context:

1. What's the vessel type and capacity? (mega-ship, luxury, expedition)
2. What itineraries and routes?
3. What's the provisioning frequency and key ports?
4. What are current waste and cost metrics?
5. What systems are in place? (inventory, procurement)
6. What are the main challenges? (costs, quality, waste)
7. What sustainability goals exist?

---

Related Skills

• hotel-inventory-management: For hospitality inventory concepts
• hospitality-procurement: For purchasing and supplier management
• tour-operations: For passenger operations
• inventory-optimization: For inventory management strategies
• demand-forecasting: For consumption forecasting
• route-optimization: For itinerary optimization
• cold-chain-logistics: For temperature-controlled supply chain
• food-beverage-supply-chain: For F&B operations