第2191篇：企业AI基础设施建设路径——从单个项目到共享AI平台

老张2026/4/30大约 7 分钟

第2191篇：企业AI基础设施建设路径——从单个项目到共享AI平台

适读人群：负责企业AI基础设施规划的技术负责人 | 阅读时长：约18分钟 | 核心价值：掌握企业AI平台从0到1的建设路径，避免重复造轮子，建立真正的AI工程能力积累

去年我们做了一次内部统计，发现了一个让人哭笑不得的情况。

全公司六个业务团队都在做AI功能，但每个团队都独立实现了：

自己的LLM调用封装
自己的Prompt管理
自己的成本追踪
自己的内容过滤

六套重复的基础设施，维护成本翻了六倍，而且质量参差不齐——有的团队做了限流，有的没做；有的团队做了容灾，有的一挂就全挂。

这触发了我们做企业级AI基础设施（AI Platform）的决定：把这些公共能力抽取出来，由专门的平台团队维护，业务团队只需要调用接口。

企业AI平台的建设阶段

AI平台建设的三个阶段：

阶段0（当前状态，大多数企业）：
  各业务团队独立实现，功能重复，质量不齐
  
  痛点：
  - 重复造轮子，工程浪费
  - 各团队能力参差不齐（有的团队做了容灾，有的没有）
  - 公司级的AI成本无法管控
  - 最佳实践无法共享

阶段1（AI工具共享层）：
  把公共工具打包成共享库，各团队引入使用
  
  包含：
  - 统一的LLM客户端封装（含容灾/限流/成本追踪）
  - 统一的Prompt版本管理SDK
  - 统一的评估框架
  
  适合：<10人的AI工程师团队，项目数<10

阶段2（AI微服务层）：
  把共享能力做成独立服务，业务通过API调用
  
  包含：
  - AI网关（统一入口，路由/限流/鉴权）
  - 知识库服务（统一的RAG基础设施）
  - 评估服务（统一的质量评估API）
  - 成本管理服务（统一的配额管理）
  
  适合：10-50人的AI工程师团队，项目数10-50

阶段3（AI平台）：
  完整的企业AI平台，包含开发到运营的完整工具链
  
  包含：
  - 模型管理（选型、部署、版本、切换）
  - 数据管理（知识库、训练数据、评估数据）
  - 实验平台（Prompt实验、模型对比）
  - 安全合规（统一的内容过滤、审计日志）
  - 成本管理（配额分配、成本追踪）
  
  适合：>50人的AI工程师团队，企业级使用

阶段1：AI公共库设计

/**
 * 企业AI公共库核心接口
 * 
 * 这是最小可行版本：把常见的基础能力封装起来
 * 业务团队只需要依赖这个库，不需要自己实现
 */
public interface EnterpriseAIClient {
    
    /**
     * 核心对话接口
     * 
     * 封装了：限流、容灾、成本追踪、审计日志、内容过滤
     * 业务团队无需关心这些细节
     */
    AIResponse chat(AIRequest request);
    
    /**
     * 流式对话
     */
    Flux<String> chatStream(AIRequest request);
    
    /**
     * 嵌入向量生成
     */
    float[] embed(String text);
    
    /**
     * 批量嵌入
     */
    List<float[]> embedBatch(List<String> texts);
}

