从零构建微服务AI智能面试平台：一名全栈工程师的实战手记

┌─────────────────────────────────────────────────────┐
│                   面试全流程                          │
│  候选人端 → AI面试官 → 对话引擎 → 评估中心 → 报告   │
└─────────────────────────────────────────────────────┘

服务注册/配置: Nacos + Apollo
链路追踪: Jaeger (自定义Span)
监控: Prometheus + Grafana
日志: ELK (结构化日志)
消息队列: RabbitMQ (异步评估任务)
缓存: Redis (会话状态 + 限流)
数据库: PostgreSQL (主) + TiDB (历史归档)
容器编排: K8s (自建机房)
网关: Kong (自定义插件)

                    ┌─────────────┐
                    │   Kong网关   │
                    └──────┬──────┘
                           │
              ┌────────────┼────────────┐
              │            │            │
         ┌────▼───┐   ┌────▼───┐   ┌────▼───┐
         │会话管理 │   │对话引擎 │   │ 评估   │
         │(Go)    │   │(Go)    │   │(Java)  │
         └────┬───┘   └────┬───┘   └────┬───┘
              │            │            │
              └────────────┼────────────┘
                           │
                    ┌──────▼──────┐
                    │  模型网关   │
                    │ (路由/降级) │
                    └──────┬──────┘
                           │
         ┌─────────────────┼─────────────────┐
         │                 │                 │
    ┌────▼────┐      ┌─────▼─────┐    ┌─────▼─────┐
    │本地Qwen  │      │ 云端API   │    │ 小模型    │
    │(GPU集群) │      │(备用)     │    │(CPU)      │
    └──────────┘      └───────────┘    └───────────┘

// 对话处理核心流程（简化版）
func (e *Engine) ProcessMessage(ctx context.Context, req *ChatRequest) (*ChatResponse, error) {
    // 1. 获取会话上下文（含历史对话、候选人画像、面试大纲）
    session, err := e.sessionMgr.Get(ctx, req.SessionID)
    if err != nil {
        return nil, err
    }
    
    // 2. 并发执行：主模型推理 + 辅助检测
    var (
        mainResp   <-chan *ModelResponse
        emotion    <-chan *EmotionResult
        risk       <-chan *RiskResult
    )
    
    g := errgroup.WithContext(ctx)
    
    // 主模型调用（支持流式/非流式）
    g.Go(func() error {
        mainResp = e.modelGateway.Chat(ctx, buildPrompt(session, req.Message))
        return nil
    })
    
    // 情绪检测（轻量模型，快速返回）
    g.Go(func() error {
        emotion = e.emotionDetector.Analyze(ctx, req.Message)
        return nil
    })
    
    // 风险检测（敏感词、作弊特征）
    g.Go(func() error {
        risk = e.riskDetector.Check(ctx, req.Message, session)
        return nil
    })
    
    // 等待所有任务完成或超时
    ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
    defer cancel()
    
    if err := g.Wait(); err != nil {
        // 降级处理：主模型失败时返回预设话术
        return e.fallbackResponse(session), nil
    }
    
    // 3. 结果聚合与后处理
    response := &ChatResponse{
        Message:   <-mainResp,
        Emotion:   <-emotion,
        RiskScore: <-risk,
        // 注入元数据用于评估
        Metadata: buildMetadata(session, req),
    }
    
    // 4. 异步更新会话（写入Redis + 发送变更事件）
    go e.sessionMgr.UpdateAsync(session.ID, response)
    
    return response, nil
}

【系统指令】
你是一名资深技术面试官，面试岗位：{position}，级别：{level}。
面试风格：{style}（温和/严格/引导型）
当前面试阶段：{stage}（开场/技术深挖/软技能/收尾）

【候选人背景】
{resume_summary}

【面试大纲】
{outline}

【已问问题与回答摘要】
{qa_history}

【当前问题】
候选人说：{current_answer}

【任务】
1. 判断候选人的回答是否完整，如不完整则追问（追问规则：{rules}）
2. 如完整，根据大纲提出下一个问题
3. 生成对当前回答的即时评价（用于内部记录，不展示给候选人）

