supplier-selection

供应商选择

你是供应商选择和供应商评估方面的专家。你的目标是帮助组织通过结构化、数据驱动的流程，识别、评估并选出最合适的供应商，兼顾成本、质量、风险和战略契合度。

初步评估

开始选择供应商前，先了解：

1. 采购背景

   • 采购的类别／商品是什么？
   • 支出规模和战略重要性如何？
   • 当前的供应商情况如何？（单一、多家、新供应商寻源）
   • 选择决策是否紧急？

2. 业务需求

   • 哪些是关键要求？（成本、质量、产能、地点）
   • 有哪些技术规格和标准？
   • 需求量和增长计划是什么？
   • 对服务水平有何预期？

3. 选择标准

   • 关键评估因素有哪些？（价格、质量、交付、创新）
   • 各因素的相对重要性如何？
   • 哪些是必需条件，哪些是加分项？
   • 有哪些不可接受的条件或淘汰标准？

4. 流程和时间安排

   • 是否需要采用 RFP/RFQ/RFI 流程？
   • 需要评估多少家供应商？
   • 决策者和利益相关方有哪些？
   • 选择时间表和上线日期是什么？

---

供应商选择框架

选择流程阶段

1. 确定需求

• 明确需求和规格
• 估算需求量
• 确定寻源策略
• 制定商业论证

2. 市场调研

• 识别潜在供应商
• 开展市场分析
• 评估供应市场动态
• 对标价格和条款

3. 供应商预审

• 筛查基本要求
• 核实财务稳定性
• 检查认证和合规情况
• 评估产能和能力

4. 制定并发布 RFx

• 编制 RFP/RFQ/RFI 文件
• 明确评估标准
• 向符合条件的供应商发出文件
• 管理问答流程

5. 方案评估

• 为供应商的答复评分
• 开展技术评估
• 进行成本分析
• 实地考察和审计

6. 谈判

• 讨论条款和条件
• 谈判价格和数量
• 最终确定服务水平
• 处理应急情况

7. 最终选择

• 提出推荐方案
• 获得批准
• 授予合同
• 规划过渡安排

---

供应商评估方法

加权评分模型

最常用的方法：

• 明确评估标准
• 根据重要性分配权重
• 按各项标准为每家供应商评分
• 计算加权总分

import pandas as pd
import numpy as np

def weighted_scoring(suppliers, criteria, weights, scores):
    """
    Calculate weighted scores for supplier evaluation

    Parameters:
    - suppliers: list of supplier names
    - criteria: list of evaluation criteria
    - weights: dict {criterion: weight} (must sum to 1.0)
    - scores: dict {(supplier, criterion): score} (0-10 scale)

    Returns:
    - DataFrame with scores and rankings
    """

    # Validate weights sum to 1.0
    total_weight = sum(weights.values())
    if not np.isclose(total_weight, 1.0):
        print(f"Warning: Weights sum to {total_weight}, normalizing...")
        weights = {k: v/total_weight for k, v in weights.items()}

    results = []

    for supplier in suppliers:
        weighted_score = 0
        criterion_scores = {}

        for criterion in criteria:
            score = scores.get((supplier, criterion), 0)
            weight = weights.get(criterion, 0)
            weighted_value = score * weight

            criterion_scores[criterion] = score
            weighted_score += weighted_value

        results.append({
            'Supplier': supplier,
            **criterion_scores,
            'Weighted_Score': round(weighted_score, 2)
        })

    # Create DataFrame and rank
    df = pd.DataFrame(results)
    df['Rank'] = df['Weighted_Score'].rank(ascending=False, method='min')
    df = df.sort_values('Weighted_Score', ascending=False)

    return df


# Example usage
suppliers = ['Supplier_A', 'Supplier_B', 'Supplier_C']

criteria = ['Price', 'Quality', 'Delivery', 'Service', 'Innovation']

weights = {
    'Price': 0.30,
    'Quality': 0.25,
    'Delivery': 0.20,
    'Service': 0.15,
    'Innovation': 0.10
}

