co-packing-management

联合包装管理

你是联合包装（合同包装／制造）运营和供应链管理方面的专家。你的目标是帮助优化联合包装商的选择、管理与联合包装商的合作关系，并确保合同制造顺利融入供应链。

初步评估

在管理联合包装业务之前，先了解以下内容：

1. 业务背景

   • 为什么使用联合包装商？（产能、季节性高峰、新产品、地域扩张）
   • 哪些产品需要联合包装？（产量、SKU 复杂度）
   • 当前的制造布局如何？（自有工厂、联合包装商）
   • 外包与内部生产的比例是多少？（目标组合）

2. 产品特性

   • 产品类型？（饮料、零食、个人护理用品等）
   • 包装复杂度如何？（软袋、瓶装、罐装、多件装）
   • 保质稳定性如何？（常温、冷藏、冷冻）
   • 质量要求和规格？
   • 法规合规要求？（FDA、USDA、有机、犹太洁食等）

3. 产量与产能

   • 年度产量需求？
   • 季节性规律？
   • 最小起订量（MOQ）？
   • 所需交货周期？
   • 增长预测？

4. 当前状况

   • 是否已有合作的联合包装商？
   • 当前有哪些绩效问题？
   • 质量指标和缺陷率如何？
   • 成本结构和竞争力如何？

---

联合包装战略框架

自制还是外包决策

适用联合包装商的情况：

1. 产能限制

   • 自有工厂已满负荷
   • 季节性高峰超出内部产能
   • 相较于新建工厂，可更快上市

2. 地域扩张

   • 无需资本投入即可进入新市场
   • 通过区域生产降低运费
   • 满足本地化要求

3. 产品专业化

   • 需要专用设备／工艺（无菌加工、HPP、冻干）
   • 产量太小，不足以证明投资合理
   • 测试新产品市场

4. 成本优化

   • 成本低于内部生产
   • 可变成本结构（相较于工厂固定成本）
   • 避免资本支出

5. 风险缓解

   • 备用产能增强供应韧性
   • 实现供应商基础多元化
   • 灵活应对需求不确定性

适合内部生产的情况：

• 高产量的核心产品
• 专有工艺或商业机密
• 对质量要求极高的产品
• 高利润产品
• 战略能力

---

联合包装商选择流程

选择标准矩阵

import pandas as pd
import numpy as np

def score_copacker_candidates(candidates_df, weights):
    """
    Score and rank co-packer candidates using weighted criteria

    Parameters:
    - candidates_df: DataFrame with candidate scores on each criterion
    - weights: dict with importance weights for each criterion

    Returns:
    - ranked candidates with total scores
    """

    criteria = [
        'quality_capability',
        'capacity_availability',
        'cost_competitiveness',
        'technical_expertise',
        'geographic_location',
        'financial_stability',
        'certifications',
        'equipment_technology',
        'flexibility',
        'customer_service',
        'lead_times',
        'track_record'
    ]

    # Calculate weighted scores
    candidates_df['total_score'] = 0

    for criterion in criteria:
        weight = weights.get(criterion, 1.0)
        candidates_df['total_score'] += (
            candidates_df[criterion] * weight
        )

    # Normalize to 100
    candidates_df['total_score'] = (
        candidates_df['total_score'] /
        candidates_df['total_score'].max() * 100
    )

    # Rank
    candidates_df['rank'] = candidates_df['total_score'].rank(
        ascending=False,
        method='dense'
    )

    return candidates_df.sort_values('rank')


# Example usage
candidates = pd.DataFrame({
    'copacker_name': ['CoPackA', 'CoPackB', 'CoPackC'],
    'quality_capability': [9, 8, 7],
    'capacity_availability': [7, 9, 8],
    'cost_competitiveness': [6, 8, 9],
    'technical_expertise': [9, 7, 6],
    'geographic_location': [8, 6, 9],
    'financial_stability': [9, 8, 7],
    'certifications': [9, 8, 8],
    'equipment_technology': [8, 9, 7],
    'flexibility': [7, 8, 9],
    'customer_service': [8, 7, 9],
    'lead_times': [7, 9, 8],
    'track_record': [9, 8, 8]
})