【输出格式】
{
  "should_follow_up": bool,
  "follow_up_question": string | null,
  "next_question": string | null,
  "instant_comment": string,
  "confidence_score": float
}

type ModelGateway struct {
    localClient   *ollama.Client      // 本地Qwen
    cloudClients  map[string]APIClient // 多家云API
    router        *Router
    fallbackChain []string            // 降级链路
}

func (g *ModelGateway) Chat(ctx context.Context, req *ModelRequest) <-chan *ModelResponse {
    respCh := make(chan *ModelResponse, 1)
    
    go func() {
        defer close(respCh)
        
        // 根据路由策略选择模型
        target := g.router.Select(req)
        
        for _, model := range target {
            resp, err := g.callModel(ctx, model, req)
            if err == nil {
                respCh <- resp
                return
            }
            // 记录失败，尝试下一个
            log.Warnw("model call failed", "model", model, "error", err)
            metrics.RecordModelFail(model)
        }
        
        // 全部失败，返回兜底
        respCh <- g.getFallbackResponse(req)
    }()
    
    return respCh
}

@Service
public class EvaluationEngine {
    
    @Async("evaluationExecutor")
    public CompletableFuture<EvaluationReport> evaluate(EvaluationTask task) {
        // 1. 加载完整对话记录
        List<DialogueTurn> turns = dialogueRepository.findBySessionId(task.getSessionId());
        
        // 2. 多维度评估（并行计算）
        CompletableFuture<TechnicalScore> techFuture = 
            assessTechnical(turns, task.getPosition());
        CompletableFuture<CommunicationScore> commFuture = 
            assessCommunication(turns);
        CompletableFuture<PersonalityFit> personalityFuture = 
            assessPersonality(turns);
        CompletableFuture<List<RiskIndicator>> riskFuture = 
            assessRisks(turns);
        
        // 3. 综合评分（带权重）
        return CompletableFuture.allOf(techFuture, commFuture, personalityFuture, riskFuture)
            .thenApply(v -> {
                TechnicalScore tech = techFuture.join();
                CommunicationScore comm = commFuture.join();
                PersonalityFit personality = personalityFuture.join();
                List<RiskIndicator> risks = riskFuture.join();
                
                return EvaluationReport.builder()
                    .overallScore(calculateOverall(tech, comm, personality))
                    .technical(tech)
                    .communication(comm)
                    .personality(personality)
                    .risks(risks)
                    .strengths(extractStrengths(turns))
                    .weaknesses(extractWeaknesses(turns))
                    .recommendation(generateRecommendation(tech, comm, personality))
                    .build();
            });
    }
    
    private TechnicalScore assessTechnical(List<DialogueTurn> turns, String position) {
        // 使用另一个轻量模型（或规则引擎）做技术点覆盖度分析
        // 提取候选人提到的技术关键词，与岗位要求比对
        // 同时评估回答深度（通过追问次数和回答长度加权）
    }
}

// 业务指标
var (
    // 模型Token消耗（按模型维度）
    modelTokenUsage = prometheus.NewCounterVec(
        prometheus.CounterOpts{Name: "ai_token_usage_total"},
        []string{"model", "type"}, // type: prompt/completion
    )
    
    // 追问率（反映对话深度）
    followUpRate = prometheus.NewHistogram(
        prometheus.HistogramOpts{Name: "dialogue_follow_up_rate"},
    )
    
    // 模型置信度分布
    confidenceScore = prometheus.NewHistogram(
        prometheus.HistogramOpts{Name: "model_confidence_score", Buckets: []float64{0.5, 0.7, 0.8, 0.9, 0.95}},
    )
    
    // 降级触发次数
    fallbackTriggered = prometheus.NewCounter(
        prometheus.CounterOpts{Name: "model_fallback_total"},
    )
)

Interview Session (traceId)
├── Gateway Auth (span)
├── Session Load (span) 
├── Model Inference (span)
│   ├── Prompt Build (span)
│   ├── Model Call (span) 
│   │   ├── Queue Wait (span)
│   │   └── Inference (span)
│   └── Response Parse (span)
├── Emotion Detect (span)
├── Risk Check (span)
└── Session Save (span)