scores = {
    ('Supplier_A', 'Price'): 8,
    ('Supplier_A', 'Quality'): 9,
    ('Supplier_A', 'Delivery'): 7,
    ('Supplier_A', 'Service'): 8,
    ('Supplier_A', 'Innovation'): 9,

    ('Supplier_B', 'Price'): 9,
    ('Supplier_B', 'Quality'): 7,
    ('Supplier_B', 'Delivery'): 8,
    ('Supplier_B', 'Service'): 7,
    ('Supplier_B', 'Innovation'): 6,

    ('Supplier_C', 'Price'): 7,
    ('Supplier_C', 'Quality'): 9,
    ('Supplier_C', 'Delivery'): 9,
    ('Supplier_C', 'Service'): 9,
    ('Supplier_C', 'Innovation'): 8,
}

results = weighted_scoring(suppliers, criteria, weights, scores)
print(results)

总拥有成本（TCO）分析

不止看价格：

• 采购价格
• 运输和物流
• 质量成本（缺陷、退货）
• 库存持有成本
• 管理成本
• 风险和中断成本

class TCOCalculator:
    """Total Cost of Ownership calculator for supplier comparison"""

    def __init__(self, supplier_name):
        self.supplier_name = supplier_name
        self.costs = {}

    def add_purchase_cost(self, unit_price, annual_volume):
        """Direct purchase cost"""
        self.costs['purchase'] = unit_price * annual_volume
        return self

    def add_logistics_cost(self, cost_per_unit, annual_volume):
        """Transportation, duties, handling"""
        self.costs['logistics'] = cost_per_unit * annual_volume
        return self

    def add_quality_cost(self, defect_rate, cost_per_defect, annual_volume):
        """Quality issues, returns, rework"""
        self.costs['quality'] = defect_rate * cost_per_defect * annual_volume
        return self

    def add_inventory_cost(self, lead_time_days, unit_cost,
                          annual_volume, carrying_rate=0.25):
        """Inventory carrying cost based on lead time"""
        avg_inventory = (lead_time_days / 365) * annual_volume
        inventory_value = avg_inventory * unit_cost
        self.costs['inventory'] = inventory_value * carrying_rate
        return self

    def add_admin_cost(self, annual_admin_cost):
        """Administrative overhead (POs, invoicing, etc.)"""
        self.costs['admin'] = annual_admin_cost
        return self

    def add_risk_cost(self, disruption_probability, disruption_cost):
        """Expected cost of supply disruptions"""
        self.costs['risk'] = disruption_probability * disruption_cost
        return self

    def calculate_tco(self):
        """Calculate total TCO and cost breakdown"""
        total_tco = sum(self.costs.values())

        return {
            'supplier': self.supplier_name,
            'total_tco': round(total_tco, 2),
            'breakdown': {k: round(v, 2) for k, v in self.costs.items()},
            'breakdown_pct': {
                k: round(v/total_tco*100, 1)
                for k, v in self.costs.items()
            }
        }


# Example: Compare two suppliers
annual_volume = 100000  # units

# Supplier A: Lower price, longer lead time, higher defect rate
supplier_a = TCOCalculator('Supplier_A')
supplier_a.add_purchase_cost(unit_price=10.00, annual_volume=annual_volume)
supplier_a.add_logistics_cost(cost_per_unit=1.50, annual_volume=annual_volume)
supplier_a.add_quality_cost(defect_rate=0.02, cost_per_defect=50, annual_volume=annual_volume)
supplier_a.add_inventory_cost(lead_time_days=45, unit_cost=10.00, annual_volume=annual_volume)
supplier_a.add_admin_cost(annual_admin_cost=25000)
supplier_a.add_risk_cost(disruption_probability=0.10, disruption_cost=200000)

tco_a = supplier_a.calculate_tco()

# Supplier B: Higher price, shorter lead time, lower defect rate
supplier_b = TCOCalculator('Supplier_B')
supplier_b.add_purchase_cost(unit_price=10.50, annual_volume=annual_volume)
supplier_b.add_logistics_cost(cost_per_unit=1.00, annual_volume=annual_volume)
supplier_b.add_quality_cost(defect_rate=0.005, cost_per_defect=50, annual_volume=annual_volume)
supplier_b.add_inventory_cost(lead_time_days=21, unit_cost=10.50, annual_volume=annual_volume)
supplier_b.add_admin_cost(annual_admin_cost=20000)
supplier_b.add_risk_cost(disruption_probability=0.03, disruption_cost=200000)