/**
 * 企业AI公共库实现
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class EnterpriseAIClientImpl implements EnterpriseAIClient {

    private final MultiProviderLLMRouter router;
    private final RateLimiter rateLimiter;
    private final ContentFilter contentFilter;
    private final AICostTrackingService costTracker;
    private final ImmutableAuditLogService auditLogger;

    @Override
    public AIResponse chat(AIRequest request) {
        // 1. 速率限制检查
        if (!rateLimiter.tryAcquire(request.getTeamId())) {
            throw new RateLimitExceededException(request.getTeamId());
        }
        
        // 2. 输入内容过滤
        ContentFilterResult inputFilter = contentFilter.filterInput(
            request.getUserMessage());
        if (inputFilter.isBlocked()) {
            log.warn("输入被内容过滤: teamId={}", request.getTeamId());
            throw new ContentFilteredException(inputFilter.getReason());
        }
        
        // 3. 路由并调用
        long startTime = System.currentTimeMillis();
        String rawResponse = router.callWithFailover(
            LLMRequest.from(request));
        long latencyMs = System.currentTimeMillis() - startTime;
        
        // 4. 输出内容过滤
        ContentFilterResult outputFilter = contentFilter.filterOutput(rawResponse);
        if (outputFilter.isBlocked()) {
            log.warn("输出被内容过滤: teamId={}", request.getTeamId());
            rawResponse = outputFilter.getSafeAlternative();
        }
        
        AIResponse response = AIResponse.builder()
            .content(rawResponse)
            .latencyMs(latencyMs)
            .modelUsed(router.getLastUsedModel())
            .build();
        
        // 5. 成本追踪（异步，不阻塞响应）
        CompletableFuture.runAsync(() -> costTracker.recordCost(
            CostRecord.from(request, response)));
        
        // 6. 审计日志（异步）
        CompletableFuture.runAsync(() -> auditLogger.writeLog(
            AuditLogRequest.from(request, response)));
        
        return response;
    }
}

阶段2：AI网关服务

/**
 * AI网关：企业所有LLM请求的统一入口
 * 
 * 职责：
 * - 统一鉴权（哪个团队有权限用哪个模型）
 * - 统一限流（按团队/功能的配额管理）
 * - 统一路由（根据请求特征路由到合适的模型）
 * - 统一日志（所有请求的完整记录）
 */
@RestController
@RequestMapping("/ai-gateway/v1")
@RequiredArgsConstructor
@Slf4j
public class AIGatewayController {

    private final TeamAuthorizationService authService;
    private final QuotaManagementService quotaService;
    private final RequestEnrichmentService enricher;
    private final EnterpriseAIClientImpl aiClient;

    /**
     * 统一的对话接口
     */
    @PostMapping("/chat")
    public ResponseEntity<AIGatewayResponse> chat(
            @RequestBody AIGatewayRequest request,
            @RequestHeader("X-Team-Id") String teamId,
            @RequestHeader("X-Api-Key") String apiKey) {
        
        // 鉴权
        AuthResult auth = authService.authenticate(teamId, apiKey);
        if (!auth.isAuthorized()) {
            return ResponseEntity.status(HttpStatus.FORBIDDEN)
                .body(AIGatewayResponse.error("未授权"));
        }
        
        // 配额检查
        QuotaCheckResult quota = quotaService.checkAndDeduct(
            teamId, request.getEstimatedTokens());
        if (!quota.isAvailable()) {
            return ResponseEntity.status(HttpStatus.TOO_MANY_REQUESTS)
                .body(AIGatewayResponse.quotaExceeded(quota.getResetTime()));
        }
        
        // 丰富请求（注入团队配置、默认Prompt等）
        AIRequest enrichedRequest = enricher.enrich(request, teamId, auth);
        
        // 调用
        AIResponse response = aiClient.chat(enrichedRequest);
        
        return ResponseEntity.ok(AIGatewayResponse.success(response));
    }

    /**
     * 团队配额查询
     */
    @GetMapping("/quota/{teamId}")
    public ResponseEntity<QuotaStatus> getQuotaStatus(
            @PathVariable String teamId,
            @RequestHeader("X-Api-Key") String apiKey) {
        
        if (!authService.isAdmin(apiKey)) {
            return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
        }
        
        return ResponseEntity.ok(quotaService.getStatus(teamId));
    }
}

阶段3：完整AI平台的核心组件

/**
 * AI平台能力注册表
 * 
 * 统一管理企业内所有AI能力的发现和调用
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class AICapabilityRegistry {

    private final Map<String, AICapability> capabilities = new ConcurrentHashMap<>();
    private final CapabilityRepository capabilityRepo;

    /**
     * 注册AI能力
     * 
     * 业务团队开发的AI功能可以注册到平台，供其他团队发现和复用
     */
    public void register(AICapabilityRegistration registration) {
        AICapability capability = AICapability.builder()
            .capabilityId(UUID.randomUUID().toString())
            .name(registration.getName())
            .description(registration.getDescription())
            .category(registration.getCategory())
            .ownerTeam(registration.getOwnerTeam())
            .apiEndpoint(registration.getApiEndpoint())
            .inputSchema(registration.getInputSchema())
            .outputSchema(registration.getOutputSchema())
            .version(registration.getVersion())
            .qualityScore(registration.getQualityScore())
            .registeredAt(Instant.now())
            .build();
        
        capabilities.put(capability.getCapabilityId(), capability);
        capabilityRepo.save(capability);
        
        log.info("AI能力已注册: name={}, owner={}", 
            capability.getName(), capability.getOwnerTeam());
    }

    /**
     * 发现可用的AI能力
     */
    public List<AICapability> discover(
            String category, 
            double minQualityScore) {
        
        return capabilities.values().stream()
            .filter(c -> category == null || c.getCategory().equals(category))
            .filter(c -> c.getQualityScore() >= minQualityScore)
            .sorted(Comparator.comparingDouble(AICapability::getQualityScore).reversed())
            .collect(Collectors.toList());
    }
}

