1. 分数归一化问题：向量相似度是[0,1]，BM25分数是无界的，直接合并没有意义。
   解决：用Min-Max归一化，或者用Reciprocal Rank Fusion（RRF）算法。

2. RRF算法核心思想：不看分数，只看排名。
   RRF_score = Σ 1/(k + rank_i)，k通常取60。
   两路召回各自排序后，用RRF合并排名，生成统一排序。

3. 权重调整：可以给向量召回和BM25加权。
   对于技术问答，关键词匹配更重要，BM25权重调高；
   对于意图理解，向量召回更重要，向量权重调高。

4. 工程实现：Elasticsearch 8.x原生支持hybrid search + RRF，
   Milvus也有混合检索接口，不需要自己手撸。

代码展示加分项：

/**
 * 混合检索实现 - RRF融合策略
 * 字节面试中展示这段代码，面试官当场给了好评
 */
@Service
@RequiredArgsConstructor
public class HybridSearchService {

    private final VectorStoreService vectorStoreService;
    private final KeywordSearchService keywordSearchService;
    
    // RRF的k参数，论文推荐60
    private static final int RRF_K = 60;

    /**
     * 混合检索，返回融合后的结果列表
     */
    public List<SearchResult> hybridSearch(String query, int topK) {
        // 并行执行两路召回，提升性能
        CompletableFuture<List<SearchResult>> vectorFuture = 
            CompletableFuture.supplyAsync(() -> 
                vectorStoreService.search(query, topK * 2));
        
        CompletableFuture<List<SearchResult>> keywordFuture = 
            CompletableFuture.supplyAsync(() -> 
                keywordSearchService.search(query, topK * 2));
        
        List<SearchResult> vectorResults = vectorFuture.join();
        List<SearchResult> keywordResults = keywordFuture.join();
        
        // RRF融合
        return rrfFusion(vectorResults, keywordResults, topK);
    }

    /**
     * Reciprocal Rank Fusion算法
     */
    private List<SearchResult> rrfFusion(List<SearchResult> list1, 
                                          List<SearchResult> list2, 
                                          int topK) {
        Map<String, Double> rrfScores = new HashMap<>();
        Map<String, SearchResult> resultMap = new HashMap<>();
        
        // 计算第一路召回的RRF分数
        for (int i = 0; i < list1.size(); i++) {
            SearchResult result = list1.get(i);
            double score = 1.0 / (RRF_K + i + 1);
            rrfScores.merge(result.getId(), score, Double::sum);
            resultMap.put(result.getId(), result);
        }
        
        // 计算第二路召回的RRF分数，累加
        for (int i = 0; i < list2.size(); i++) {
            SearchResult result = list2.get(i);
            double score = 1.0 / (RRF_K + i + 1);
            rrfScores.merge(result.getId(), score, Double::sum);
            resultMap.putIfAbsent(result.getId(), result);
        }
        
        // 按RRF分数降序排列，取topK
        return rrfScores.entrySet().stream()
            .sorted(Map.Entry.<String, Double>comparingByValue().reversed())
            .limit(topK)
            .map(entry -> {
                SearchResult result = resultMap.get(entry.getKey());
                return result.withScore(entry.getValue());  // 更新为RRF分数
            })
            .collect(Collectors.toList());
    }
}

题目2：如何评估RAG系统的质量？说说你的方案。

这道题考察的是工程化思维，不只是技术实现，而是你有没有系统性地考虑过质量保障问题。

高分回答框架：

RAG质量评估分三个层次：

1. 检索质量评估（Retrieval Quality）
   - Recall@K：给定问题，正确文档是否在TopK里？
   - MRR（Mean Reciprocal Rank）：正确文档排名的倒数均值
   - 工具：RAGAS框架，有context_recall和context_precision两个指标

2. 生成质量评估（Generation Quality）
   - Faithfulness（忠实度）：回答是否完全基于检索到的文档？
   - Answer Relevancy（相关性）：回答是否切题？
   - 这两个指标RAGAS也有，用LLM作为评判者（LLM-as-Judge）

3. 端到端业务指标
   - 用户满意度（点赞/点踩比）
   - 问题解决率（用户追问频率）
   - 拒答率（"我不知道"的比例）

工程化落地：建立Golden Dataset（标准问答集），CI/CD中跑自动化评估，
质量指标下降超阈值则阻断发布。

阿里巴巴真题解析

题目3：你们的Prompt是怎么管理的？版本控制怎么做？

这是阿里非常看重的工程化意识题。Prompt管理混乱是AI项目死亡的常见原因之一。

高分回答：

Prompt管理分三个阶段：

开发阶段：
- Prompt存数据库，不硬编码在代码里
- 每个Prompt有版本号（语义化版本）
- 支持A/B测试：同一个业务场景可以运行多个Prompt版本
- 有变量占位符系统，业务逻辑和Prompt解耦

测试阶段：
- 每个Prompt版本有对应的测试用例集
- 修改Prompt必须跑回归测试，通过率>95%才能发布
- Golden Dataset评估，确保新版本不比旧版本差

生产阶段：
- 灰度发布：新Prompt先给5%流量，观察指标正常后再扩量
- 快速回滚：出现问题一键切回上个版本
- 监控：每个Prompt版本分别统计Token消耗、延迟、错误率

配套代码：

/**
 * Prompt版本管理服务
 * 支持版本化管理、A/B测试、灰度发布
 */
@Service
@RequiredArgsConstructor
public class PromptManagementService {

    private final PromptVersionRepository promptRepo;
    private final PromptMetricsService metricsService;