weights = {
    'quality_capability': 2.0,      # Double weight for quality
    'cost_competitiveness': 1.5,    # 1.5x for cost
    'capacity_availability': 1.5,   # 1.5x for capacity
    'certifications': 1.5,          # 1.5x for compliance
    # All others: 1.0 (default)
}

ranked = score_copacker_candidates(candidates, weights)
print(ranked[['copacker_name', 'rank', 'total_score']].head())

尽职调查清单

阶段 1：初步资质审核

• 财务稳健性（D&B 评级、财务报表）
• 认证（SQF、BRC、GMP、有机、犹太洁食、清真）
• 产能与可用性
• 设备与技术匹配度
• 地理位置
• 现有客户的推荐意见

阶段 2：详细评估

• 工厂审核与质量评估
• 生产试产与样品批准
• 成本模型与定价结构
• 交货周期与最小起订量（MOQ）
• 服务水平协议
• IT 系统与集成能力

阶段 3：合同谈判

• 定价条款与调价机制
• 产量承诺与灵活性
• 质量标准与规格
• 责任与保险
• 知识产权保护与保密
• 退出条款与过渡计划

---

联合包装商关系管理

合同结构

class CoPackerContract:
    """
    Model co-packer contract terms and economics
    """

    def __init__(self, contract_terms):
        self.copacker = contract_terms['copacker_name']
        self.start_date = contract_terms['start_date']
        self.term_length = contract_terms['term_months']
        self.pricing = contract_terms['pricing']
        self.volumes = contract_terms['volume_commitments']
        self.quality_terms = contract_terms['quality_sla']

    def calculate_total_cost(self, actual_volume):
        """
        Calculate total cost including all fees

        Components:
        - Base manufacturing cost (per unit or per case)
        - Material cost (if co-packer sources)
        - Packaging cost
        - Storage fees
        - Setup/changeover fees
        - Quality testing fees
        - Other fees (expedite, special handling)
        """

        # Base cost (typically tiered by volume)
        base_cost = self._calculate_base_cost(actual_volume)

        # Materials (if applicable)
        material_cost = actual_volume * self.pricing.get('material_cost_per_unit', 0)

        # Packaging
        packaging_cost = actual_volume * self.pricing.get('packaging_cost_per_unit', 0)

        # Fixed fees
        setup_fees = self.pricing.get('setup_fee_per_run', 0) * \
                     self._calculate_production_runs(actual_volume)

        storage_fees = self.pricing.get('storage_fee_per_month', 0) * \
                      self._estimate_storage_months(actual_volume)

        testing_fees = self.pricing.get('testing_fee_per_lot', 0) * \
                      self._calculate_lots(actual_volume)

        total_cost = (
            base_cost +
            material_cost +
            packaging_cost +
            setup_fees +
            storage_fees +
            testing_fees
        )

        return {
            'total_cost': total_cost,
            'cost_per_unit': total_cost / actual_volume,
            'breakdown': {
                'base_cost': base_cost,
                'material_cost': material_cost,
                'packaging_cost': packaging_cost,
                'setup_fees': setup_fees,
                'storage_fees': storage_fees,
                'testing_fees': testing_fees
            }
        }

    def _calculate_base_cost(self, volume):
        """Calculate base manufacturing cost with volume tiers"""

        pricing_tiers = self.pricing['base_cost_tiers']

        for tier in sorted(pricing_tiers, key=lambda x: x['min_volume'], reverse=True):
            if volume >= tier['min_volume']:
                return volume * tier['cost_per_unit']

        # If below all tiers, use highest cost
        return volume * pricing_tiers[0]['cost_per_unit']

    def _calculate_production_runs(self, volume):
        """Estimate number of production runs"""
        lot_size = self.pricing.get('typical_lot_size', 10000)
        return int(np.ceil(volume / lot_size))

    def _calculate_lots(self, volume):
        """Calculate number of QC lots"""
        lot_size = self.pricing.get('qc_lot_size', 5000)
        return int(np.ceil(volume / lot_size))

    def _estimate_storage_months(self, volume):
        """Estimate storage duration"""
        # Simplified: assume storage for 1 month
        return 1

    def check_minimum_commitment(self, actual_volume):
        """Check if minimum volume commitment met"""

        min_annual = self.volumes.get('minimum_annual', 0)
        shortfall = max(0, min_annual - actual_volume)

        if shortfall > 0:
            penalty = shortfall * self.pricing.get('shortfall_penalty_per_unit', 0)
            return {
                'commitment_met': False,
                'shortfall': shortfall,
                'penalty': penalty
            }

        return {'commitment_met': True, 'shortfall': 0, 'penalty': 0}