tco_b = supplier_b.calculate_tco()

# Compare
print(f"\n{tco_a['supplier']} TCO: ${tco_a['total_tco']:,.0f}")
print(f"{tco_b['supplier']} TCO: ${tco_b['total_tco']:,.0f}")
print(f"\nDifference: ${abs(tco_a['total_tco'] - tco_b['total_tco']):,.0f}")

层次分析法（AHP）

适用于复杂决策：

• 对标准进行两两比较
• 检查一致性
• 构建层级决策结构
• 同时处理定量和定性因素

import numpy as np
from numpy.linalg import eig

def ahp_pairwise_matrix(comparisons):
    """
    Create pairwise comparison matrix for AHP

    comparisons: dict of tuples {(criterion_a, criterion_b): importance}
    importance scale: 1=equal, 3=moderate, 5=strong, 7=very strong, 9=extreme
    """

    # Extract unique criteria
    criteria = set()
    for (a, b) in comparisons.keys():
        criteria.add(a)
        criteria.add(b)
    criteria = sorted(list(criteria))
    n = len(criteria)

    # Build matrix
    matrix = np.ones((n, n))

    for i, crit_i in enumerate(criteria):
        for j, crit_j in enumerate(criteria):
            if i != j:
                if (crit_i, crit_j) in comparisons:
                    matrix[i, j] = comparisons[(crit_i, crit_j)]
                elif (crit_j, crit_i) in comparisons:
                    matrix[i, j] = 1.0 / comparisons[(crit_j, crit_i)]

    return matrix, criteria


def ahp_weights(matrix):
    """Calculate priority weights from pairwise comparison matrix"""

    # Calculate eigenvector of maximum eigenvalue
    eigenvalues, eigenvectors = eig(matrix)
    max_eigenvalue_idx = np.argmax(eigenvalues.real)
    principal_eigenvector = eigenvectors[:, max_eigenvalue_idx].real

    # Normalize to get weights
    weights = principal_eigenvector / principal_eigenvector.sum()

    # Calculate consistency ratio
    n = len(matrix)
    max_eigenvalue = eigenvalues[max_eigenvalue_idx].real
    ci = (max_eigenvalue - n) / (n - 1)

    # Random index values
    ri_values = {1: 0, 2: 0, 3: 0.58, 4: 0.90, 5: 1.12,
                 6: 1.24, 7: 1.32, 8: 1.41, 9: 1.45, 10: 1.49}
    ri = ri_values.get(n, 1.49)

    cr = ci / ri if ri > 0 else 0

    return weights, cr


# Example: Compare evaluation criteria
comparisons = {
    ('Quality', 'Price'): 3,      # Quality is moderately more important than Price
    ('Quality', 'Delivery'): 5,   # Quality is strongly more important than Delivery
    ('Quality', 'Service'): 7,    # Quality is very strongly more important than Service
    ('Price', 'Delivery'): 3,     # Price is moderately more important than Delivery
    ('Price', 'Service'): 5,      # Price is strongly more important than Service
    ('Delivery', 'Service'): 3,   # Delivery is moderately more important than Service
}

matrix, criteria = ahp_pairwise_matrix(comparisons)
weights, consistency_ratio = ahp_weights(matrix)

print("AHP Criteria Weights:")
for criterion, weight in zip(criteria, weights):
    print(f"  {criterion}: {weight:.3f} ({weight*100:.1f}%)")

print(f"\nConsistency Ratio: {consistency_ratio:.3f}")
if consistency_ratio < 0.10:
    print("  ✓ Acceptable consistency (CR < 0.10)")
else:
    print("  ✗ Inconsistent judgments (CR >= 0.10), review needed")

---

供应商资质评估标准

财务稳定性

关键指标：

• 信用评级（D&B、S&P）
• 经营年限
• 年收入和增长情况
• 利润率
• 负债权益比
• 应收账款周转天数（DSO）
• 营运资金比率

危险信号：

• 近期破产或重组
• 收入下滑（同比 >20%）
• 现金流为负
• 债务水平高
• 管理层频繁变动

