企业级 AI 编程｜大模型结合业务系统工程化开发实训

# deployment.yaml 片段
containers:
  - name: main-app
    image: risk-agent:latest
    env:
      - name: PROMPT_SERVICE_URL
        value: "http://localhost:8081"
  - name: prompt-sidecar
    image: prompt-engine:latest
    volumeMounts:
      - name: prompt-config
        mountPath: /etc/prompts
    # 支持热加载：监听配置中心Nacos变化

// 敏感信息脱敏过滤器
@Component
public class SensitiveDataFilter {
    
    private static final Pattern ID_CARD = Pattern.compile("\\d{17}[\\dXx]");
    private static final Pattern PHONE = Pattern.compile("1[3-9]\\d{9}");
    
    public String sanitize(String input) {
        String sanitized = ID_CARD.matcher(input).replaceAll("***************");
        sanitized = PHONE.matcher(sanitized).replaceAll("***********");
        // 保留企业名称、行业代码等非敏感信息
        return sanitized;
    }
    
    // 且所有日志输出前必须经过此过滤器
}

@Service
public class EnterpriseRetrievalPipeline {

    // 第一级：意图识别（小模型，5ms内完成）
    @Autowired
    private IntentClassifier tinyClassifier; // 基于BERT-tiny
    
    // 第二级：多路召回
    public SearchResult retrieve(Query query) {
        Intent intent = tinyClassifier.predict(query.getText());
        
        CompletableFuture<List<Doc>> vectorFuture = 
            CompletableFuture.supplyAsync(() -> vectorStore.search(query.getEmbedding(), 20));
        CompletableFuture<List<Doc>> keywordFuture = 
            CompletableFuture.supplyAsync(() -> esService.bm25(query.getText(), 20));
        CompletableFuture<List<GraphNode>> graphFuture = 
            CompletableFuture.supplyAsync(() -> graphService.traverse(query.getEntities()));
        
        CompletableFuture.allOf(vectorFuture, keywordFuture, graphFuture).join();
        
        // 第三级：融合与精排（Cross-Encoder）
        List<Candidate> candidates = fuse(vectorFuture.join(), keywordFuture.join(), graphFuture.join());
        return reRanker.rerank(query, candidates, 5); // 最终只返回5条
    }
}

@Component
public class RiskOrchestrator {

    public RiskReport process(CompanyInfo company) {
        // Step 1: 并行执行检索与规则
        CompletableFuture<RetrievalResult> retrieval = 
            retrievalAgent.analyze(company);
        CompletableFuture<RuleResult> rules = 
            ruleAgent.check(company);
        
        // Step 2: 汇总结果
        CompletableFuture.allOf(retrieval, rules).join();
        
        // Step 3: 仅在需要时调用昂贵的大模型
        if (rules.join().hasViolation()) {
            return reasoningAgent.deepAnalyze(
                retrieval.join(), 
                rules.join(), 
                company
            );
        } else {
            // 低风险场景：使用模板快速生成（不调LLM，节省成本）
            return templateService.generatePassReport(company);
        }
    }
}

@Component
public class SemanticCacheManager {
    
    // L1: 本地Caffeine（命中率20%，RT<1ms）
    @Cacheable(value = "local", key = "#query")
    public String getL1(String query) { return null; }
    
    // L2: Redis（命中率60%，RT<5ms）
    @Cacheable(value = "redis", key = "#query")
    public String getL2(String query) { return null; }
    
    // L3: 向量相似度缓存（命中率15%，RT<50ms）
    public String getL3(String query) {
        float[] emb = embeddingService.embed(query);
        // 在向量库中查找相似历史Query（相似度>0.95）
        List<CachedResult> similar = vectorStore.searchCache(emb, 0.95);
        if (!similar.isEmpty()) {
            return similar.get(0).getResponse();
        }
        return null; // Miss，调用真实LLM
    }
}

@SpringBootTest
public class RiskOrchestratorTest {
    
    @MockBean
    private ReasoningAgent reasoningAgent;
    
    @Test
    public void testLowRiskPassesWithoutLLM() {
        // 模拟低风险企业（负债率30%）
        CompanyInfo company = CompanyInfo.builder()
            .debtRatio(0.3)
            .industry("IT")
            .build();
        
        // 注入固定返回
        when(reasoningAgent.deepAnalyze(any(), any(), any()))
            .thenThrow(new RuntimeException("不应该被调用"));
        
        RiskReport report = orchestrator.process(company);
        
        // 验证没有触发LLM调用
        verify(reasoningAgent, never()).deepAnalyze(any(), any(), any());
        assertThat(report.getRiskLevel()).isEqualTo(RiskLevel.LOW);
    }
}

# 自动化回归脚本
def regression_test():
    golden_set = load_golden_set("risk_cases.json")
    passed = 0
    for case in golden_set:
        response = client.call(case['input'])
        # 检查关键实体是否一致
        if case['expected_risk'] == response['risk'] and \
           case['expected_regulation'] in response['citations']:
            passed += 1
    assert passed / len(golden_set) > 0.95

# JMeter 测试计划配置
- 线程数: 100 (模拟并发)
- 启动时间: 10秒
- 循环次数: 100
- 断言: 响应时间<800ms & 错误率<0.1%

@Aspect
@Component
public class LLMMonitorAspect {
    
    private final Counter llmRequestCounter = Counter.build()
        .name("llm_requests_total")
        .labelNames("model", "success")
        .help("Total LLM requests").register();
    
    private final Histogram llmLatencyHistogram = Histogram.build()
        .name("llm_latency_seconds")
        .labelNames("model")
        .buckets(0.1, 0.5, 1.0, 2.0, 5.0)
        .register();
    
    @Around("execution(* com.bank.llm.*.call(..))")
    public Object monitor(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        boolean success = true;
        try {
            return pjp.proceed();
        } catch (Exception e) {
            success = false;
            throw e;
        } finally {
            long duration = System.currentTimeMillis() - start;
            llmRequestCounter.labels("deepseek", String.valueOf(success)).inc();
            llmLatencyHistogram.labels("deepseek").observe(duration / 1000.0);
        }
    }
}

# 事实核查器
def fact_check(response: str, retrieved_docs: List[str]) -> float:
    # 使用NLI模型判断response是否被retrieved_docs蕴含
    scores = []
    for doc in retrieved_docs:
        score = nli_model.predict(premise=doc, hypothesis=response)
        scores.append(score)
    return max(scores)  # 返回最高蕴含分数

# 通过Istio实现流量切分
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: risk-agent
spec:
  hosts:
  - risk-agent
  http:
  - match:
    - headers:
        canary:
          exact: "true"
    route:
    - destination:
        host: risk-agent
        subset: v2  # 新模型版本
      weight: 100
  - route:
    - destination:
        host: risk-agent
        subset: v1  # 稳定版本
      weight: 95
    - destination:
        host: risk-agent
        subset: v2  # 5%流量引入新版
      weight: 5

-- 反馈数据表设计
CREATE TABLE llm_feedback (
    id BIGINT PRIMARY KEY,
    input_text TEXT,
    output_text TEXT,
    user_modified TEXT,        -- 用户最终提交的版本
    accepted BOOLEAN,          -- 是否直接采纳
    latency_ms INT,
    created_at TIMESTAMP
);

-- 每月运行分析报告
SELECT 
    DATE_TRUNC('month', created_at) as month,
    AVG(CASE WHEN accepted THEN 1 ELSE 0 END) as acceptance_rate,
    AVG(latency_ms) as avg_latency
FROM llm_feedback
GROUP BY month
ORDER BY month DESC;