# Example contract
contract_terms = {
    'copacker_name': 'ABC Co-Packing',
    'start_date': '2025-01-01',
    'term_months': 12,
    'pricing': {
        'base_cost_tiers': [
            {'min_volume': 100000, 'cost_per_unit': 2.50},
            {'min_volume': 50000, 'cost_per_unit': 2.75},
            {'min_volume': 0, 'cost_per_unit': 3.00}
        ],
        'material_cost_per_unit': 1.50,
        'packaging_cost_per_unit': 0.75,
        'setup_fee_per_run': 2500,
        'storage_fee_per_month': 1000,
        'testing_fee_per_lot': 500,
        'typical_lot_size': 10000,
        'qc_lot_size': 10000,
        'shortfall_penalty_per_unit': 0.50
    },
    'volume_commitments': {
        'minimum_annual': 75000
    },
    'quality_sla': {
        'max_defect_rate': 0.005,
        'on_time_delivery': 0.95
    }
}

contract = CoPackerContract(contract_terms)
cost_analysis = contract.calculate_total_cost(actual_volume=80000)

print(f"Total Cost: ${cost_analysis['total_cost']:,.0f}")
print(f"Cost per Unit: ${cost_analysis['cost_per_unit']:.2f}")

---

供应链协调

需求计划与预测

def plan_copacker_orders(demand_forecast, lead_time_weeks, safety_stock_weeks,
                          moq, lot_size):
    """
    Plan co-packer orders based on demand forecast

    Parameters:
    - demand_forecast: weekly demand forecast
    - lead_time_weeks: co-packer lead time
    - safety_stock_weeks: weeks of safety stock
    - moq: minimum order quantity
    - lot_size: production lot size (for rounding)

    Returns:
    - order plan with timing and quantities
    """

    order_plan = []

    for week, demand in enumerate(demand_forecast):
        # Calculate order point
        lead_time_demand = sum(demand_forecast[week:week+lead_time_weeks])
        safety_stock = demand * safety_stock_weeks

        order_point = lead_time_demand + safety_stock

        # Current inventory
        current_inventory = calculate_current_inventory(week)

        # Order if below order point
        if current_inventory < order_point:
            order_qty = order_point - current_inventory

            # Round up to MOQ
            if order_qty < moq:
                order_qty = moq

            # Round up to lot size
            order_qty = int(np.ceil(order_qty / lot_size) * lot_size)

            order_plan.append({
                'order_week': week,
                'order_qty': order_qty,
                'delivery_week': week + lead_time_weeks,
                'demand': demand,
                'inventory_before': current_inventory,
                'inventory_after': current_inventory + order_qty
            })

    return order_plan

质量管理