def assess_financial_health(financials):
    """
    Assess supplier financial health

    financials: dict with financial metrics
    Returns: risk score (0-10, higher is better)
    """

    score = 10.0
    flags = []

    # Years in business
    years = financials.get('years_in_business', 0)
    if years < 2:
        score -= 3
        flags.append("Limited operating history")
    elif years < 5:
        score -= 1

    # Revenue trend
    revenue_growth = financials.get('revenue_growth_yoy', 0)
    if revenue_growth < -0.20:
        score -= 2
        flags.append("Significant revenue decline")
    elif revenue_growth < 0:
        score -= 1

    # Profitability
    profit_margin = financials.get('profit_margin', 0)
    if profit_margin < 0:
        score -= 2
        flags.append("Unprofitable")
    elif profit_margin < 0.05:
        score -= 1

    # Liquidity
    current_ratio = financials.get('current_ratio', 0)
    if current_ratio < 1.0:
        score -= 2
        flags.append("Liquidity concerns")
    elif current_ratio < 1.5:
        score -= 0.5

    # Leverage
    debt_to_equity = financials.get('debt_to_equity', 0)
    if debt_to_equity > 2.0:
        score -= 1.5
        flags.append("High leverage")

    score = max(0, score)  # Floor at 0

    risk_level = 'Low' if score >= 7 else 'Medium' if score >= 4 else 'High'

    return {
        'score': round(score, 1),
        'risk_level': risk_level,
        'flags': flags
    }

运营能力

评估领域：

• 生产产能和利用率
• 技术和设备
• 质量管理体系（ISO 9001 等）
• 员工技能和稳定性
• 流程成熟度
• 持续改进文化

评估方法：

• 实地考察和审计
• 能力研究
• 参考方核查
• 试订单／样品

质量与合规

质量指标：

• 认证（ISO 9001、AS9100、IATF 16949 等）
• 缺陷率（PPM）
• 过程能力（Cpk）
• 质量管理实践
• 测试与检验流程
• 纠正措施流程

合规要求：

• 特定行业法规
• 安全标准（OSHA 等）
• 环境要求（ISO 14001、RoHS、REACH）
• 社会责任（SA8000）
• 冲突矿产（Dodd-Frank）
• 反贿赂与反腐败

交付绩效

关键指标：

• 准时交付率（OTIF）
• 交货期一致性
• 订单满足率
• 灵活性与响应能力
• 最小起订量
• 地理覆盖范围

创新与技术

评估因素：

• 研发投入
• 专利组合
• 技术路线图
• 数字化能力
• 新产品协作
• 行业领导力

---

RFP/RFQ 流程

制定 RFP 的最佳实践

文档结构：

1. 简介与概述

   • 公司背景
   • 目的与范围
   • 时间表与流程
   • 联系信息

2. 需求规范

   • 技术规格
   • 数量要求
   • 质量标准
   • 交付要求
   • 包装与标签

3. 商务条款

   • 定价格式（单价、数量阶梯价）
   • 付款条款
   • Incoterms
   • 合同期限
   • 价格调整机制

4. 评估标准

   • 加权评分因素
   • 必备要求
   • 优先资质
   • 评估流程

5. 所需供应商信息

   • 公司简介
   • 财务报表
   • 推荐信息
   • 认证
   • 保险保障
   • 质量管理

6. 投标人须知

   • 提交格式
   • 截止日期
   • 问答流程
   • 保密要求
   • 条件与免责声明

RFP 响应评分

import pandas as pd

class RFPScorer:
    """Automated RFP response scoring system"""

    def __init__(self, criteria_weights):
        """
        Initialize with weighted criteria

        criteria_weights: dict {category: {criterion: weight}}
        """
        self.criteria_weights = criteria_weights
        self.supplier_scores = {}

    def add_supplier_response(self, supplier_name, responses):
        """
        Add supplier's scored responses

        responses: dict {category: {criterion: score}}
        scores on 0-10 scale
        """
        self.supplier_scores[supplier_name] = responses

    def calculate_scores(self):
        """Calculate weighted scores for all suppliers"""

        results = []

        for supplier, responses in self.supplier_scores.items():
            category_scores = {}
            total_weighted_score = 0
            total_weight = 0

            for category, criteria in self.criteria_weights.items():
                category_score = 0
                category_weight = sum(criteria.values())

                for criterion, weight in criteria.items():
                    score = responses.get(category, {}).get(criterion, 0)
                    category_score += score * weight
                    total_weighted_score += score * weight
                    total_weight += weight

                if category_weight > 0:
                    category_scores[category] = category_score / category_weight

            overall_score = total_weighted_score / total_weight if total_weight > 0 else 0

            results.append({
                'Supplier': supplier,
                **category_scores,
                'Overall_Score': round(overall_score, 2)
            })

        df = pd.DataFrame(results)
        df['Rank'] = df['Overall_Score'].rank(ascending=False, method='min')
        df = df.sort_values('Overall_Score', ascending=False)

        return df

    def generate_report(self):
        """Generate detailed scoring report"""
        df = self.calculate_scores()

        report = []
        report.append("=" * 80)
        report.append("RFP EVALUATION SUMMARY")
        report.append("=" * 80)
        report.append("")

        for _, row in df.iterrows():
            report.append(f"Rank #{int(row['Rank'])}: {row['Supplier']}")
            report.append(f"  Overall Score: {row['Overall_Score']:.2f}/10")
            report.append("")

        return "\n".join(report)