企业AI平台的"黄金通道"设计

/**
 * AI黄金通道
 * 
 * 为满足条件的业务团队提供"快速上线"路径
 * 使用平台提供的标准组件，无需自己构建基础设施
 */
@Service
@RequiredArgsConstructor
public class AIGoldenPathService {

    /**
     * 从Prompt到生产的一键部署
     * 
     * 业务团队只需要提供：
     * 1. System Prompt
     * 2. 功能描述
     * 3. 测试用例
     * 
     * 平台自动处理：
     * - 评估测试
     * - 内容过滤配置
     * - 监控告警配置
     * - 成本配额分配
     * - 生产部署
     */
    public GoldenPathDeployment deployFromPrompt(GoldenPathRequest request) {
        log.info("黄金通道部署请求: team={}, feature={}", 
            request.getTeamId(), request.getFeatureName());
        
        // 1. 自动评估
        EvaluationResult eval = runAutoEvaluation(
            request.getSystemPrompt(), request.getTestCases());
        
        if (!eval.meetsQualityBar()) {
            throw new QualityGateFailedException(
                "自动评估未达标，请优化Prompt后重试", eval);
        }
        
        // 2. 自动配置内容过滤
        ContentFilterConfig filterConfig = configureContentFilter(
            request.getBusinessDomain());
        
        // 3. 分配成本配额
        QuotaAllocation quota = allocateQuota(
            request.getTeamId(), 
            request.getExpectedMonthlyQPS());
        
        // 4. 创建监控告警
        MonitoringConfig monitoring = createMonitoringConfig(
            request.getFeatureName(), request.getTeamId());
        
        // 5. 部署
        String featureId = deployFeature(
            request, filterConfig, quota, monitoring);
        
        return GoldenPathDeployment.builder()
            .featureId(featureId)
            .apiEndpoint("/ai-gateway/v1/features/" + featureId)
            .quotaPerMonth(quota.getMonthlyTokens())
            .dashboardUrl("/platform/features/" + featureId)
            .build();
    }
}

平台建设的实际路径

企业AI平台建设时间线（参考）：

第1-2个月：打基础
  - 实现统一的LLM客户端封装（含容灾/限流/成本追踪）
  - 推广到2-3个内部团队使用
  - 根据反馈迭代
  
  关键成果：消除各团队重复实现基础功能

第3-4个月：建立核心服务
  - 部署AI网关服务
  - 建立统一的Prompt版本管理
  - 实现基础的成本看板
  
  关键成果：全公司AI成本可见、可控

第5-6个月：质量与合规
  - 建立统一的评估框架
  - 实现内容过滤服务
  - 建立审计日志基础设施
  
  关键成果：AI质量和安全合规有基础保障

第7-9个月：能力沉淀
  - 建立AI能力注册表
  - 实现黄金通道部署流程
  - 建立知识共享机制
  
  关键成果：AI能力开始在团队间复用

核心洞察：平台是为业务团队服务的，不是为了标准化而标准化

建设企业AI平台最容易犯的错误，是把它变成"强制使用的标准化工具"，而不是"让业务团队更高效的加速器"。

如果平台让业务团队觉得"用平台比自己做更麻烦"，那平台就失败了。

几个建设原则：

从减少摩擦开始，而不是从强制统一开始。让最常见的任务（调用LLM、追踪成本）变得极其简单，业务团队自然会用。
内部客户思维。对待业务团队就像对待外部客户——他们是平台的用户，平台要关注他们的体验和需求。
渐进建设，快速交付价值。不要等平台"完善了"才推出去。每个月都应该有具体的功能让业务团队感受到价值。
度量采用率。如果平台没有人用，功能再多也没有意义。定期看有多少团队、多少功能在使用平台，这是最诚实的成功指标。

AI平台不是技术荣誉工程，是组织AI工程能力的载体。建好了，它会让每个业务团队的AI效率倍增；建不好，它会成为一个没人用的基础设施负担。