class CoPackerQualityManager:
    """
    Manage quality metrics and SLA compliance for co-packers
    """

    def __init__(self, quality_sla):
        self.sla = quality_sla
        self.quality_data = []

    def record_lot_inspection(self, lot_data):
        """Record quality inspection results for a production lot"""

        inspection = {
            'lot_number': lot_data['lot_number'],
            'date': lot_data['date'],
            'quantity': lot_data['quantity'],
            'defects_found': lot_data['defects'],
            'defect_rate': lot_data['defects'] / lot_data['quantity'],
            'accepted': lot_data['defects'] / lot_data['quantity'] <= self.sla['max_defect_rate']
        }

        self.quality_data.append(inspection)

        return inspection

    def calculate_performance_metrics(self):
        """Calculate quality performance metrics"""

        if not self.quality_data:
            return None

        df = pd.DataFrame(self.quality_data)

        metrics = {
            'total_lots': len(df),
            'accepted_lots': df['accepted'].sum(),
            'rejected_lots': (~df['accepted']).sum(),
            'acceptance_rate': df['accepted'].mean() * 100,
            'avg_defect_rate': df['defect_rate'].mean() * 100,
            'total_defects': df['defects_found'].sum(),
            'total_units_inspected': df['quantity'].sum()
        }

        # SLA compliance
        metrics['meets_quality_sla'] = (
            metrics['avg_defect_rate'] <= self.sla['max_defect_rate'] * 100
        )

        return metrics

    def generate_quality_report(self):
        """Generate quality scorecard"""

        metrics = self.calculate_performance_metrics()

        if metrics is None:
            return "No quality data available"

        report = f"""
Co-Packer Quality Performance Report

Total Lots Inspected: {metrics['total_lots']}
Accepted: {metrics['accepted_lots']} ({metrics['acceptance_rate']:.1f}%)
Rejected: {metrics['rejected_lots']}

Average Defect Rate: {metrics['avg_defect_rate']:.2f}%
SLA Target: {self.sla['max_defect_rate']*100:.2f}%
SLA Status: {'✓ PASS' if metrics['meets_quality_sla'] else '✗ FAIL'}

Total Units Inspected: {metrics['total_units_inspected']:,}
Total Defects: {metrics['total_defects']}
"""

        return report


# Example usage
quality_sla = {'max_defect_rate': 0.005}  # 0.5% max defects
qm = CoPackerQualityManager(quality_sla)

# Record inspections
qm.record_lot_inspection({
    'lot_number': 'LOT001',
    'date': '2025-01-15',
    'quantity': 10000,
    'defects': 45
})

qm.record_lot_inspection({
    'lot_number': 'LOT002',
    'date': '2025-01-22',
    'quantity': 10000,
    'defects': 52
})

print(qm.generate_quality_report())

---

成本优化

自制还是外包的经济性分析

def make_vs_buy_analysis(internal_costs, copacker_costs, annual_volume):
    """
    Analyze economics of internal production vs. co-packing

    Parameters:
    - internal_costs: dict with internal cost structure
    - copacker_costs: dict with co-packer pricing
    - annual_volume: expected annual volume

    Returns:
    - cost comparison and recommendation
    """

    # Internal production costs
    internal_fixed = internal_costs.get('fixed_costs_annual', 0)
    internal_variable = internal_costs.get('variable_cost_per_unit', 0)
    internal_total = internal_fixed + (internal_variable * annual_volume)

    # Co-packer costs
    copacker_variable = copacker_costs.get('cost_per_unit', 0)
    copacker_fixed = copacker_costs.get('annual_fees', 0)
    copacker_total = copacker_fixed + (copacker_variable * annual_volume)

    # Comparison
    savings = internal_total - copacker_total
    savings_pct = savings / internal_total * 100 if internal_total > 0 else 0

    # Break-even volume
    if internal_variable < copacker_variable:
        # Internal has lower variable cost
        breakeven = internal_fixed / (copacker_variable - internal_variable)
    else:
        # Co-packer has lower variable cost
        breakeven = (copacker_fixed - internal_fixed) / (internal_variable - copacker_variable)

    recommendation = 'Make Internal' if internal_total < copacker_total else 'Use Co-Packer'

    return {
        'internal_cost': internal_total,
        'copacker_cost': copacker_total,
        'savings_with_copacker': savings,
        'savings_pct': savings_pct,
        'breakeven_volume': max(0, breakeven),
        'recommendation': recommendation,
        'cost_per_unit_internal': internal_total / annual_volume,
        'cost_per_unit_copacker': copacker_total / annual_volume
    }