    /**
     * 获取当前生效的Prompt
     * 支持A/B测试：按userId hash分流
     */
    public PromptTemplate getActivePrompt(String promptKey, String userId) {
        // 查询该key下所有active版本
        List<PromptVersion> activeVersions = promptRepo
            .findActiveVersionsByKey(promptKey);
        
        if (activeVersions.isEmpty()) {
            throw new IllegalStateException("No active prompt for key: " + promptKey);
        }
        
        // 单版本直接返回
        if (activeVersions.size() == 1) {
            return buildTemplate(activeVersions.get(0));
        }
        
        // 多版本：按userId hash做流量分割
        PromptVersion selected = selectVersionByTraffic(activeVersions, userId);
        
        // 记录版本使用，用于A/B测试统计
        metricsService.recordPromptUsage(promptKey, selected.getVersion(), userId);
        
        return buildTemplate(selected);
    }

    /**
     * 基于userId hash的流量分割
     */
    private PromptVersion selectVersionByTraffic(List<PromptVersion> versions, 
                                                   String userId) {
        int hash = Math.abs(userId.hashCode() % 100); // 0-99
        int cumulative = 0;
        
        for (PromptVersion version : versions) {
            cumulative += version.getTrafficPercent();
            if (hash < cumulative) {
                return version;
            }
        }
        
        return versions.get(versions.size() - 1);
    }

    private PromptTemplate buildTemplate(PromptVersion version) {
        return new PromptTemplate(version.getContent());
    }
}

/**
 * Prompt版本实体
 */
@Entity
@Table(name = "prompt_versions")
@Data
public class PromptVersion {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String promptKey;      // 如 "question-answering"
    private String version;         // 如 "1.2.0"
    private String content;         // Prompt模板内容
    private Integer trafficPercent; // 流量百分比，所有active版本之和=100
    private Boolean active;         // 是否生效
    
    @CreationTimestamp
    private LocalDateTime createdAt;
    private String createdBy;
    private String changeLog;       // 本次修改说明
}

题目4：向量数据库选型，你会怎么选？

维度	Milvus	Weaviate	Qdrant	pgvector
性能（亿级向量）	极强	强	强	一般
运维复杂度	高（依赖etcd/MinIO）	中	低	极低
混合检索	支持	原生支持	支持	有限
云托管	Zilliz Cloud	官方云	官方云	Supabase
适用场景	超大规模生产	灵活语义搜索	中小规模	现有PG系统扩展

选型建议：

初期/中小规模：pgvector，省事，和现有PostgreSQL融合
中等规模且需要混合检索：Qdrant，性能好，运维简单
大规模生产（亿级以上）：Milvus，性能天花板最高

腾讯真题解析

题目5：讲一下Agent和普通RAG的区别，什么场景下需要用Agent？

高分回答框架：

核心区别：

RAG是单轮检索增强：一次检索、一次生成，适合"问答"场景
Agent是多步骤自主决策：可以使用工具、有循环推理能力，适合"任务完成"场景

什么时候上Agent：需要执行多步骤操作的任务，比如"帮我分析最近一个月的销售数据，找出下降的产品，并草拟一份改进方案"——这需要查数据库、做计算、写文档，多步骤才能完成。

Agent的坑：延迟高（多轮LLM调用叠加）、成本高、行为不可预测性高。不要为了用Agent而用Agent。

题目6：如何防止LLM幻觉问题？

这是2026年面试出现频率极高的题，因为幻觉是AI应用落地最大的障碍之一。

系统性回答（不要只说一两点）：

幻觉防治是多层防线：

1. 数据层：
   - RAG引入外部知识，减少模型凭空生成
   - 知识库要定期更新，避免用过时信息

2. Prompt层：
   - 明确要求："如果你不知道，就说不知道，不要编造"
   - Few-shot示例里包含正确拒答的例子
   - 要求模型引用来源："请基于以下文档回答，并标注来自哪段"

3. 输出验证层：
   - Faithfulness检查：验证回答是否与检索到的文档一致
   - 关键事实验证：对于数字、日期等关键信息做二次验证
   - 工具：RAGAS框架、LangChain的自我验证链

4. 降级策略：
   - 置信度低于阈值时，自动降级回答："我不确定这个答案，建议您咨询专业人士"
   - 不在知识库范围内的问题，直接拒答而不是乱答

5. 人工审核：
   - 高风险场景（医疗、法律、金融）保留人工审核环节
   - 用户反馈机制，标记错误回答后持续优化

面试准备清单

大厂AI岗位对比

维度	字节跳动	阿里巴巴	腾讯
技术深度要求	极高，考算法底层	高，重工程化	高，重业务落地
Prompt Engineering考察	中等	高	中等
系统设计比重	30%	35%	40%
代码题难度	LeetCode Hard	LeetCode Medium+	LeetCode Medium
面试轮数	4-5轮	4-5轮	4轮
薪资区间（北京P6）	60-90W	55-85W	50-80W

最后说几句实在话

面试这件事，技术是基础，但光技术好不够。我见过太多技术很扎实但面试不过的同学，原因是：

没有项目经验支撑。大厂面试官最怕的是背题的人，他们会追问细节：你们的向量数据库QPS是多少？怎么处理热点文档？遇到过什么具体问题？

所以，备考AI面试的核心不是背题，而是真正做过一个AI项目，在做的过程中遇到了问题、解决了问题，有真实的思考和经验。

这也是我在星球里一直强调的：先做项目，再刷题，而不是反过来。