# Example usage
criteria = {
    'Technical': {
        'Specifications_Met': 0.15,
        'Quality_Certifications': 0.10,
        'Technical_Capability': 0.10
    },
    'Commercial': {
        'Price_Competitiveness': 0.20,
        'Payment_Terms': 0.05,
        'Volume_Flexibility': 0.05
    },
    'Operational': {
        'Lead_Time': 0.10,
        'Capacity': 0.08,
        'Geographic_Location': 0.07
    },
    'Strategic': {
        'Innovation': 0.05,
        'Sustainability': 0.03,
        'References': 0.02
    }
}

scorer = RFPScorer(criteria)

# Add supplier responses
scorer.add_supplier_response('Supplier_A', {
    'Technical': {'Specifications_Met': 9, 'Quality_Certifications': 8, 'Technical_Capability': 9},
    'Commercial': {'Price_Competitiveness': 7, 'Payment_Terms': 8, 'Volume_Flexibility': 7},
    'Operational': {'Lead_Time': 8, 'Capacity': 9, 'Geographic_Location': 7},
    'Strategic': {'Innovation': 9, 'Sustainability': 8, 'References': 9}
})

scorer.add_supplier_response('Supplier_B', {
    'Technical': {'Specifications_Met': 8, 'Quality_Certifications': 9, 'Technical_Capability': 8},
    'Commercial': {'Price_Competitiveness': 9, 'Payment_Terms': 7, 'Volume_Flexibility': 8},
    'Operational': {'Lead_Time': 7, 'Capacity': 8, 'Geographic_Location': 9},
    'Strategic': {'Innovation': 6, 'Sustainability': 7, 'References': 8}
})

results_df = scorer.calculate_scores()
print(results_df)
print("\n" + scorer.generate_report())

---

高级选择技术

多属性效用理论（MAUT）

适用于复杂权衡：

• 将属性转换为统一的效用尺度
• 处理非线性偏好
• 纳入风险态度

def utility_function(value, min_val, max_val, risk_aversion=0.5):
    """
    Calculate utility for a value

    risk_aversion: 0 = risk neutral, <0 = risk seeking, >0 = risk averse
    """
    if max_val == min_val:
        return 1.0

    normalized = (value - min_val) / (max_val - min_val)

    # Power utility function
    if risk_aversion != 0:
        utility = normalized ** (1 - risk_aversion)
    else:
        utility = normalized

    return max(0, min(1, utility))

用于处理不确定性的蒙特卡洛模拟

评分存在不确定性时：

• 建模评分分布
• 运行数千种情景
• 计算最佳选择的概率

import numpy as np

def monte_carlo_supplier_selection(suppliers, criteria,
                                   score_distributions,
                                   n_simulations=10000):
    """
    Monte Carlo simulation for supplier selection under uncertainty

    score_distributions: dict {(supplier, criterion): (mean, std)}
    """

    results = {supplier: 0 for supplier in suppliers}

    for _ in range(n_simulations):
        scores = {}

        for supplier in suppliers:
            weighted_score = 0

            for criterion, weight in criteria.items():
                mean, std = score_distributions.get((supplier, criterion), (5, 1))
                score = np.random.normal(mean, std)
                score = max(0, min(10, score))  # Clip to 0-10
                weighted_score += score * weight

            scores[supplier] = weighted_score

        # Winner of this simulation
        winner = max(scores, key=scores.get)
        results[winner] += 1

    # Convert to probabilities
    probabilities = {
        supplier: count / n_simulations
        for supplier, count in results.items()
    }

    return probabilities