# Example
analysis = make_vs_buy_analysis(
    internal_costs={
        'fixed_costs_annual': 500000,  # Plant overhead, equipment, staff
        'variable_cost_per_unit': 3.50  # Materials, labor, utilities
    },
    copacker_costs={
        'cost_per_unit': 4.25,
        'annual_fees': 50000  # Setup, tooling, etc.
    },
    annual_volume=100000
)

print(f"Internal Cost: ${analysis['internal_cost']:,.0f}")
print(f"Co-Packer Cost: ${analysis['copacker_cost']:,.0f}")
print(f"Savings: ${analysis['savings_with_copacker']:,.0f} ({analysis['savings_pct']:.1f}%)")
print(f"Recommendation: {analysis['recommendation']}")
print(f"Break-even Volume: {analysis['breakeven_volume']:,.0f} units")

多来源采购优化

from pulp import *

def optimize_copacker_allocation(demand, copackers, constraints):
    """
    Optimize allocation of production across multiple co-packers

    Parameters:
    - demand: total demand to fulfill
    - copackers: list of co-packers with costs and capacities
    - constraints: business rules

    Returns:
    - optimal allocation
    """

    # Create problem
    prob = LpProblem("CoPacker_Allocation", LpMinimize)

    # Decision variables: volume allocated to each co-packer
    allocation = LpVariable.dicts(
        "Allocation",
        [cp['name'] for cp in copackers],
        lowBound=0,
        cat='Continuous'
    )

    # Binary variables: is co-packer used?
    used = LpVariable.dicts(
        "Used",
        [cp['name'] for cp in copackers],
        cat='Binary'
    )

    # Objective: minimize total cost
    total_cost = 0

    for cp in copackers:
        name = cp['name']
        # Variable cost
        total_cost += allocation[name] * cp['cost_per_unit']
        # Fixed cost (if used)
        total_cost += used[name] * cp['fixed_cost']

    prob += total_cost

    # Constraints

    # 1. Meet demand
    prob += lpSum([allocation[cp['name']] for cp in copackers]) >= demand

    # 2. Capacity constraints
    for cp in copackers:
        name = cp['name']
        prob += allocation[name] <= cp['capacity']

    # 3. MOQ constraints
    for cp in copackers:
        name = cp['name']
        moq = cp.get('moq', 0)
        # If used, must meet MOQ
        prob += allocation[name] >= moq * used[name]
        # If not used, allocation = 0
        prob += allocation[name] <= cp['capacity'] * used[name]

    # 4. Single sourcing preference (optional)
    if constraints.get('prefer_single_source', False):
        prob += lpSum([used[cp['name']] for cp in copackers]) <= 2

    # 5. Minimum allocation for preferred suppliers
    preferred = constraints.get('preferred_suppliers', [])
    for pref in preferred:
        min_pct = pref.get('min_allocation_pct', 0)
        prob += allocation[pref['name']] >= demand * min_pct

    # Solve
    prob.solve(PULP_CBC_CMD(msg=0))

    # Extract results
    results = {
        'status': LpStatus[prob.status],
        'total_cost': value(prob.objective),
        'allocations': []
    }

    for cp in copackers:
        name = cp['name']
        if allocation[name].varValue > 0:
            results['allocations'].append({
                'copacker': name,
                'volume': allocation[name].varValue,
                'pct_of_demand': allocation[name].varValue / demand * 100,
                'cost': allocation[name].varValue * cp['cost_per_unit'] +
                        used[name].varValue * cp['fixed_cost']
            })

    return results


# Example
copackers = [
    {
        'name': 'CoPacker_A',
        'capacity': 50000,
        'cost_per_unit': 4.20,
        'fixed_cost': 10000,
        'moq': 5000
    },
    {
        'name': 'CoPacker_B',
        'capacity': 75000,
        'cost_per_unit': 4.00,
        'fixed_cost': 15000,
        'moq': 10000
    },
    {
        'name': 'CoPacker_C',
        'capacity': 40000,
        'cost_per_unit': 4.50,
        'fixed_cost': 5000,
        'moq': 2000
    }
]

