企业 AI 应用采购 vs 自建：短期和长期的成本决策框架
一、买来的 AI 客服系统，用了半年发现根本调不了 prompt
很多企业在 AI 应用采购上踩过同样的坑：厂商 Demo 演示时效果很好（因为用的是厂商准备好的示例场景），部署到自己的业务后效果大打折扣——因为数据格式不同、业务流程不匹配、定制化需求无法满足。这时候才意识到：买的系统只提供有限的配置选项（比如调整置信度阈值），但无法修改底层的 Prompt、无法更换 Embedding 模型、无法添加自定义的 Function Calling 工具。
但反过来，完全自建也有问题：需要一个 3-5 人的 AI 团队（至少 150 万/年的成本），研发周期 6-12 个月，而且需要持续维护（模型更新、安全补丁、性能优化）。采购还是自建？这不是非黑即白的选择题，而是一个需要量化的成本决策问题。
二、采购 vs 自建的决策框架
核心是画一条"定制化需求 vs 规模效应"的曲线：
关键认知：决策不在"采购 vs 自建"的第一层，而在"哪些模块适合采购，哪些模块必须自建"的第二层。很少有企业 AI 应用需要从零到一全部自建。
三、Python 实现：采购 vs 自建的 TCO 计算器
from dataclasses import dataclass, field
from typing import List, Dict, Optional
import math
@dataclass
class CostModel:
"""成本模型"""
# 一次性投入
initial_setup_cost: float = 0 # 初始部署/开发费
# 年度运营成本
annual_license_fee: float = 0 # SaaS 年费
annual_api_cost: float = 0 # API 调用费（自建时为大模型费用）
annual_infra_cost: float = 0 # 基础设施成本
annual_personnel_cost: float = 0 # 人力成本
# 隐性成本
annual_maintenance_cost: float = 0 # 维护升级成本
integration_cost: float = 0 # 集成改造成本
# 风险成本
vendor_lockin_risk: float = 0.15 # 供应商锁定风险溢价（0-1）
customization_limit_penalty: float = 0 # 定制受限的业务损失
@dataclass
class AIScenario:
"""AI 应用场景评估"""
name: str
# 定制化评分 0-1（越高越需要定制）
customization_score: float
# 数据敏感度 0-1（越高越不能给第三方）
data_sensitivity: float
# 规模效应 0-1（越高越适合 SaaS）
scale_economy: float
# 业务关键度 0-1（越高越需要自建控制）
business_criticality: float
# 预计日活用户数
expected_dau: int = 100
# 团队 AI 能力 0-1
team_ai_capability: float = 0.3
class BuildVsBuyAnalyzer:
"""采购 vs 自建决策分析器"""
def __init__(self, project_years: int = 3):
self.project_years = project_years
self.discount_rate = 0.08 # 折现率 8%
def score_scenario(self, scenario: AIScenario) -> Dict:
"""计算场景的采购/自建倾向评分"""
# 自建倾向 = 定制化 + 敏感度 + 关键度 – 规模效应
build_score = (
scenario.customization_score * 0.35 +
scenario.data_sensitivity * 0.25 +
scenario.business_criticality * 0.25 –
scenario.scale_economy * 0.15
)
build_score = max(0, min(1, build_score + 0.5))
buy_score = 1 – build_score
recommendation = "自建"
if buy_score > 0.7:
recommendation = "采购SaaS"
elif buy_score > 0.4:
recommendation = "混合方案（采购基础+自建核心）"
return {
'scenario': scenario.name,
'build_score': build_score,
'buy_score': buy_score,
'recommendation': recommendation,
}
def calculate_buy_tco(
self, scenario: AIScenario
) -> Dict:
"""计算采购方案的 3 年 TCO"""
# SaaS 年费估算（基于 DAU）
annual_license = scenario.expected_dau * 120 # 每人年120元
# 集成成本
integration = 50000 * (1 – scenario.scale_economy)
# 定制受限的隐性损失
custom_penalty = (
scenario.customization_score *
annual_license * 1.5
)
model = CostModel(
initial_setup_cost=10000,
annual_license_fee=annual_license,
integration_cost=integration,
customization_limit_penalty=custom_penalty,
vendor_lockin_risk=0.15,
)
return self._compute_tco(model, "采购SaaS")
def calculate_build_tco(
self, scenario: AIScenario
) -> Dict:
"""计算自建方案的 3 年 TCO"""
# 开发团队成本：2个后端 + 1个AI工程师
annual_personnel = 600000 * 2 + 800000 * 1 # 200 万/年
# 大模型 API 成本
# 假设每次调用 0.01 元，每人每天 20 次
annual_api = (
scenario.expected_dau * 20 * 365 * 0.01
)
# 基础设施
annual_infra = 120000 # GPU 服务器 + 云服务
# 初始开发周期
dev_months = 6 + 6 * (1 – scenario.team_ai_capability)
initial_dev = annual_personnel * (dev_months / 12)
# 维护成本（20% 的人力）
maintenance = annual_personnel * 0.2
model = CostModel(
initial_setup_cost=initial_dev,
annual_api_cost=annual_api,
annual_infra_cost=annual_infra,
annual_personnel_cost=annual_personnel,
annual_maintenance_cost=maintenance,
)
return self._compute_tco(model, "自建")
def _compute_tco(self, model: CostModel, label: str) -> Dict:
"""计算总拥有成本"""
total = model.initial_setup_cost + model.integration_cost
for year in range(1, self.project_years + 1):
annual = (
model.annual_license_fee +
model.annual_api_cost +
model.annual_infra_cost +
model.annual_personnel_cost +
model.annual_maintenance_cost +
model.customization_limit_penalty
)
# 折现
discounted = annual / ((1 + self.discount_rate) ** year)
total += discounted
# 供应商锁定风险
total *= (1 + model.vendor_lockin_risk)
yearly_avg = total / self.project_years
return {
'type': label,
'initial_investment': model.initial_setup_cost,
'total_3year_tco': round(total, 2),
'annual_average': round(yearly_avg, 2),
'breakdown': {
'personnel': model.annual_personnel_cost,
'api': model.annual_api_cost,
'license': model.annual_license_fee,
'infra': model.annual_infra_cost,
}
}
def full_analysis(self, scenario: AIScenario) -> Dict:
"""完整的采购 vs 自建决策分析"""
scores = self.score_scenario(scenario)
buy_tco = self.calculate_buy_tco(scenario)
build_tco = self.calculate_build_tco(scenario)
tco_diff = buy_tco['total_3year_tco'] – build_tco['total_3year_tco']
tco_winner = "采购" if tco_diff < 0 else "自建"
print(f"=== {scenario.name} 采购 vs 自建分析 ===")
print(f"\\n[场景评分]")
print(f" 自建倾向分: {scores['build_score']:.2f}")
print(f" 采购倾向分: {scores['buy_score']:.2f}")
print(f" 建议: {scores['recommendation']}")
print(f"\\n[3年 TCO 对比]")
print(f" 采购方案: ¥{buy_tco['total_3year_tco']:,.0f}")
print(f" 自建方案: ¥{build_tco['total_3year_tco']:,.0f}")
print(f" 差额: ¥{abs(tco_diff):,.0f} ({tco_winner}更经济)")
print(f"\\n[年度均摊]")
print(f" 采购: ¥{buy_tco['annual_average']:,.0f}/年")
print(f" 自建: ¥{build_tco['annual_average']:,.0f}/年")
return {
'scores': scores,
'buy_tco': buy_tco,
'build_tco': build_tco,
'tco_diff': tco_diff,
'tco_winner': tco_winner,
}
# 使用示例
def demo():
analyzer = BuildVsBuyAnalyzer(project_years=3)
# 场景1：智能客服（标准化场景）
customer_service = AIScenario(
name="智能客服",
customization_score=0.3,
data_sensitivity=0.4,
scale_economy=0.9,
business_criticality=0.5,
expected_dau=1000,
)
# 场景2：内部数据智能分析（定制化场景）
data_analysis = AIScenario(
name="内部数据智能分析",
customization_score=0.9,
data_sensitivity=0.95,
scale_economy=0.2,
business_criticality=0.85,
expected_dau=50,
)
analyzer.full_analysis(customer_service)
print("\\n" + "="*50 + "\\n")
analyzer.full_analysis(data_analysis)
if __name__ == "__main__":
demo()
四、边界分析与 Trade-offs
隐性成本往往被忽略：采购看似便宜（年费 20 万），但集成到企业系统可能花掉 50 万（API 适配、数据迁移、权限对接、员工培训）。自建看似贵（年投入 200 万），但产出的代码和能力属于公司，可以在第 2、3 个项目上复用，边际成本递减。TCO 计算时一定要把"可复用性"折算进去。
供应商锁定的真实代价：一旦某 SaaS 产品的 API、数据格式、用户入口和企业的其他系统深度绑定，换供应商的成本可能超过当年的采购费。避免锁定的方法：合同阶段就谈好数据导出格式（必须支持标准 SQL/JSON 导出），以及 API 对接标准（必须基于 RESTful + OAuth2）。
渐进式策略：不建议全量采购或全量自建。先采购 SaaS 做快速验证（3 个月），如果验证通过且规模起量（DAU > 1000 或日调用 > 10 万次），评估自建方案。此时你已经用 SaaS 积累了真实的使用数据和用户反馈，自建时可以避开之前踩过的坑。
安全合规的反向约束：金融、医疗行业的数据合规要求可能让"采购"变得不可行——数据不能出企业内网，第三方 SaaS 无法满足合规要求。这种情况下技术评估退居次位，合规是首要约束条件。
五、总结
企业 AI 应用的采购 vs 自建决策不是技术问题，是经济问题。核心决策公式：TCO（3年总拥有成本）= 一次性投入 + 年化运营成本 ÷ 折现率 + 隐性成本（锁定风险 + 定制损失）。建议用两个打分维度构成矩阵：业务关键度 × 数据敏感度（得分高的 → 自建）、标准化程度 × 团队 AI 能力（得分低的 → 采购）。实际操作中，混合方案（SaaS 做前端体验，自建做内核定制）往往是最优解——半年内用 SaaS 验证 PMF，半年后自建核心模块，SaaS 降级为备用方案。