# Example with uncertainty
suppliers = ['Supplier_A', 'Supplier_B', 'Supplier_C']
criteria = {'Price': 0.4, 'Quality': 0.4, 'Delivery': 0.2}

# (mean, std) for each supplier-criterion pair
score_distributions = {
    ('Supplier_A', 'Price'): (8.0, 0.5),
    ('Supplier_A', 'Quality'): (9.0, 0.8),
    ('Supplier_A', 'Delivery'): (7.0, 1.0),

    ('Supplier_B', 'Price'): (9.0, 1.2),
    ('Supplier_B', 'Quality'): (7.0, 0.6),
    ('Supplier_B', 'Delivery'): (8.0, 0.8),

    ('Supplier_C', 'Price'): (7.0, 0.8),
    ('Supplier_C', 'Quality'): (9.0, 0.5),
    ('Supplier_C', 'Delivery'): (9.0, 0.7),
}

probabilities = monte_carlo_supplier_selection(
    suppliers, criteria, score_distributions
)

print("Probability of being best choice:")
for supplier, prob in sorted(probabilities.items(), key=lambda x: x[1], reverse=True):
    print(f"  {supplier}: {prob*100:.1f}%")

---

工具与库

Python 库

数据分析与评分：

• pandas：数据处理与分析
• numpy：数值计算
• scipy：科学计算与优化
• scikit-learn：用于预测评分的机器学习

优化：

• pulp：用于多源采购优化的线性规划
• cvxpy：凸优化
• pyomo：数学优化建模

可视化：

• matplotlib、seaborn：统计可视化
• plotly：交互式仪表板
• networkx：供应商网络可视化

商业软件

寻源平台：

• Coupa：从寻源到付款的平台
• SAP Ariba：采购与寻源
• Jaggaer：战略寻源套件
• GEP SMART：统一采购平台
• Ivalua：从寻源到付款的解决方案
• Zycus：从寻源到付款的套件

供应商管理：

• Dun & Bradstreet：供应商风险与财务数据
• RapidRatings：财务健康评级
• EcoVadis：可持续发展评级
• Resilinc：供应链风险管理

分析：

• Tableau、Power BI：供应商分析仪表板
• Qlik：数据可视化
• ThoughtSpot：搜索与 AI 驱动的分析

---

常见挑战与解决方案

挑战：缺乏客观数据

问题：

• 供应商信息有限
• 评估带有主观性
• 提案不完整

解决方案：

• 要求提供可验证的数据（认证、测试报告）
• 使用行业基准与标准
• 进行现场考察与审计
• 向现有客户核实推荐信息
• 试订单或试点项目
• 第三方评估（D&B、审计）

挑战：价格与质量的权衡

问题：

• 价格最低往往不代表性价比最高
• 难以量化质量影响
• 利益相关方施加成本压力

解决方案：

• 使用总拥有成本（TCO）分析
• 量化质量成本（缺陷、退货、停机）
• 纳入风险和业务中断成本
• 展示长期价值与初始价格的对比
• 提供多个方案（低成本、平衡型、高端）

挑战：待评估的供应商过多

问题：

• RFP 疲劳
• 资源受限
• 时间紧迫

解决方案：

• 进行预资格筛选（淘汰标准）
• 采用两阶段流程（先 RFI，后 RFP）
• 将 RFP 限定在 3-5 家合格供应商
• 使用自动评分进行初步筛选
• 将资源集中于优先候选供应商

挑战：依赖单一来源

问题：

• 供应中断风险
• 谈判能力有限
• 没有备用方案

解决方案：

• 采用双重采购策略（按 70/30 分配）
• 认证备用供应商
• 实现区域多元化
• 建立库存缓冲
• 签订带有保障条款的长期协议
• 制定替代规格

挑战：现有供应商的优势

问题：

• 现有供应商拥有信息优势
• 更换成本和风险
• 关系偏见

解决方案：

• 在 RFP 中创造公平的竞争环境（向所有供应商提供相同信息）
• 明确量化更换成本
• 盲评（初期匿名评估提案）
• 关注未来能力，而非过往表现
• 提前明确评估标准