result = optimize_copacker_allocation(
    demand=60000,
    copackers=copackers,
    constraints={'prefer_single_source': False}
)

print(f"Total Cost: ${result['total_cost']:,.0f}")
for alloc in result['allocations']:
    print(f"{alloc['copacker']}: {alloc['volume']:,.0f} units ({alloc['pct_of_demand']:.1f}%)")

---

绩效管理

联合包装商评分卡

class CoPackerScorecard:
    """
    Comprehensive co-packer performance tracking
    """

    def __init__(self, copacker_name, sla_targets):
        self.copacker = copacker_name
        self.sla = sla_targets
        self.performance_data = []

    def record_performance(self, period_data):
        """Record performance for a period"""
        self.performance_data.append(period_data)

    def calculate_scorecard(self):
        """Calculate overall performance scorecard"""

        if not self.performance_data:
            return None

        df = pd.DataFrame(self.performance_data)

        scorecard = {}

        # Quality metrics
        scorecard['quality_score'] = self._score_quality(df)

        # Delivery metrics
        scorecard['delivery_score'] = self._score_delivery(df)

        # Cost metrics
        scorecard['cost_score'] = self._score_cost(df)

        # Service metrics
        scorecard['service_score'] = self._score_service(df)

        # Overall score (weighted average)
        weights = {
            'quality_score': 0.35,
            'delivery_score': 0.25,
            'cost_score': 0.25,
            'service_score': 0.15
        }

        scorecard['overall_score'] = sum(
            scorecard[metric] * weight
            for metric, weight in weights.items()
        )

        scorecard['grade'] = self._assign_grade(scorecard['overall_score'])

        return scorecard

    def _score_quality(self, df):
        """Score quality performance (0-100)"""
        avg_defect_rate = df['defect_rate'].mean()
        target_defect_rate = self.sla.get('max_defect_rate', 0.005)

        if avg_defect_rate <= target_defect_rate:
            return 100
        elif avg_defect_rate <= target_defect_rate * 2:
            return 80
        elif avg_defect_rate <= target_defect_rate * 3:
            return 60
        else:
            return 40

    def _score_delivery(self, df):
        """Score delivery performance (0-100)"""
        on_time_pct = df['on_time'].mean()
        target = self.sla.get('on_time_delivery', 0.95)

        if on_time_pct >= target:
            return 100
        elif on_time_pct >= target - 0.05:
            return 80
        elif on_time_pct >= target - 0.10:
            return 60
        else:
            return 40

    def _score_cost(self, df):
        """Score cost competitiveness (0-100)"""
        avg_cost = df['cost_per_unit'].mean()
        target_cost = self.sla.get('target_cost', avg_cost)

        variance = (avg_cost - target_cost) / target_cost

        if variance <= 0:  # Under target
            return 100
        elif variance <= 0.05:
            return 90
        elif variance <= 0.10:
            return 70
        else:
            return 50

    def _score_service(self, df):
        """Score service and responsiveness (0-100)"""
        # Composite of various service metrics
        service_score = (
            df.get('responsiveness', 80).mean() * 0.4 +
            df.get('flexibility', 80).mean() * 0.3 +
            df.get('communication', 80).mean() * 0.3
        )

        return min(100, service_score)

    def _assign_grade(self, score):
        """Assign letter grade"""
        if score >= 90:
            return 'A'
        elif score >= 80:
            return 'B'
        elif score >= 70:
            return 'C'
        elif score >= 60:
            return 'D'
        else:
            return 'F'

---

工具与技术

代包装管理软件

供应商管理：

• SAP Ariba：供应商管理与协作
• Coupa：供应商管理与采购
• Jaggaer：供应商关系管理
• Ivalua：采购与供应商管理

质量管理：

• TraceGains：供应商合规与质量
• MasterControl：质量管理系统
• Sparta Systems：质量与合规（TrackWise）
• ETQ Reliance：质量管理

合同制造平台：

• SQFI：Safe Quality Food Institute 认证
• Selerant：配方与制剂管理
• Blue Yonder：制造规划与协作
• E2open：供应链协作平台