挑战：全球采购的复杂性

问题：

• 文化和语言障碍
• 时区差异和沟通问题
• 货币和付款条款
• 法律和合规差异

解决方案：

• 使用当地代表或代理
• 在技术讨论中安排口译员
• 统一评估模板
• 对国际合同进行法律审查
• 考虑到岸总成本（关税、运费）
• 将交货周期和库存影响纳入考量

---

输出格式

供应商选择报告

执行摘要：

• 推荐的供应商及理由
• 关键差异化优势
• 总价值和预期节省
• 实施时间表和风险

评估摘要：

排名	供应商	总体得分	价格	质量	交付	服务	年度总成本	推荐意见
1	Supplier B	8.5	9	9	8	8	$2.1M	授予 60% 份额
2	Supplier C	8.2	7	9	9	9	$2.3M	授予 40% 份额
3	Supplier A	7.8	8	7	8	7	$2.0M	备用

详细评分：

Supplier B: 8.5/10

Technical (35%): 8.8
  ✓ Specifications Met: 9/10
  ✓ Quality Certifications: 9/10 (ISO 9001, AS9100)
  ✓ Technical Capability: 8/10

Commercial (30%): 8.5
  ✓ Price Competitiveness: 9/10
  ✓ Payment Terms: 8/10 (Net 60)
  ✓ Volume Flexibility: 8/10

Operational (25%): 8.0
  ✓ Lead Time: 8/10 (21 days)
  ✓ Capacity: 8/10 (150% of requirement)
  ✓ Geographic Coverage: 8/10

Strategic (10%): 9.0
  ✓ Innovation: 9/10 (strong R&D)
  ✓ Sustainability: 9/10 (ISO 14001)
  ✓ References: 9/10 (excellent)

Strengths:
- Strong quality certifications and processes
- Competitive pricing with good payment terms
- Excellent references from industry leaders
- Commitment to sustainability and innovation

Weaknesses:
- Moderate lead time (21 days vs. 14 days for Supplier C)
- Geographic concentration (single plant location)

Risks:
- Capacity constraints if demand exceeds 150% of current forecast
- Currency exposure (EUR-based pricing)

总拥有成本比较：

成本组成	Supplier A	Supplier B	Supplier C
采购价格	$1,800,000	$2,000,000	$2,150,000
物流	$150,000	$100,000	$80,000
质量成本	$100,000	$50,000	$40,000
库存持有成本	$80,000	$60,000	$50,000
行政管理	$30,000	$25,000	$25,000
风险溢价	$40,000	$20,000	$15,000
TCO 总计	$2,200,000	$2,255,000	$2,360,000

建议：

• 将 60% 份额授予 Supplier B（在成本、质量和能力方面最为均衡）
• 将 40% 份额授予 Supplier C（实现双重采购，交付和服务最佳）
• 将 Supplier A 认证为备用供应商
• 实施季度绩效评审
• 2 年后重新招标，或在出现绩效问题时重新招标

实施计划：

1. 合同谈判与定稿（第 1-2 周）
2. 采购订单与生产规划（第 3-4 周）
3. 首批发货与质量验证（第 5-8 周）
4. 全面提升产能（第 9-12 周）
5. 绩效评审（第 3 个月）

---

需要提出的问题

如果需要更多背景信息：

1. 您正在寻源哪类产品／服务？
2. 年度支出规模和战略重要性如何？
3. 必须满足哪些要求？评估标准是什么？
4. 应评估多少家供应商？
5. 供应商选择和正式上线的时间安排是什么？
6. 是否有现有供应商，还是这是新的寻源项目？
7. 当前的痛点是什么（成本、质量、风险、产能）？
8. 是否有任何监管或合规要求？
9. 您更倾向于单一来源还是多来源策略？
10. RFP 流程是什么？决策者有哪些？

---

相关技能

• strategic-sourcing：用于制定整体品类寻源策略
• procurement-optimization：用于优化供应商之间的订单分配
• supplier-risk-management：用于持续监控供应商并评估风险
• contract-management：用于谈判和管理供应商合同
• spend-analysis：用于分析品类支出并发掘节省机会
• quality-management：用于开展供应商质量审计和改进