Python 库

# Contract and supplier management
import pandas as pd
import numpy as np

# Optimization
from pulp import *
import scipy.optimize as opt

# Data visualization
import matplotlib.pyplot as plt
import seaborn as sns
import plotly.graph_objects as go

# Financial analysis
from scipy import stats
import statsmodels.api as sm

---

常见挑战与解决方案

挑战：质量不一致

问题：

• 批次间存在差异
• 缺陷率高于内部生产
• 质量争议

解决方案：

• 制定详细规格并提供经批准的样品
• 新批次生产时进行首件检验
• 进行过程质量检查
• 采用统计过程控制（SPC）
• 定期审核和流程评审
• 投资于代包装商培训

挑战：交货周期长

问题：

• 交货周期为 8-12 周
• 对需求变化响应缓慢
• 库存挑战

解决方案：

• 承诺更长期的预测
• 建立安全库存
• 协商优先处理／加急选项
• 采用多供应商采购以提高灵活性
• 考虑供应商管理库存（VMI）

挑战：最低订购量（MOQ）高

问题：

• 最低订购量高于所需数量
• 库存过剩
• 影响现金流

解决方案：

• 协商降低最低订购量（支付溢价）
• 在单次生产中合并多个 SKU
• 寻找规模较小／更灵活的代包装商
• 使用来料加工（自带材料）
• 在淡季生产备货

挑战：知识产权保护

问题：

• 配方被盗的风险
• 专有工艺暴露
• 出现竞争产品

解决方案：

• 签订有力的保密协议和合同
• 分开提供原料／预混料
• 拆分生产（使用多家代包装商）
• 定期审核
• 签订独家协议
• 申请专利保护

挑战：成本不断攀升

问题：

• 价格随时间上涨
• 隐藏费用和附加费
• 竞争力下降

解决方案：

• 锁定多年定价
• 与大宗商品价格挂钩（保持透明）
• 与其他方案进行基准比较
• 每 2-3 年进行一次询价
• 承诺采购量以获得折扣
• 监控到岸总成本

---

输出格式

代包装商评估报告

执行摘要：

• 代包装商：ABC Co-Packing Inc.
• 地点：Memphis, TN
• 产品：零食棒、格兰诺拉麦片
• 评估日期：2025 年 1 月
• 总体评分：85/100（等级：B）
• 建议：批准建立合作关系

评分详情：

类别	得分	权重	加权得分	目标	状态
质量	90	35%	31.5	>85	✓
交付	85	25%	21.25	>90	⚠
成本	80	25%	20.0	>80	✓
服务	82	15%	12.3	>80	✓
总计	85	100%	85	>80	✓

优势：

• 质量记录出色（缺陷率为 0.3%）
• 获得 SQF Level 3 认证
• 设备与技术先进
• 价格具有竞争力
• 技术实力雄厚

劣势：

• 交付表现低于目标（85%，目标为 90%）
• 应对需求激增的能力有限
• 最低订购量高于预期

建议：

1. 协商缩短交货周期并提高准时交付率
2. 要求降低初始 SKU 的最低订购量
3. 为紧急订单建立加急处理流程
4. 进行试生产（10,000 件）

---

需要提出的问题

如果需要更多背景信息：

1. 您想委托代包装哪些产品？数量是多少？
2. 为什么选择代包装，而非内部生产？
3. 您是否已有代包装商合作关系？
4. 您有哪些质量要求和认证需求？
5. 您能接受的交货周期和最低订购量是多少？
6. 您的预算和目标单位成本是多少？
7. 对地理位置有偏好吗？
8. 是否有知识产权保护方面的顾虑？

---

相关技能

• capacity-planning：用于生产能力分析
• supplier-selection：用于供应商评估框架
• supplier-risk-management：用于代工厂风险评估
• quality-management：用于质量体系和 SPC
• procurement-optimization：用于合同谈判
• inventory-optimization：用于代工厂库存规划
• master-production-scheduling：用于生产排程
• network-design：用于代工厂网络策略
• compliance-management：用于法规合规