# 简历复盘记录

本文档用于整理简历项目的面试复盘内容。简历是事实基准；`amms` 和 `ragent` 两个本地项目仅用于辅助理解实现，不代表个人职责或经历与仓库完全一致。涉及个人贡献、数据结果和业务背景时，以本人实际经历为准，尚未确认的内容先标记为待核实。

## 简历经历索引

| 经历 | 简历时间 | 简历角色 | 参考项目 |
| --- | --- | --- | --- |
| 八字健康科技集团有限公司 | 2026.06–2026.09 | AI 应用开发实习生 | `ragent`（参考） |
| 设备智能运维平台 | 2026.04–至今 | 后端开发 / 大模型应用 | `amms`（参考） |

## 使用约定

- 本文档与 [HTML 阅读版](简历复盘记录.html) 同步维护；内容确认后同时更新两个版本。
- 职责模块按“快速回顾 → 职责与实现概述 → 分类追问”复习；先理解业务问题和整体实现，每道追问再练“面试回答”，查看“实现细节”中的补充说明、例子、参数和对照表。
- HTML 提供“表格速查”与关键词搜索；表格直接取自正文，点击搜索结果可展开并定位对应内容。
- HTML 可切换“只看问题”进行自测；表格速查适合集中回顾选型、参数、职责和异常处理。
- 先记录问题和回答，再补充追问、证据及需要核实的事实。
- 回答优先按“背景与目标、个人负责、方案与取舍、结果与验证”组织。
- 区分个人完成、参与协作和系统已有能力；不把参考项目代码直接当作个人贡献。
- 评测数据和性能结果应记录评测集、指标口径、对照条件及来源。
- 待确认信息使用 `待核实` 标记，确认后再改为事实陈述。

## 经历一：八字健康科技集团有限公司

### 项目概览

#### 项目背景与职责

##### 项目速览

- **服务对象**

  政府监管人员、养老机构、老人及家属

- **项目目标**

  在权限和政策有效期范围内检索资料，生成可回查原文的答案

- **个人负责**

  资料入库、混合检索、Agent 查询流程与离线评测

##### 项目背景

养老政策、机构制度和服务资料来源分散、格式多样，并随政策修订持续更新。用户查询申请条件、补贴标准或材料要求时，需要同时匹配地区、对象和适用时间；做政策对比时，还需要找到新旧条款及关联附件，为每项差异提供出处。

平台面向政府监管人员、养老机构、老人及家属，提供资料检索、知识问答和政策变化分析。系统从文档入库开始保存版本与原文位置，在检索和工具执行时校验访问范围与政策适用性，回答通过 Evidence ID 关联文档和页码，让用户能够核对具体依据。

##### 我的职责

**资料入库**

我将文档解析、分块和向量化转为 Kafka 后台任务，使文件提交与耗时处理解耦；结合 MinIO 分片上传和 Redis Bitmap 实现断点续传，通过阶段状态与幂等写入支持任务恢复。文件传输中断后补传缺片，后台处理中断后复用已完成阶段的产物。

**检索与证据**

我采用 Parent-Child Chunk，以子块定位具体条款、父块补全适用条件与例外；结合 BM25 的关键词匹配和 BGE-M3 的语义召回，经 RRF 融合与 BGE Reranker 重排筛选候选。知识库、权限、政策有效期和文档版本共同确定可用证据范围，兼顾精确条款查询与口语化提问。

**Agent 查询流程**

我参与设计基于 ReAct 的检索与工具调用流程，并引入 Plan-and-Execute 处理政策变化分析等多步任务。Agent 根据正文、附件和版本查询结果补充证据，按比较维度组织答案；对话使用滑动窗口和历史摘要管理上下文，最终结论关联 Evidence ID、文档和页码。

##### 评测结果

我围绕养老政策、机构制度和服务资料构建了 200 余道题的离线测评集。原始系统与最终检索链路对比，Recall@10 从 0.71 提升至 0.89，MRR@10 从 0.62 提升至 0.78，体现了前十条结果中标准证据覆盖率和首条正确证据排序的改善。

### 简历要点复盘

#### 文档异步入库、分块上传与断点续传

简历表述：基于 Kafka 将解析、分块与向量化转为后台任务；结合 Redis Bitmap 与 MinIO 分片上传实现大文件断点续传。

##### 快速回顾

| 项目 | 内容 |
| --- | --- |
| 核心目的 | 上传与解析、分块、向量化解耦，支持大文件续传和任务恢复 |
| 处理链路 | MinIO 分片上传 → 合并确认 → MySQL 状态与 Outbox → Kafka → 后台处理 |
| 状态与恢复 | Redis Bitmap 记录进度；MinIO 校对实际分片；MySQL 保存阶段 checkpoint |
| 一致性 | 稳定业务键、条件更新、稳定 chunk ID upsert、Outbox 重试发布 |

##### 职责与实现概述

文档解析、分块、向量化和索引写入耗时较长，大文件传输又容易受网络中断影响。入库链路将文件传输和后台处理解耦：MinIO 分片上传配合 Redis Bitmap 支持续传，Kafka 承接后续入库任务，使上传进度和处理进度能够分别跟踪、分别恢复。

文件上传采用 MinIO 分片上传，Redis Bitmap 记录已完成的分片。网络中断后沿用原上传会话，与 MinIO 的实际分片核对，再补传缺失部分。文件合并并确认可用后，在数据库事务中更新文档状态、写入 Outbox 事件，由发布器投递 Kafka 入库任务。

后台按阶段保存处理进度和产物，失败后从未完成的位置继续；通过稳定业务键和索引 upsert 处理重复消费。只有解析、分块和索引全部成功，文档才进入可检索状态。

##### 原理与选型

<!-- question-id: q-14b0ff4f0214 -->
###### 为什么选择 Kafka，而不是其他 MQ？

面试回答：

文件上传后还要解析、分块和向量化，所以通过消息队列把上传接口和后台处理解耦。选择 Kafka 首先是因为公司团队已有使用基础，可以沿用已有经验，减少引入另一套消息队列的学习和维护成本。

技术上，Kafka 通过日志顺序追加、批量发送和分区并行，适合承接较高吞吐的任务消息。集中上传时，任务可以先进入队列，再由消费者按处理能力消化，缓冲上传高峰与后台处理速度之间的差异。同时，Kafka 支持消息保留和按位点重放，便于追踪消费进度和失败后重新处理。

综合团队基础、分区扩展和消息重放需求，我们采用 Kafka。队列负责缓冲任务，后台通过阶段并发上限控制解析和向量化资源，通过幂等写入和 checkpoint 处理重复消费与失败恢复。

实现细节：

Kafka 将记录追加到分区日志，顺序追加减少随机写入开销；生产者批量发送摊薄网络请求和 Broker 处理开销，分区支持分散存储及并行消费。文档处理能力则由解析、模型调用和索引写入各阶段的资源与并发决定。

`batch.size` 控制每个分区的批次大小，`linger.ms` 控制聚合批次的等待时间，调节时同时观察发送吞吐与排队延迟。压缩通过 CPU 开销换取更少的传输和存储量；`acks`、副本数和 `min.insync.replicas` 按写入可靠性与故障容忍要求配置。

Kafka 在消息保留期内支持按位点重新读取消息，重放时仍需检查业务任务状态。消费者组通过分配分区扩展消费能力，同一消费组的有效消费并行度受分区数量限制。

消费位点记录分区中的消息进度，业务 checkpoint 记录文档的阶段进度。任务投递、阶段完成和查询放行各有状态：消息发布后进入后台处理，必要阶段与索引全部完成后文档才可检索。

性能分析从消息排队、阶段处理和端到端入库三个层面展开，结合积压量、阶段耗时、在途任务数与下游限流定位瓶颈，再调整相应阶段的处理能力。

| 比较点 | Kafka | RabbitMQ |
| --- | --- | --- |
| 任务传递 | 分区日志，消费者按位点读取 | 队列投递，消费者确认处理结果 |
| 本项目的取舍 | 团队已有 Kafka 使用基础，同时考虑吞吐扩展、消息保留、按位点重放与消费进度管理 | 任务队列和消息路由机制更直接，也能承担异步任务 |
| 扩展方式 | 顺序追加与批处理摊薄开销，通过分区并行扩展 | 通过队列与消费者配置扩展 |
| 消费扩展 | 消费者组分配分区，并行度受分区数限制 | 由队列及消费者配置决定 |
| 业务侧仍需处理 | 幂等、任务状态与失败恢复 | 幂等、任务状态与失败恢复 |

<!-- question-id: q-8c609a117c38 -->
###### 文件上传后，解析、分块、向量化和索引是如何衔接的？

面试回答：

原文件在 MinIO 中合并并确认可用后，系统通过 Outbox 发布入库任务。后台先解析文件，提取正文和页码等信息，再按文档结构划分父块和子块，保存正文、版本及父子关系。之后对子块进行向量编码，并写入全文索引和向量索引，供后续关键词检索和语义检索使用。

每个阶段都保存处理状态和产物，后一个阶段使用前一个阶段的结果。处理中断后，核对已完成阶段及其产物，从未完成的位置继续。本次文档版本所需的处理和索引全部完成后，再标记为可检索。

检索侧按文档版本核对入库状态，以必要处理阶段和索引均完成为放行条件，使查询使用完整入库的文档版本。

实现细节：

上传分片按文件字节划分，合并后得到完整原文件，以 `uploadId + partNumber` 定位；正文分块发生在解析之后，按章节、条款和语义组织检索内容，以 chunk ID 关联索引与原文。

MySQL 保存文档版本、父子块正文、关联关系与阶段 checkpoint；全文索引保存用于 BM25 检索的子块文本，Milvus 保存 BGE-M3 编码后的子块向量及必要过滤字段。任务消息应引用文档版本和原文件位置，让后台从对象存储读取文件，避免把大文件直接塞进消息。

阶段完成以产物可用为依据：解析阶段核对正文和页码，向量化阶段核对子块向量，索引阶段确认目标版本的必要索引写入成功。失败时保存位置与原因，保留待处理状态。处理进度从持久化任务记录查询，上传分片进度从 Redis Bitmap 查询。

例如，同一文档版本的全文索引已写入、向量索引失败，此时阶段状态仍未完成。查询侧需要依据权威状态排除该版本；重试完成必要索引后，才具备放行条件。MySQL 中的完成状态需要与查询侧的放行检查配合，才能避免使用未完成版本的索引结果。

| 阶段 | 输入 | 产物与完成依据 |
| --- | --- | --- |
| 上传与合并 | 原文件分片 | MinIO 中完整可用的原文件 |
| 文件解析 | 原文件 | 正文、页码等解析结果 |
| 正文分块 | 解析结果与文档结构 | 父子块正文、版本与关联关系 |
| 向量化 | 子块正文 | 对应编码配置的子块向量 |
| 索引写入 | 子块文本、向量与过滤字段 | 目标版本的全文索引和向量索引写入成功 |
| 完成入库 | 本次版本的阶段状态和产物 | 必要处理均已完成，文档才可检索 |

##### 实现与恢复

<!-- question-id: q-19792db67a6a -->
###### MinIO 分片上传与断点续传的流程是什么？

面试回答：

流程可以分成创建会话、上传分片、中断续传和合并确认。用户发起上传后，后端先校验文件信息和权限，再向 MinIO 创建分片上传会话，取得 uploadId。客户端沿用这个会话上传各个分片，Redis Bitmap 记录哪些分片已经完成。

网络中断后，先用原会话查询 MinIO 中实际存在的分片，校正缓存进度，再补传缺失部分。这样既不用从头上传，也不会因为 Redis 进度丢失或过期而误判文件已经传完。

所有分片齐全后，后端请求合并并确认目标文件完整可用，随后发布入库任务，后台继续解析和索引处理。

实现细节：

`uploadId` 标识 MinIO 的一次 Multipart Upload，续传必须沿用对应会话。`partNumber` 标识分片序号，客户端保存每片上传后返回的 ETag，合并时按序号提交对应的 ETag 列表。

Redis Bitmap 用位记录分片完成情况，分片上传成功后更新对应进度。续传时以 MinIO 的实际分片列表为依据校正 Bitmap，再计算缺失分片。

合并确认后，在同一数据库事务中更新文档状态并写入 Outbox 事件，再由发布器投递 Kafka。上传状态与索引处理状态分别维护。

| 步骤 | 关键动作 | 具体记录或检查 |
| --- | --- | --- |
| 创建会话 | 校验文件与权限，创建 Multipart Upload | 关联上传会话与 `uploadId` |
| 上传分片 | 按 `partNumber` 上传 | 保存对应 ETag，成功后更新 Bitmap |
| 中断续传 | 查询 MinIO 实际分片 | 校正缓存进度，只补传缺失分片 |
| 合并确认 | 按序号提交分片及 ETag 列表 | 确认目标对象完整可用 |
| 触发入库 | 数据库事务更新状态并写入 Outbox | 由发布器投递 Kafka，后续单独跟踪处理状态 |

<!-- question-id: q-96f1408e475c -->
###### 为什么用 Redis Bitmap 记录上传进度？具体如何设计？

面试回答：

分片序号是连续整数，每个分片又只需要记录完成或未完成，用 Bitmap 比较合适。每个分片占一位，上传成功后把对应位设为一，查询时可以定位缺失分片，也可以统计已完成数量。重复把同一位设为一不会重复计数。

Bitmap 按上传会话隔离，分片序号映射到对应位，避免不同文件或不同上传尝试共用进度。它只记录完成标记，分片的 ETag 仍要另外保存，合并时交给 MinIO。Redis 进度丢失或过期后，先查询 MinIO 的实际分片列表，再恢复进度并补传缺片。

Set 也能记录已完成分片，适合编号比较稀疏或需要直接枚举成员的情况。这里分片序号连续、状态简单，因此使用 Bitmap；它用来加速进度查询，MinIO 中的实际分片仍是续传核对依据。

实现细节：

若共有 N 个连续分片，Bitmap 的位数据约占 `ceil(N / 8)` 字节，Redis Key 和对象另有开销。编号稀疏时，位数据空间由最大位偏移决定，因此连续分片编号更适合这种表示。

分片编号与位偏移需要统一约定。例如 MinIO 的 `partNumber` 从 1 开始，可以映射到 `partNumber - 1` 的位偏移，先校验编号位于本次上传的合法范围，再执行 `SETBIT`；查询单片使用 `GETBIT`，统计已完成分片数使用 `BITCOUNT`。

进度 Key 按上传会话隔离，后台结合认证身份校验会话操作权限。同一文件重新创建会话时建立独立进度；ETag 列表、总分片数和目标对象信息保存到会话元数据中。

分片大小与上传并发需要结合文件规模、网络和对象存储约束选择。最后一片大小可能不同，已完成分片比例不一定等于已上传字节比例。清理进度前核对会话状态和实际分片，避免缓存过期后误删仍有效的上传。

<!-- question-id: q-159655211ace -->
###### 解析和向量化耗时很长，如何避免 Kafka 消费超时，并控制处理并发？

面试回答：

关键是同时控制拉取节奏、在途任务数和消费位点。解析和向量化可能耗时很长，单批拉取太多，再逐条串行处理，就容易超过两次 poll 的最大间隔。因此先按阶段处理能力限制批量和并发，让消费循环能够按时继续运行，后台也不会被任务压满。

如果耗时工作交给工作线程，消费线程仍负责 poll、暂停恢复和提交位点，工作线程只返回处理结果。缓冲队列满时暂停对应分区接收新任务，并继续维持消费循环；处理能力恢复后再接收。增加消费者只解决一部分并行度问题，解析、模型调用和存储仍各有资源上限。

位点按分区推进到连续完成或已持久化交接的位置；工作线程乱序完成时，等待前面的消息满足确认条件再提交。重平衡后，通过阶段状态识别已完成工作，通过幂等写入处理再次到达的任务。

实现细节：

Kafka 的 `max.poll.interval.ms` 限制消费应用两次 poll 之间的最大间隔，超出时会触发重平衡；心跳与会话超时负责检测成员存活。`max.poll.records` 控制单次返回数量，应用另设在途任务上限控制累计负载。

直接在消费线程执行时，让批量和处理耗时与 poll 间隔相匹配；交给工作线程时，由消费线程统一操作 KafkaConsumer，协调拉取、暂停和位点提交，工作线程返回结果。分区暂停期间继续 poll，并通过有界缓冲实施背压。

按分区跟踪连续完成的消息，提交位点表示下一条待消费的位置。内存排队的任务等待执行完成后确认；采用持久化任务接管时，以任务记录落库并具备后续领取和恢复能力为交接条件，重平衡后的重复领取走业务幂等控制。

积压处理分别观察消息积压、文档排队时长、各阶段耗时、在途任务数与失败重试。消费者数量、分区数、解析并发和向量化并发围绕瓶颈阶段调整，并受下游限流与资源容量约束。

| 控制项 | 作用 | 配套要求 |
| --- | --- | --- |
| `max.poll.interval.ms` | 限制两次 poll 的间隔 | 按批量耗时安排 poll 节奏 |
| `max.poll.records` | 限制单次 poll 返回数量 | 同时设置在途任务上限 |
| 分区暂停与恢复 | 暂缓拉取已分配分区的数据 | 暂停期间仍需 poll，也需限制应用缓冲 |
| 有界队列与阶段并发上限 | 控制待处理任务和资源使用 | 持久化交接成功后才满足相应确认条件 |
| 分区内连续完成位点 | 避免确认尚未完成的较早消息 | 配合业务幂等与阶段恢复状态 |

<!-- question-id: q-5bb531290812 -->
###### Kafka 重复消费如何保证幂等？

面试回答：

幂等控制覆盖任务状态和索引写入两层。任务按文档版本和处理阶段区分，消费者收到重复消息时，已经完成的阶段直接跳过；状态推进通过数据库条件更新控制，避免两个消费者只凭一次状态查询就同时推进同一阶段。

索引写入使用稳定的 chunk ID 和 upsert。同一个子块重复处理时更新同一条记录，不会因为消息重放而新增一份重复索引。阶段产物和完成状态持久化之后，即使提交消费位点失败，消息再次到达，也能识别已经完成的工作。

实现细节：

阶段业务键使用 `documentVersionId + stage`，对应同一文档版本的同一处理阶段。条件更新同时匹配业务键与预期状态，根据更新结果判断处理资格和状态推进；更新未成功时，重新读取当前状态再决定后续动作。

同一文档版本、同一切分配置下，chunk ID 在重复处理时保持一致。upsert 将重复写入落到同一条索引，阶段状态控制处理资格，checkpoint 支持复用已完成产物，分别解决写入幂等、并发推进和计算恢复问题。

checkpoint 记录阶段恢复位置，阶段完成前核对产物已持久化且可用。重复消息按当前状态决定跳过、等待或恢复；涉及非幂等外部副作用时，另外保存调用结果，恢复前核对实际执行情况或进行补偿。

| 层次 | 标识或机制 | 控制的内容 |
| --- | --- | --- |
| 任务阶段 | `documentVersionId + stage` | 识别同一文档版本的同一处理阶段 |
| 状态推进 | 业务键、预期状态与数据库条件更新 | 避免只查后改造成并发重复推进 |
| 阶段完成 | checkpoint、持久化产物与完成状态 | 识别已完成工作，提供恢复依据 |
| 索引写入 | 稳定 chunk ID + upsert | 重复写入同一条记录，避免新增重复索引 |
| 外部副作用 | 调用结果记录与核对或补偿 | 单独处理无法直接幂等的外部操作 |

<!-- question-id: q-61729f2e1ead -->
###### 消费失败如何重试和恢复？

面试回答：

失败后先保存文档版本、失败阶段和原因，再判断是否值得重试。模型超时、存储暂时不可用这类临时故障适合退避重试；文件损坏、格式不支持等需要修正输入的问题，则保留失败状态，停止重复执行同一份错误输入。临时故障达到重试上限后，也要保留可继续处理的失败记录。

恢复时先读阶段 checkpoint，再核对实际产物，从第一个未完成或产物不可用的阶段继续。例如解析结果已经保存，向量化超时，就复用解析和分块结果，继续处理向量化与索引，而不是重新上传、重新解析。Worker 重启和消息重放沿用同一套恢复逻辑。

位点确认以消息负责的工作完成或失败任务持久化交接为条件。交接记录包含任务标识、失败阶段与原因，确保后续重试或人工处理能够找到并接管任务。

实现细节：

checkpoint 记录解析、分块、向量化等阶段的进度。恢复时核对状态与产物，产物缺失则重新处理对应阶段。重试记录失败类型、原因和次数，临时故障按退避策略执行，确定性错误或重试耗尽后转入持久化失败处理。

消费位点按消息职责确认：消息覆盖完整入库时，等待完整处理结束或持久化交接；消息按阶段拆分时，等待当前阶段完成且下一阶段任务可靠交接。分区位点推进到连续满足确认条件的位置。

业务恢复流程根据持久化的任务状态和失败记录接管后续处理；交接完成后再提交相应位点。异常日志用于排查，任务记录用于定位恢复阶段和重新执行。

| 情况 | 判断依据 | 处理边界 |
| --- | --- | --- |
| 临时故障 | 超时、存储暂时不可用等 | 退避重试，受次数或执行预算限制 |
| 确定性错误或重试耗尽 | 失败类型、原因与已执行次数 | 持久化失败信息，再转后续处理 |
| Worker 重启或消息重放 | 阶段 checkpoint 与实际产物 | 从未完成阶段恢复，重复到达仍走幂等控制 |
| 某个阶段完成 | 阶段产物及状态已持久化 | 保存 checkpoint，不据此确认超出该阶段范围的整条消息 |
| 消息可确认 | 所负责的工作完成，或失败任务已可靠交接 | 才具备提交相应消费位点的条件 |

<!-- question-id: q-3169546ad22e -->
###### 文件合并、状态落库和消息投递之间如何处理失败？

面试回答：

链路分两段建立恢复依据：先核对 MinIO 目标对象是否完整可用，再通过数据库事务将文档状态与 Outbox 待发布事件一起落库。对象合并结果不确定时走上传恢复；状态与事件提交成功后，由 Outbox 发布器负责投递重试。

文件已经合并、数据库事务却失败时，根据同一上传会话、目标对象和文档版本核对记录，再恢复文档状态与待发事件。这样已上传文件可以继续用于入库，任务创建也有明确的持久化依据。

Kafka 暂时不可用时，待发布事件仍然保留在数据库，发布器可以继续重试，收到 Kafka 确认后才标记为已发布。如果消息已经发出，但发布器在更新标记前崩溃，事件可能再次发送，由消费端幂等处理。这样，数据库事务保证状态与待发事件一起落库，发布重试处理漏投递，消费幂等处理重复投递。

实现细节：

MinIO 合并在数据库事务之外完成，Outbox 事务覆盖文档状态和待发事件。文件与数据库之间的恢复按上传会话、目标对象及文档版本对齐；数据库提交后的恢复则以待发布事件为依据。

发布器扫描已提交的待发布事件，收到 Kafka 确认后标记已发布。未收到确认、发送超时或结果不确定时保留重试资格；消息已送达但标记未更新时允许再次投递，由消费端按业务键和阶段状态幂等处理。

| 故障位置 | 已持久化的内容 | 后续处理依据 |
| --- | --- | --- |
| MinIO 合并完成、数据库事务未成功 | 目标文件、上传会话关联记录 | 核对对象后恢复文档状态与待发事件 |
| 数据库事务执行 | 提交后文档状态与待发布事件同时落库 | 事务失败时两项数据库变更一起回滚 |
| Kafka 不可用或发送结果不确定 | 待发布事件仍保留 | 发布器继续重试，不提前标记已发布 |
| 已发送、更新标记前崩溃 | Kafka 可能已收到消息，事件仍待发布 | 再次投递，由消费端幂等处理 |

<!-- question-id: q-c648751b3a0f -->
###### 分片合并失败如何处理？

面试回答：

先核对 MinIO 中的实际分片是否齐全。如果缺片或分片信息不一致，就保留仍有效的上传会话，补传或校正后再请求合并。

合并接口超时只表示未取得确定响应，恢复时需要核对目标对象是否已经完整生成。已经生成就继续后续入库；确认没有成功且原会话仍有效时，再重试合并。文件没有生成、原会话也已失效时，才需要重新创建上传。

只有确认原文件完整可用后才触发入库。失败过程中保留状态和原因，长期未完成的分片再按清理策略回收。

实现细节：

合并前按 `partNumber` 核对分片及对应 ETag，并按序号提交合并列表。ETag 用于指定参与合并的分片，不直接当作原文件的完整性校验值。

合并成功会结束对应 Multipart Upload。请求超时后，先检查本次上传关联的目标对象，结合预期大小和内容校验确认完整性；对象尚未生成时，再查询会话是否仍有效，决定重试合并还是重新上传。

清理长期未完成的会话和分片前，需要检查任务是否仍有效，避免回收仍在上传或等待恢复的分片。

| 故障位置 | 具体检查 | 恢复方式 |
| --- | --- | --- |
| 分片不完整 | MinIO 实际分片与预期列表 | 保留有效会话，补传缺失分片 |
| 分片信息不一致 | `partNumber` 与对应 ETag | 校正后重新请求合并 |
| 合并请求超时 | 本次上传关联的目标对象及完整性 | 已完成则继续入库，确认未完成且会话有效才重试 |
| 目标对象未生成、会话失效 | 同时核对对象与会话状态 | 重新创建上传 |
| 长期未完成 | 任务有效性与清理条件 | 按策略回收，避免清理仍有效的上传 |

##### 验证与结果

<!-- question-id: q-d2b037c394db -->
###### 如何验证断点续传和异步入库的可靠性？

面试回答：

验证时要主动打断链路，再检查恢复后的业务结果。上传侧可以在传完部分分片后断网，确认重新连接后沿用原会话，只补传缺片；再清除缓存进度，确认系统能依据 MinIO 的实际分片恢复进度，最终文件与原文件一致。

入库侧重点检查重复消息、Worker 重启和下游暂时失败。恢复后，已完成的阶段应能复用，索引不应产生重复记录，未完成版本也不应出现在回答证据中。Outbox 则检查发送失败能否继续投递，以及发送成功但标记未更新时，重复投递是否仍得到正确结果。

可靠性核对关注续传结果、阶段复用、重复索引和查询放行；性能核对记录消息积压、排队时间、各阶段耗时及端到端入库耗时，用于定位后台处理瓶颈。

实现细节：

验证场景和预期结果如下。

| 中断或故障位置 | 恢复操作 | 核对结果 |
| --- | --- | --- |
| 部分分片上传后断网 | 使用原会话重新查询并续传 | 已有分片不重复传，缺片补齐；合并后大小与独立内容校验一致 |
| Redis 进度丢失 | 从 MinIO 分片列表恢复 | 不误报完成，不重新上传全部分片 |
| 阶段产物保存后 Worker 重启 | 重新领取或重放任务 | 已完成阶段被识别，失败阶段继续执行 |
| 相同任务重复到达 | 重复消费同一业务版本 | 状态不倒退，稳定 chunk ID 不产生重复索引 |
| 一路索引写入失败 | 重试该阶段并发起查询 | 完成前不放行该版本，必要索引完成后可查询 |
| Kafka 确认后发布器崩溃 | 重启发布器 | 允许重复投递，最终业务结果保持一致 |

##### 补充记录

- 消费执行：单条消息负责完整入库还是一个阶段；同步处理、工作线程或持久化任务接管的实际选择；消费位点提交点及重平衡处理。
- 并发与重试：poll 配置、在途任务和阶段并发上限、重试载体与次数、失败任务的持久化接管方式。
- 查询可见性：未完成文档版本在全文索引与向量索引中的隔离方式，权威状态的查询校验位置。
- 上传恢复：合并成功但数据库事务失败时的恢复入口；上传会话与进度 Key 的关联、位偏移约定、分片大小、上传并发及清理周期。
- 状态反馈：任务进度和失败原因查询接口，以及消息负载中的实际字段。
- 验证依据：已执行的断网、重复消费、Worker 重启和 Outbox 故障场景记录；实际性能数据。
#### Parent-Child Chunk 分层索引

简历表述：通过子块召回定位相关内容，回溯父块补全条款与上下文。

##### 快速回顾

| 项目 | 内容 |
| --- | --- |
| 核心思路 | 子块定位，父块补全；兼顾检索精度与条款完整性 |
| 处理链路 | 子块召回 → RRF → 子块重排 → 按父块去重 → 预算内补全上下文 |
| 调参参考 | 子块约 200～400 tokens；父块约 800～1500 tokens |
| 存储分工 | MySQL 保存正文与关系；全文索引保存子块文本；Milvus 保存子块向量 |

##### 职责与实现概述

养老政策和机构制度中的具体条件需要精确定位，但单个片段又可能缺少适用范围和例外说明。Parent-Child Chunk 将用于召回的子块和补充上下文的父块分开处理，兼顾定位精度与条款完整性。

入库时，先按章节、条款等结构划分父块，再在父块内部划分主题更集中的子块，保存父子关系、文档版本和页码。检索时对较小的子块做 BM25 和向量召回，经过 RRF 融合与 BGE Reranker 重排，再根据命中的子块回溯父块，补充回答需要的完整依据。

回溯时按 `parentId` 去重，并根据上下文预算控制补充范围。父块尽量保留完整条款边界，避免将无关内容拼在一起，也避免重复内容占用上下文。具体切分粒度和补全范围结合文档结构与离线测评调整。

##### 原理与选型

<!-- question-id: q-be4a121d5884 -->
###### 为什么不直接用固定切块加 overlap？

面试回答：

固定切块加 overlap 可以补偿切分边界附近的信息，但政策的适用范围和例外说明可能相隔比较远，只增加相邻重叠，不一定能把这些条件一起带回来。overlap 过大还会增加重复文本，让相似片段占用召回名额。

父子分块由较小、主题集中的子块负责精确召回和重排，命中后按父子关系补回完整条款，让模型同时读到所问内容、前置条件和例外。子块可保留适量 overlap 补偿局部切分边界，父块则按条款结构补全更大范围的上下文。

父块负责补全同一条款的上下文；条款引用其他章节或附件时，继续沿引用关系读取或补充检索，取得相应依据。

实现细节：

父子分块需要维护 `parentId` 与版本关系，并控制回溯预算。选择该方案的业务依据是政策、制度具有章节与条款结构，且遗漏限制条件会影响答案适用性。

| 方案 | 主要作用 | 需要注意 |
| --- | --- | --- |
| 固定切块 | 控制片段长度，便于建立索引 | 可能拆开条件与例外，或混合多个主题 |
| 增加 overlap | 补偿切分边界附近的信息 | 增加重复内容，未必覆盖远处附注 |
| Parent-Child | 子块精确定位，父块补齐结构化上下文 | 需维护父子关系并控制回溯预算 |

##### 实现与调参

<!-- question-id: q-bd61f651e140 -->
###### 父块和子块分别多大？怎么确定？

面试回答：

我们优先按文档结构切分，再设置长度上限。父块对应完整条款或章节中的独立主题，子块沿段落、句子边界细分，使检索主题集中。调参时以子块约 200 到 400 tokens、父块约 800 到 1500 tokens 为比较范围，结合条款结构选择粒度。

选择大小时，要同时看检索效果和回答完整性。子块太大可能混入无关主题，太小又可能失去必要指代；父块太大则会增加上下文成本。因此尺寸需要结合条款结构与评测确定，比较时同时观察召回、条件覆盖和 token 开销。

实现细节：

过长章节按独立主题继续拆分，并保存章节关联。长度使用对应模型的 tokenizer 计算，补充的标题与必要指代信息一并计入预算。

例如，一个条款包含“适用对象—材料清单—例外说明”三个段落，父块可对应完整条款，子块沿段落进一步划分。材料清单被召回后，仍能通过父子关系读到同条款的对象与例外；如果条款过长，则需要继续按独立主题拆分并保留结构关联。

| 对象 | 调参参考范围 | 切分与检查重点 |
| --- | --- | --- |
| 子块 | 约 200～400 tokens | 按段落和句子边界，主题集中且可独立理解 |
| 父块 | 约 800～1500 tokens | 尽量覆盖完整条款、适用条件和例外 |
| 参数选择 | 参考范围，结合文档与评测确定 | 比较召回、排序、条件完整性和上下文成本 |

<!-- question-id: q-ca3c2121baae -->
###### 父块和子块分别存在哪里？哪些内容需要向量化？

面试回答：

这套方案里，MySQL 保存文档版本、父子块正文和关联关系，子块上记录 parentId、章节路径和页码。用于检索的是子块，全文索引保存子块文本供 BM25 使用，Milvus 保存 BGE-M3 编码后的子块向量和必要过滤字段。

检索、融合和重排确定子块后，根据文档版本和 parentId 从 MySQL 直接回查父块。回查时校验父子版本一致、该版本适用于请求时间，以及用户当前具有访问权限。历史查询读取对应时点有效的旧版本，保留当时的条款依据。

实现细节：

正文与父子关系以 MySQL 记录为准，全文索引和向量索引承担召回职责。父块回溯时同时使用文档版本与 `parentId`，防止不同版本之间错误关联。

例如 V1 的子块 C1、C2 都指向父块 P1，读取时使用 V1 与 P1 联合定位。子块保留原文件位置，补全父块后仍能将结论映射回 V1 的实际来源页。

| 组件 | 保存内容 | 主要用途 |
| --- | --- | --- |
| MySQL | 文档版本、父子块正文、parentId、章节及页码 | 回查正文、父子关系、入库状态与时间适用性 |
| 全文索引 | 子块文本及过滤字段 | BM25 关键词检索 |
| Milvus | BGE-M3 子块向量及过滤字段 | 语义召回 |
| 父块读取 | 按文档版本与 parentId 回查 | 补齐上下文，不另做一次父块向量检索 |

<!-- question-id: q-6453e8c91b61 -->
###### 重排在回溯父块之前还是之后？为什么？

面试回答：

我们先对子块重排，再回溯父块。子块内容比较集中，Reranker 更容易判断它是否直接回答问题，输入长度和计算成本也比较可控。等相关子块筛选出来后，再补回它所在的完整条款，供后续生成答案使用。

先重排子块能减少同一父块被重复评分及长文本截断的开销。切分时为子块保留标题、章节路径和必要指代信息，使 Reranker 能理解局部正文的含义，再为高相关子块补全条款。

实现细节：

重排输入是问题与候选子块，父块装配服务于后续回答。对子块中“符合上述条件者”一类表述，需要保留足够的标题或上下文信息，避免相关性判断失去依据。

| 顺序 | 收益 | 主要代价或风险 |
| --- | --- | --- |
| 先重排子块，再回溯父块 | 相关性判断集中，输入较短，成本可控 | 子块需要保留标题和必要指代信息 |
| 先回溯父块，再重排 | 可直接看到更大范围内容 | 重复与无关内容增加，相关条款可能被截断 |

<!-- question-id: q-854083b1369f -->
###### 多个子块命中同一个父块，怎么去重和排序？

面试回答：

先按文档版本和 parentId 聚合，同一个父块只放进上下文一次，同时保留命中的子块和位置。父块排序需要结合子块相关性，一种简单方式是取最相关子块的得分，避免长章节因为子块多、累加分数高就天然排在前面。

如果同一父块的多个命中分别覆盖问题的不同条件，装配时保留各自的证据范围。重排后的十个子块可能聚合为两个父块，证据是否充足按问题维度的覆盖情况判断。缺少申请材料等必要维度时，再定向补查，并控制相关性和上下文预算。

实现细节：

父块去重键使用文档版本与 parentId，子块位置用于围绕命中区域读取及定位引用。候选补充以未覆盖的问题维度为目标，并满足相关性与上下文预算要求。

排序示例：C1、C2 属于 V1/P1，重排分数为 0.9、0.8；C3 属于 V1/P2，分数为 0.85。若采用最高子块分数，P1、P2 的排序分数分别为 0.9、0.85；P1 只装配一次，但 C1、C2 的来源位置都保留。

<!-- question-id: q-d9c8260ef37f -->
###### 父块太大，超过上下文预算怎么办？

面试回答：

父块超过上下文预算时，围绕命中的子块补充所属条款，优先保留标题、适用条件和例外说明。同一父块中多个相邻或重叠的命中范围先合并，减少重复，不同父块再根据相关性分配 token 预算。

必要条件超出单次预算时，通过后续读取或补充检索分步查证；每项结论保留对应的适用条件与例外。当前回答范围由已取得的完整依据决定，后续调用继续处理剩余维度。

实现细节：

预算装配保留原文位置和版本，截取片段后仍可回查。跨父块比较时，先检查问题各维度的证据覆盖，再按相关性分配剩余预算。

证据可用预算可按“模型上下文上限 − 指令与工具说明 − 当前问题、对话和任务状态 − 输出预留”估算，所有内容使用实际 tokenizer 计数。例如 P1 的两个命中范围在同一条款中重叠，可先合并范围，再计算标题、正文及引用元数据的总长度。

| 优先级 | 装配内容 | 控制方式 |
| --- | --- | --- |
| 先保留 | 命中片段、所属条款、标题、适用条件与例外 | 围绕命中位置读取，避免只截取开头 |
| 再去重 | 同一父块内相邻或重叠范围 | 合并后装配 |
| 分配预算 | 不同父块的相关证据 | 按相关性分配 token 预算 |
| 仍有缺口 | 回答必须依赖但未读到的内容 | 补充读取、分步查证或缩小回答范围 |

<!-- question-id: q-7e30ae2914c2 -->
###### PDF 表格、跨页条款怎么切？

面试回答：

切分依据应是解析后的条款和表格结构，页码主要用于引用定位。一个条款即使跨了两页，只要编号、标题和正文是连续的，仍然需要关联起来，同时保留每个片段的来源页码。

表格要保留表名、表头、单位和附注。表格过大需要拆开时，每组数据行都带上必要表头，否则一个金额数字脱离照护等级和每人每月的单位就没有完整含义。跨页表格还要检查列结构和表头是否一致，不能只因为位置相邻就合并。最终引用指向真正支持结论的页面，涉及多页时保留多页来源。

实现细节：

结构切分关注条款编号、标题层级、正文连续性以及表格列结构。金额、比例、计量周期和适用对象都属于证据的一部分，不能只索引单元格中的数值。

例如，同一条款跨第 4、5 页，父块可以关联两页正文；第 4 页子块记录自己的页内位置，第 5 页子块也保留独立位置。回答仅使用第 5 页某项材料时引用第 5 页，结论同时依赖两页时保留两侧来源。

<!-- question-id: q-a04910280572 -->
###### 命中的子块找不到父块，或父子版本不一致时怎么处理？

面试回答：

按命中子块记录的文档版本和父块关系回查，分别识别父块缺失、版本错配、文档状态变化和权限变化。当前请求排除错配或无权访问的候选，后台按文档与构建版本核对关联记录。

父块缺失时，若子块来源有效且权限通过校验，就检查其能否独立支持当前结论；缺少必要条件则继续补查，并保留待补依据。关联异常记录下来交由后台修复，回答使用校验通过且条件完整的证据。

实现细节：

| 检查结果 | 当前查询的处理 | 后续核对方向 |
| --- | --- | --- |
| 父块不存在 | 不装配虚构或同名父块，重新判断证据是否足够 | 父子记录是否完整、索引是否残留 |
| 父子版本不一致 | 排除错配组合 | 文档版本与索引构建版本、关联写入过程 |
| 版本对请求时间不适用 | 排除该证据，查请求时间对应版本 | 时间条件与政策关系 |
| 用户已无权访问 | 不返回正文 | 当前认证范围与索引过滤信息 |
| 文档尚未完成入库 | 不作为回答证据 | 入库状态及部分索引的隔离方式 |

##### 评测与结果

<!-- question-id: q-c50e74ff0579 -->
###### 怎么证明父子分块比原来的方案好？

面试回答：

父子分块的评价重点是：子块能否准确定位条款，父块补全后能否保留适用条件和例外，以及为此增加多少上下文开销。对照时固定文档版本、测评集、embedding、检索与重排配置，比较固定切块加 overlap 和父子分块两种方式，同时记录 Recall@10、MRR@10、条件覆盖、引用支持情况、token 数与耗时。

标注以原文条款或范围为单位，将各方案命中的子块映射回同一份标准证据。这样即使切分后 chunk ID 变化，也能比较是否找到了相同依据。对“材料清单已命中，但适用对象或例外被切开”的题目，重点核对补全后条件是否齐全。

实现细节：

分块对照固定检索和重排配置，混合检索对照固定分块。子块排序在父块扩展前统计，条件覆盖在证据装配后检查；项目整体检索结果见“混合检索与重排”的评测部分。

独立对照需要记录以下项目。

| 比较项 | 固定条件或观察参数 |
| --- | --- |
| 固定条件 | 文档及版本、评测集、embedding、检索与重排配置 |
| 主要变量 | 分块方式与上下文补充方式 |
| 证据覆盖与排序 | Recall@10、MRR@10 |
| 回答质量 | 适用条件是否遗漏、例外是否误用、引用是否支持结论 |
| 成本 | 上下文 token 数与耗时 |
| 归因 | 整体链路提升与父子分块独立收益分开判断 |

##### 补充记录

- 切分配置：实际结构识别规则、父子块长度、overlap、tokenizer 及标题补全方式。
- 关联与排序：父子 ID 与文档/构建版本的关系、原文位置保存方式、父块得分聚合及候选补位策略。
- 预算与读取：实际 token 预算、超预算后的读取入口与次数限制。
- PDF 能力：解析工具、跨页条款与表格处理方式，无法识别结构时的处理。
- 异常恢复：父块缺失、版本错配和索引残留的发现与修复方式。
- 评测依据：独立分块对照、基线配置、条件遗漏案例及 token/耗时记录。

#### BM25 与 BGE-M3 混合检索、RRF 融合及重排

简历表述：融合 BM25 与向量检索，经 RRF 合并候选、BGE Reranker 重排，并按知识库范围和用户权限过滤；Recall@10 从 0.71 提升至 0.89，MRR@10 从 0.62 提升至 0.78。

##### 快速回顾

| 项目 | 内容 |
| --- | --- |
| 核心思路 | BM25 精确匹配 + BGE-M3 语义召回 → RRF 融合 → Reranker 精排 |
| 初始召回配置 | BM25 Top 50 + 向量 Top 50 → RRF 取 50 → 重排取 10 个子块 |
| RRF 初始参数 | 平滑常数 k=60，BM25 与向量权重 1:1 |
| RRF 调参参考 | k 可比较 20、60、100；权重可比较 1:1、1.5:1、1:1.5 |
| 输入预算参考 | Reranker 1024 tokens，受所选模型长度上限约束 |
| 测评集与结果 | 200 余道题；Recall@10：0.71 → 0.89；MRR@10：0.62 → 0.78 |

##### 职责与实现概述

养老政策查询既有政策名称、条款编号等精确表达，也有“老人吃饭穿衣困难，能申请什么帮助”这样的口语化需求。BM25 负责关键词匹配，BGE-M3 负责语义召回，RRF 汇合两路候选，BGE Reranker 进一步筛选直接回答问题的条款，覆盖两类查询。

实现上，先将可确定的知识库、权限和时间条件下推到检索，再由 BM25 匹配关键词、BGE-M3 补充语义召回；两路子块通过 RRF 按排名融合，再用 BGE Reranker 对问题和候选正文联合评分。装配证据前回查文档状态、权限和适用版本，随后回溯父块补全上下文，避免只凭文本相似度决定回答依据。

在 200 余道题的离线测评集上，原始系统与最终检索链路对比，Recall@10 从 0.71 提升到 0.89，MRR@10 从 0.62 提升到 0.78：前十条结果的标准证据覆盖率提高，首条正确证据的排序也得到改善。

##### 原理与选型

<!-- question-id: q-3cd773172a64 -->
###### 为什么要混合检索？

面试回答：

养老资料查询有两类表达需要同时照顾。一类包含明确的政策名称、条款编号或专业术语，BM25 的关键词匹配比较合适；另一类是用户用日常语言描述需求，和文档原文用词差异很大，需要 BGE-M3 的语义检索补充。

比如用户问“老人自己吃饭穿衣都困难，能申请什么帮助”，文档可能写的是生活自理能力、失能等级和照护补贴，纯关键词检索容易漏掉。反过来，纯向量检索也可能找到主题相近但条件不符的内容。两路并行召回，再用 RRF 融合和 Reranker 筛选，能够扩大证据覆盖并进一步判断相关性。

实现细节：

“养老机构等级评定的申请材料”这类含明确术语的查询适合检查 BM25；口语化需求适合检查语义召回。两路候选再按地区、时间、权限和条款内容筛选，确定足以回答问题的依据。

| 检索方式 | 擅长处理 | 容易出现的问题 |
| --- | --- | --- |
| BM25 | 政策名称、条款编号、机构名称、明确术语 | 用户与原文用词差异大时可能漏召回 |
| BGE-M3 向量检索 | 同义表达、自然语言描述、语义相近问题 | 可能召回主题相近、具体条件却不匹配的内容 |

<!-- question-id: q-8c1ed50524f1 -->
###### BM25 和 BGE-M3 如何工作，为什么这样配合？

面试回答：

BM25 是基于倒排索引的关键词相关性计算，主要看查询词出现的频率、词的区分度和文档长度。少见且准确命中的词通常更有价值，同一个词重复出现带来的加分会逐渐饱和，避免长文档单纯靠重复词占优势。

BGE-M3 在这里使用 dense 向量能力。入库时把子块编码成向量，查询时把用户问题用兼容的模型和编码方式生成向量，再交给 Milvus 查找相近结果。BM25 更直接利用词面匹配，BGE-M3 补充不同表达之间的语义关联，两路返回后按同一子块 ID 进行融合。

这样配合的业务依据是，政策名称和条款编号要求词面命中，用户的日常表达需要语义匹配。BGE-M3 提供中文及多语言语义表示，选型评估关注养老领域的证据召回、推理延迟和部署成本。

实现细节：

BGE-M3 支持多种检索形式，本项目这一路使用 dense，关键词召回仍由 BM25 完成。查询与文档必须保持模型版本和编码配置兼容，否则向量距离无法按原有口径比较。

两路索引需要携带能对应到同一子块和文档版本的标识。融合时，两个不同版本的相似条款不能因标题相同就合并。

<!-- question-id: q-99a674428380 -->
###### 为什么用 RRF，不能直接把两路分数相加吗？

面试回答：

BM25 分数和向量相似度的含义、数值范围都不同，直接相加会让数值范围更大的通道主导结果。RRF 将各路结果转换成排名贡献，再按稳定的子块 ID 合并，减少对原始分数尺度的依赖。

一个子块在两路里都排名靠前时，会得到两路加分；被单路召回的候选也能保留。RRF 依据名次合并结果，后续 Reranker 联合读取问题和正文，进一步判断条款与当前需求的相关性，两者分别承担候选融合和内容精排。

实现细节：

计算使用 `RRF(d) = Σᵢ wᵢ / (k + rankᵢ(d))`。排名从 1 开始，`wᵢ` 是通道权重，未出现在某一路中的候选不获得该路分数。`k` 是平滑常数，与召回 Top-K 数量无关。同一子块分别排第 2、第 4 时，融合分数为两路贡献之和。

<!-- question-id: q-06a2fc0419d9 -->
###### 已经做了 RRF，为什么还要 BGE Reranker？

面试回答：

RRF 按两路排名合并候选，BGE Reranker 将问题与候选子块成对输入、联合读取，细化内容相关性判断。两阶段配合，先汇集关键词与语义召回，再优先选出能回答当前问题的条款。

比如两段内容都讨论补贴，语义上都接近，但用户问的是申请材料，Reranker 可以更细地判断哪一段真正列出了材料要求。因为这种联合评分成本较高，我们只对融合后的有限候选使用。地区、权限、时间和版本仍然由硬条件过滤处理，相关性分数再高也不能让不适用的资料进入回答。

实现细节：

双塔向量召回分别编码查询和子块，重排则联合输入二者。两者的计算方式与成本不同。RRF 改变候选池，Reranker 在候选池内排序，候选阶段漏掉的依据无法靠精排补回。

| 环节 | 依据 | 作用与边界 |
| --- | --- | --- |
| RRF | 候选在各通道中的排名 | 合并不同通道，不读取正文判断具体条件 |
| BGE Reranker | 问题与候选文本联合输入 | 精细判断相关性，成本较高 |
| 硬条件过滤 | 权限、地区、时间和版本 | 确定证据是否适用，不能由相关性分数替代 |

##### 实现与调参

<!-- question-id: q-51aee20be27b -->
###### 完整检索链路与权限、时间过滤如何配合？

面试回答：

收到问题后，先确定用户可访问的知识库、地区和时间范围，把能够提前确定的过滤条件下推到两路检索。BM25 和 BGE-M3 并行召回子块，按子块 ID 对齐后做 RRF 融合，再交给 BGE Reranker 精排。

候选返回后，还会回查入库状态、文档版本和当前访问权限，防止索引更新滞后。确认可用后，按父块聚合、补充条款上下文，并按 token 预算装配证据，最终生成带 Evidence ID、文档和页码的回答。时间过滤根据用户问题确定，历史查询保留当时适用的版本，不能一律只取最新文件。

过滤后按问题维度检查证据覆盖。缺少旧版清单、适用条件等必要依据时，针对缺口继续查询；新增候选沿用相同的权限、时间和相关性校验。缺少用户条件时先澄清，执行预算耗尽时返回已确认部分及待补依据。

实现细节：

过滤依据分工如下。进入任何模型服务前都应满足该服务的访问边界；后置复核用于处理状态变化，不替代前置权限约束。

| 检查位置 | 依据 | 处理内容 |
| --- | --- | --- |
| 两路召回前 | 后端认证范围、用户明确的地区和时间 | 下推可确定的过滤条件，模型参数不能扩大范围 |
| 候选回查 | 权威文档版本、入库状态、当前访问权限 | 排除未完成入库、关联错误或无权使用的证据 |
| 父块装配 | 相同文档与版本的父子关系、原文位置 | 防止回溯时混入另一个版本的正文 |
| 有效候选不足 | 尚缺的比较维度、剩余时间与调用预算 | 补查仍缺的依据，或结束并说明缺口 |

例如精排前十中有四条未通过复核，当前可用候选就是六条；这六条覆盖全部问题维度时，无须补足十条。若缺少旧版材料清单，则需要补旧版依据，新增候选也必须重新校验。

<!-- question-id: q-e1b1c6bc685b -->
###### 两路各召回多少条？

面试回答：

我们的初始配置是 BM25 和向量检索各取 Top 50，按子块 ID 去重后最多得到 100 个候选，RRF 融合后取前 50 个交给 Reranker，再取精排前 10 个子块。这里的十个是精排结果，仍要经过状态、版本和权限复核。之后回溯父块、去重，并根据上下文预算决定真正装入多少证据。

前面保留较多候选，给融合和精排留下筛选空间；候选池扩大时同时增加重排开销。调参可比较 20、50、100 等数量下的覆盖率、最终排序和延迟。前十子块经过校验、父块聚合与预算装配后，形成最终提供给模型的证据。

实现细节：

表中记录初始配置。调参时根据两路有效候选分布调整召回名额，比较候选覆盖率、最终排序和延迟。子块排序指标在父块扩展前统计，条件覆盖在父块装配后检查。

| 阶段 | 初始配置数量 | 输入与输出 |
| --- | --- | --- |
| BM25 | Top 50 | 查询 → 关键词候选子块 |
| BGE-M3 / Milvus | Top 50 | 查询向量 → 语义候选子块 |
| ID 对齐与 RRF | 去重后最多 100，取前 50 | 两路候选 → 重排候选 |
| BGE Reranker | 精排前 10 个子块 | 问题与候选正文 → 待复核的排序结果 |
| 证据放行与父块回溯 | 由校验、去重和 token 预算决定 | 校验子块、聚合父块，再按预算装配证据 |

<!-- question-id: q-536bd6dc0807 -->
###### RRF 参数怎么调？

面试回答：

主要看平滑常数 k 和两路权重，初始采用 k 等于 60、BM25 与向量权重 1 比 1。调整 k 时先固定召回和重排配置，观察头部与后部候选的变化。k 小时更强调头部名次，k 大时排名贡献的差距会缩小。

然后根据错误分析调整权重。精确名称、编号类问题不足时，比较偏向 BM25 的配置；口语化问题漏召回较多时，比较偏向向量检索的配置。每次少量改变参数，同时看重排前的证据覆盖和重排后的 Recall@10、MRR@10，避免只看最终排序，忽略候选池已经发生的变化。

实现细节：

可比较 k 为 20、60、100，权重为 `1:1`、`1.5:1`、`1:1.5`。选择配置与报告最终结果使用分开的题目，近似改写分到同一组，减少数据泄漏。平滑常数 k 调整排名贡献差距，Top-K 单独控制候选数量。

| 参数 | 初始配置 | 调参参考 | 主要观察 |
| --- | --- | --- | --- |
| 平滑常数 k | 60 | 20、60、100 | 头部与后部排名贡献的差距 |
| BM25 : 向量权重 | 1:1 | 1:1、1.5:1、1:1.5 | 精确术语与口语表达的覆盖 |
| 候选与最终结果 | 配置分别记录 | 分开调参，固定其他条件 | 重排前覆盖率、最终 Recall@10 与 MRR@10 |

<!-- question-id: q-376a2233e497 -->
###### Reranker 输入如何截断？

面试回答：

Reranker 的输入包含问题、文档标题、章节路径和子块正文。长度预算需要用对应模型的 tokenizer 计算，先给问题、标题和输入格式预留空间，再分配正文预算。因为重排对象是子块，通常不需要直接处理整个父块。

遇到超长表格或片段，可以按段落、句子或表格结构拆成多个窗口，每个窗口保留必要标题和表头，再分别评分。这样能保留后部的相关内容，减少统一截取开头造成的遗漏。重排判断的是相关性，生成答案时还要读取足够的条件和例外，原文与页码映射也要保留。

实现细节：

工程输入预算可从 1024 tokens 起比较，并受所选 Reranker 的实际支持长度约束。使用对应 tokenizer 计算总长度，扣除问题、标题和输入格式开销后，得到正文预算。

多窗口方案取最高分时，以最相关局部作为候选排序依据；生成答案时再补全所属条款的适用条件与例外。窗口数量设上限，以控制推理开销。

<!-- question-id: q-88169aa973ab -->
###### 某一路故障怎么降级？

面试回答：

两路检索设置独立超时，某一路失败时尽量保留另一路的有效结果。BM25 不可用就使用向量候选，向量编码或 Milvus 不可用就使用 BM25 候选；如果 Reranker 失败，就用 RRF 排序结果兜底，并记录实际走了哪条链路。

降级后继续检查问题维度的证据覆盖，必要时补查或澄清。正常无命中时改写查询，通道故障时有限重试并使用可用路径。权限与版本校验是各条路径共同的放行条件，校验服务不可用时暂停返回未经验证的证据。

实现细节：

记录通道错误、耗时和实际使用链路，便于定位质量变化来源。重试使用剩余超时预算，单路超时后及时切换可用路径。

| 情况 | 可用路径 | 限制 |
| --- | --- | --- |
| BM25 故障 | 使用向量候选继续处理 | 记录通道降级 |
| 向量编码或 Milvus 故障 | 使用 BM25 候选继续处理 | 记录通道降级 |
| Reranker 故障 | 使用 RRF 排序兜底 | 检查证据是否充分 |
| 正常返回但无命中 | 改写查询或澄清条件 | 区别于通道故障 |
| 权限或版本校验不可用 | 暂停放行该批证据 | 待校验通过后继续处理 |

##### 评测与结果

<!-- question-id: q-d1418839f3a8 -->
###### 评测集怎么构建？

面试回答：

我围绕养老政策、机构制度和服务资料构建了 200 余道题，用来评估检索改动。评测集要兼顾精确条款、口语表达、多条件和时间版本问题，每道题的正确依据需要能定位到文档版本与原文范围，才能判断系统是否真正找到了足以回答的内容。

标注以“足以支持回答”为标准：询问申请材料时，标准证据应包含材料要求及必要条件。检索评测核对原文依据的召回，回答评测核对条件与引用的完整性，无答案和条件不足题则单独检查拒答与澄清行为。

实现细节：

标准证据标到原文条款或范围，方便不同分块方案映射。按精确条款、口语表达、多条件和时间版本题分类分析，可以分别定位词面匹配、语义匹配、条件完整性与版本适用性问题。

建议标注项包括问题、参考答案、标准证据范围、文档版本、必要条件和题型。同一条款被多个重叠块命中时，应按统一证据单位去重。近似改写应按组划分，避免落到不同集合。

<!-- question-id: q-4ad77f37e66d -->
###### 测评基线具体是什么？

面试回答：

基线是改造前的原始系统，对照是包含父子分块、BM25 与 BGE-M3 混合召回、RRF 和重排的最终检索链路。在 200 余道题的离线测评集上，Recall@10 从 0.71 提升到 0.89，MRR@10 从 0.62 提升到 0.78，评价的是整套链路的证据覆盖与排序。

定位各环节收益时，采用组件对照方案：固定文档、分块、过滤规则和测评集，依次比较单路检索、两路融合及增加重排的效果；分块收益通过固定检索配置的另一组对照评价。整体对比回答链路是否改善，组件对照定位收益来源。

实现细节：

实验记录需补齐原始系统与最终系统的完整配置、文档快照和结果文件。下表列出用于定位收益来源的组件对照方案，各组使用固定分块；父子分块对照单独固定检索与重排配置。

组件对照方案如下。

| 组别 | 检索配置 | 比较目的 |
| --- | --- | --- |
| A | BGE-M3 单路向量检索 | 观察语义单路表现 |
| B | BM25 单路检索 | 观察关键词单路表现 |
| C | BM25 + 向量 + RRF | 观察两路互补与融合收益 |
| D | C + Reranker | 观察精排收益 |
| 原始系统 → 最终系统 | 固定评测口径，另存完整配置 | Recall@10：0.71 → 0.89；MRR@10：0.62 → 0.78，为整体收益 |

<!-- question-id: q-d5f8a91406e1 -->
###### Recall@10 和 MRR@10 如何计算，这次提升说明什么？

面试回答：

按标准证据召回的定义，Recall@10 看前十条结果找回了多少标准证据，占这道题全部标准证据的比例，再对题目汇总。MRR@10 则看第一条正确结果排在哪里，第一名得一分，第二名得二分之一，前十都没有正确结果就得零，再计算平均值。

Recall 关注证据覆盖，MRR 关注第一条正确证据的排序。多证据问题中，MRR 反映模型多早能读到第一条正确依据，Recall 反映所需依据找回了多少。项目两项指标同时提升，说明最终链路在前十条结果的证据覆盖和首条正确证据排序上均有改善；回答质量再按条件完整性和引用支持情况检查。

实现细节：

设有标准证据的评测题共 N 道，Gq 为第 q 题的标准证据集合，Rq,10 为前十条结果映射、去重后的证据集合。标准宏平均口径为：

- `Recall@10 = (1/N) × Σq |Gq ∩ Rq,10| / |Gq|`。
- `MRR@10 = (1/N) × Σq reciprocalRank(q)`；首条正确结果排名 r≤10 时取 `1/r`，否则取 0。

例如一道题需要证据 A、B，前十仅在第 2 名命中 A，则该题 Recall@10 为 1/2，倒数排名为 1/2。同一原文被多个重叠子块命中不重复计证据。判断命中所需的原文范围覆盖规则也要固定，不能只看主题相似。

“前十是否至少命中一条正确证据”的题目比例通常称为 Hit@10；每题只有一条标准证据时，它与上述宏平均 Recall@10 一致。无答案题没有普通 Recall 的有效分母，应单独报告；宏平均、微平均和 Hit 口径也不能混用。

子块排序与父块补全后的证据覆盖需分开记录。

##### 补充记录

- 原始基线：旧系统的分块、召回、过滤、融合和重排配置，以及最终系统的对应版本。
- 指标口径：Recall 的分母与汇总方式、MRR 的正确命中定义、证据去重单位、统计阶段、无答案题处理及原始结果文件。
- 评测集：题型与数量、标注字段和复核流程、调参与最终评测是否分开、近似改写是否按组划分。
- 实验记录：实际完成的 Top-K、RRF 参数组合与组件消融，各组质量和耗时结果；初始配置与最终采用配置分开记录。
- 检索实现：全文索引引擎、中文分词、BGE-M3 部署版本及距离度量。
- 重排实现：Reranker 版本、tokenizer、实际输入预算、超长截断/分窗及分数聚合规则。
- 有效候选：后置校验位置、未完成入库版本的过滤，以及候选不足后的补位、扩召回和停止条件。

#### ReAct Agent 与 Plan-and-Execute

简历表述：基于 ReAct 实现检索和工具调用，引入 Plan-and-Execute 支持多步任务规划与执行，并结合滑动窗口和历史摘要管理上下文。

##### 快速回顾

| 项目 | 内容 |
| --- | --- |
| ReAct | 根据每次工具结果决定继续检索、补充条件、澄清或回答 |
| Plan-and-Execute | 将复杂任务拆成步骤，跟踪完成情况，按执行结果调整计划 |
| 配合方式 | 计划管理整个任务，步骤内部按需使用 ReAct |
| 执行边界 | 后端校验工具参数、权限、知识库范围和时间条件；设置执行上限 |
| 上下文管理 | 滑动窗口与历史摘要管理对话，计划、状态和证据单独跟踪 |
| 完成条件 | 覆盖问题要求，检查版本、必要条件和引用，说明缺失或冲突 |
| 计划与恢复 | 结构化保存步骤、证据和预算，恢复时核对状态与证据适用性 |
| 防止重复 | 复用仍适用的查询结果，检查证据增量，调整无进展的检索方向 |
| 摘要约束 | 地区、时间、对象和输出要求显式保留，区分已确认与尚缺条件 |

##### 职责与实现概述

政策查询的依据常分散在正文、附件和关联通知中，政策变化分析还需要对齐多个版本与比较维度。查询流程用 ReAct 根据工具结果补查依据，用 Plan-and-Execute 管理多步任务，分别解决局部证据补全和整体任务覆盖问题。

普通查询采用 ReAct，由 Agent 根据工具结果选择下一步：证据不足时继续检索，查询条件需要调整时改写查询，用户信息缺失时先澄清。政策分析和制度对比采用 Plan-and-Execute，先明确对象、时间和比较维度，再拆成查版本、提取条款、比较差异等步骤；每一步内部仍可使用 ReAct 补充证据，并根据执行结果调整计划。

我参与设计上述检索与工具调用流程。后端执行前检查参数、权限和检索范围，按调用次数和超时预算控制执行；对话通过滑动窗口和历史摘要管理长度，计划与证据单独跟踪。汇总时逐项核对问题要求与引用，最终结论关联 Evidence ID、文档和页码。

##### 原理与选型

<!-- question-id: q-78fd410028ea -->
###### ReAct 是什么，怎么运行？

面试回答：

ReAct 是让模型判断和工具调用交替进行的一种 Agent 执行方式。在我们的养老知识问答里，模型会根据当前问题和已经拿到的证据，决定下一步调用哪个工具；工具返回结果后，再判断是否需要继续检索，还是已经可以回答。

比如用户询问能否申请护理补贴，Agent 会先检查地区、照护等级这些必要条件是否齐全，缺少时向用户澄清。查到政策后，如果申请条件还引用了另一份认定办法，就继续检索对应资料，补齐回答依据。

模型负责提出工具调用和参数，后端负责参数、权限及时间范围校验。同时设置调用次数和超时上限，结束前检查证据与引用是否齐全，避免反复检索或依据不足就给出结论。

实现细节：

执行循环为接收问题、判断证据缺口、生成调用、后端校验执行、回传结果、再次判断。工具以结构化状态返回命中、无命中或错误，模型根据实际结果选择下一步动作。

例如，模型提出检索“申请材料”的调用后，后端验证参数与访问范围，将“已找到正文，材料清单位于附件”的结果交回模型。模型据此提出读取附件，执行器再次校验并执行，取得清单后再组织回答。

<!-- question-id: q-8b209b4434e0 -->
###### 为什么还需要 Plan-and-Execute？

面试回答：

ReAct 适合根据当前结果决定下一步，但政策变化分析通常包含多个版本和比较维度，如果一直局部补查，容易漏掉子问题，或者反复搜索同一部分。所以我们在复杂任务中引入 Plan-and-Execute，先拆解目标，再按步骤执行和检查完成情况。

比如比较政策调整前后的申请条件、补贴标准和材料要求，要先确认地区和时间，找到两个适用版本，再分别提取这些维度，最后核对差异和引用。计划会记录哪些步骤已完成、缺什么证据。如果执行中发现文件被替代或附件缺失，可以调整计划；某一步需要动态补查时，内部仍然使用 ReAct。

规划适用于文件关系和证据缺口会随检索结果变化、需要动态增补步骤的任务。步骤与数据来源固定时采用程序工作流，简单查询直接检索；这样把规划、检查和重规划调用集中用在多版本、多维度分析上。

实现细节：

计划按任务目标、比较维度和依赖拆解，完成条件与证据关联。补充检索解决局部缺口，重规划处理目标分解或依赖发生变化的情况，并保留已有有效证据与执行记录。

以说明机制的政策对比为例：

| 执行阶段 | 计划或结果 | 下一步处理 |
| --- | --- | --- |
| 形成计划 | 找新旧版本，再比较条件、标准、材料 | 执行器检查步骤与依赖是否可执行 |
| 查询返回 | 新版正文已取得，材料要求指向附件 | 当前步骤补查附件 |
| 发现范围变化 | 原拟比较文件已被另一通知部分修订 | 模型提出调整版本定位或新增关联文件步骤 |
| 接受调整 | 检查任务约束、工具范围和剩余预算 | 执行器接受合法调整，再继续执行 |
| 汇总 | 每个比较维度关联两侧证据或缺失原因 | 检查覆盖后组织结果 |

<!-- question-id: q-7d69dc127e73 -->
###### 何时使用 ReAct、何时使用 Plan-and-Execute？

面试回答：

主要根据对象数量、时间版本、输出维度和步骤依赖判断。查询一个明确条款时，直接检索就可以；需要根据工具结果继续查附件或补条件时，使用有执行上限的 ReAct 循环。

任务同时比较多个版本或机构制度，并要求按多个维度给出结论时，用 Plan-and-Execute 管理步骤与依赖。步骤内部按需使用 ReAct，比如查旧版申请条件时，先查正文，再沿引用补查认定办法。按任务结构选择执行方式，可以将模型调用用在需要动态决策的环节。

实现细节：

整体计划负责步骤、依赖和完成状态；步骤内部的 ReAct 负责根据工具结果继续行动。复杂度由任务结构决定，同样长度的问题可能具有完全不同的证据要求。

职责分工上，模型负责提出查询、计划和后续动作，后端负责合法工具集合、参数、权限与预算等确定性约束，执行器根据通过校验的结果推进步骤。

| 场景 | 处理方式 |
| --- | --- |
| 查询一个明确条款 | 直接检索，必要时补查 |
| 根据工具结果继续调查 | 有边界的 ReAct 循环 |
| 政策变化分析、多机构制度对比 | 先规划再执行，步骤内部按需使用 ReAct |

##### 工具与计划

<!-- question-id: q-f4d373bc2112 -->
###### 工具怎样定义？

面试回答：

工具按明确的业务能力划分，比如知识检索、读取证据原文和查询文档版本。每个工具都提供名称、适用场景、输入 Schema 和结构化返回值，让模型知道什么时候调用、参数怎么填、结果代表什么。

以知识检索为例，输入包含查询文本、文档类型、时间条件和返回数量，成功时返回片段、Evidence ID、文档版本和页码；失败时返回错误类型和是否可重试。用户身份和可访问范围由后端认证上下文确定，模型填写参数不能扩大权限。结果正文也控制长度，先返回必要片段，需要完整条款时再调用原文读取工具。

实现细节：

工具描述应区分检索、原文读取与版本查询的用途。返回状态明确区分成功无命中、参数错误和服务异常，便于模型选择改写查询、修正参数或结束。数量与字段类型仍由后端检查。

| 部分 | 知识检索工具示例 |
| --- | --- |
| 工具名称 | `search_knowledge` |
| 用途 | 根据问题检索政策或机构制度证据 |
| 输入 | 查询文本、文档类型、时间条件、返回数量等 |
| 成功返回 | Evidence ID、文档版本、页码、片段及检索状态 |
| 失败返回 | 错误类型、是否可重试、错误说明 |

<!-- question-id: q-0d08ae0f6c35 -->
###### 模型如何选择工具？

面试回答：

后端会把当前任务允许使用的工具说明和参数 Schema 提供给模型。模型结合用户目标、当前步骤和已有结果，生成结构化的工具名和参数；后端根据工具名找到处理器，完成类型、范围与权限校验后执行，再把结果交回模型。

工具说明要写清能力边界，比如找资料用检索工具，已经拿到 Evidence ID 但需要完整条款时用原文读取工具，确认某个时间点适用哪个文件时用版本查询工具。模型提出的调用不会直接执行，未知工具、错误参数或越界数量会被拒绝并返回具体错误，允许模型在合法范围内修正。

实现细节：

工具是否可用由后端决定，模型选择只发生在当前允许的能力范围内。调用参数不能充当身份或权限凭据，结果再次进入上下文后才触发下一轮判断。

工具调用与返回的对应关系如下：

```json
{
  "call": {
    "name": "search_knowledge",
    "arguments": {"query": "护理补贴申请材料", "documentType": "policy", "topK": 5}
  },
  "result": {
    "status": "ok",
    "evidence": [{"evidenceId": "E1", "documentVersionId": "V1", "page": 4}],
    "missing": ["正文引用的材料清单附件尚未取得"]
  }
}
```

认证范围由后端从当前身份上下文补充。无命中与工具执行错误通过不同返回状态表达，分别触发查询调整和故障处理。

<!-- question-id: q-88d4c07776c3 -->
###### 计划用什么结构保存？

面试回答：

计划需要保存成可更新的结构化任务，至少包含目标、地区和时间等约束、步骤列表及依赖。每个步骤记录状态、完成条件、工具结果和关联证据，根任务记录累计预算。这样执行器能够判断下一步是否满足依赖，也能区分尚未执行、正在执行和已经完成。

重规划时保留调整前的执行记录，并检查已有证据是否仍适用。自然语言描述表达步骤目标，结构化字段记录状态、依赖与完成条件。进程重启恢复需要将计划、执行结果和累计预算持久化，恢复时据此定位未完成步骤。

实现细节：

计划状态定位执行进度，工具结果保存实际产出，对话摘要压缩交流背景。结构化计划包含以下字段。

| 层级 | 主要字段 |
| --- | --- |
| 根任务 | `taskId`、用户与权限范围、目标、状态 |
| 约束 | 地区、时间、文档范围、对比维度 |
| 计划 | `planVersion`、步骤列表 |
| 每个步骤 | `stepId`、目标、依赖、完成条件、状态 |
| 执行记录 | 工具及参数、结果、错误、Evidence ID |
| 执行预算 | 已用步数、模型与工具调用次数、截止时间 |

例如 S1 定位版本，S2 依赖 S1 提取条款。S1 在版本记录取得、校验通过且结果保存后完成，随后推进 S2；提取条款时发现“材料见附件”，则为 S2 保留附件补查项，取得对应清单后再检查该维度是否完成。

##### 执行与恢复

<!-- question-id: q-98d082aca9dc -->
###### Agent 怎么知道任务完成了？

面试回答：

任务按用户目标定义完成条件。政策对比需要定位两个适用版本，分别取得申请条件、补贴标准和材料要求的依据，再按维度给出差异与引用。执行器检查步骤状态、工具结果、引用 ID 和执行预算，模型结合原文判断维度覆盖与证据缺口。

执行同时受步数、调用次数和总超时限制。预算内围绕未完成项继续查证；到达上限时返回已确认部分，并逐项列出尚缺的证据或用户条件。完成状态和停止原因分别记录，便于后续继续处理。

模型提出结束后，后端核对引用归属、来源与访问权限，内容核验再检查每项结论是否由所引原文支持。

实现细节：

政策对比还需核对地区、适用时间及文件关系；附件缺失、条款冲突等未解决项保存在任务记录中，作为后续补查入口。

可核验的完成项包括“新旧版本已定位”“三个维度均有证据或缺失说明”“引用均属于当前可用证据”。

<!-- question-id: q-0c810c53fde2 -->
###### 任务如何暂停、恢复和限制步数？

面试回答：

暂停与恢复以持久化的任务状态为基础：保存步骤、checkpoint、已有证据和累计预算，再停止发起新调用。恢复时加载记录，重新检查当前权限、文档版本和证据适用性，从未完成且依赖已满足的步骤继续执行。

在途调用按工具能力处理：支持取消时发送取消请求，结果不确定时保留调用记录，恢复前核对实际结果。步数、重规划次数、模型和工具调用次数及总时间按同一任务累计，重试和恢复沿用剩余预算。

实现细节：

暂停点应位于可保存状态、可判断后续行为的安全边界。证据失效或权限变化时，恢复位置需相应调整；较长结果通过记录 ID 读取，并继续遵守上下文预算。

例如“工具已返回、步骤尚未记为完成”时，恢复要先核对该次调用结果是否已保存，避免无条件再次调用。若采用绝对截止时间，暂停期间时间仍会流逝；若限制活跃执行时长，则需要另外累计实际运行时间，两种预算规则要明确。

| 环节 | 保存或检查 | 处理原则 |
| --- | --- | --- |
| 暂停 | 任务、步骤、checkpoint、证据与已用预算 | 保留已经完成的部分 |
| 恢复 | 当前权限、证据适用性与未完成位置 | 从可继续的位置执行 |
| 重试与重规划 | 累计步数、调用次数和截止时间 | 共用累计预算，不重新计零 |

<!-- question-id: q-ea324c65901d -->
###### 工具失败怎么处理？

面试回答：

工具失败按错误类型处理。参数错误返回具体字段问题，让模型修正；超时和连接异常在剩余预算内有限重试；单路检索不可用时，使用其他可用通道。权限不足则停止这次访问，不能靠修改参数绕过。

工具正常执行但无命中时，改写查询、补充条件或报告缺失依据；服务故障则按错误类型重试或降级。正文已取得而附件获取失败时，复用正文证据，继续处理附件缺口。预算耗尽后返回已确认部分及待补材料。

实现细节：

工具返回应包含错误类型、错误说明和可重试信息。重试与降级计入累计预算，已完成步骤和已取得证据保留；附件未取得时，不生成依赖附件内容的确定结论。

| 失败情况 | 处理方式 |
| --- | --- |
| 参数错误 | 返回明确字段错误，让模型修正 |
| 超时、连接异常 | 在剩余预算内有限重试 |
| 单路检索不可用 | 使用其他可用通道并记录降级 |
| 权限不足 | 停止该访问，不能通过换参数绕过 |
| 正常执行但无结果 | 改写查询、补充条件或说明未找到 |
| 必要证据无法取得 | 保留已完成部分，说明缺失项 |

<!-- question-id: q-51a63214b157 -->
###### 如何避免重复检索？

面试回答：

重复检索按查询文本、地区、时间、知识库和权限范围共同识别。相同范围内复用仍适用的结果；地区、时间或版本改变后，重新查询对应范围的证据。

每轮还要检查新增证据是否覆盖未完成维度。补贴标准已经查到、申请材料仍缺时，下一步定向查询材料或读取附件，把调用集中在能推进任务的证据缺口上。

实现细节：

进展按文档版本、稳定原文位置和比较维度判断。同一原文在不同轮次分别编号 E1、E7 时，仍按同一份来源去重。Evidence ID 的生命周期与跨轮复用规则和政策溯源模块统一。

请求复用还需核对过滤范围和当前权限。

##### 上下文与摘要

<!-- question-id: q-f72a64172e9a -->
###### 上下文如何裁剪？

面试回答：

上下文优先保留当前问题、用户刚补充的条件、任务约束和当前步骤，再按预算装配相关证据、近期消息和历史摘要。近期对话用滑动窗口保留，较早内容压缩为摘要；计划、步骤状态和证据记录单独跟踪，不完全依赖聊天历史。

检索结果先去重，按完整条款条件提取相关片段；长工具结果移出上下文后保留记录 ID，按需读取。预算计入工具 Schema、消息结构和引用信息，并预留输出空间。工具调用与返回成组保留，政策结论使用本次核验适用的原文证据。

实现细节：

上下文装配同时管理对话背景、任务状态和证据，三者用途见表。可用输入预算从模型总窗口中扣除输出预留，再计算指令、工具 Schema、消息格式、当前问题、摘要与证据的合计长度。

例如用户从“今年本市政策”改成“去年另一地区政策”，更新当前约束并重新检查旧证据适用性，后续查询采用用户最新明确的地区和时间。

| 内容 | 作用 |
| --- | --- |
| 最近消息与历史摘要 | 理解用户意图和对话背景 |
| 计划、步骤状态、已取得的证据 | 跟踪当前任务进展 |
| 文档、版本、页码和 Evidence ID | 核对结论依据 |

<!-- question-id: q-b571d44affb4 -->
###### 摘要如何防止遗漏关键条件？

面试回答：

地区、时间、对象和输出要求作为显式任务约束，每次装配上下文都保留；摘要负责压缩对话背景。两者配合，使长对话压缩后仍按明确条件检索和回答。

用户修改条件时更新对应字段，后续查询使用新值；尚未提供的信息保留为待澄清项。摘要区分用户提供、工具确认和尚待确认的内容，重要事实保留来源消息或证据记录，发生冲突时回到原始记录核对。

实现细节：

政策比较任务的结构化约束包括地区、适用时间、指定机构或版本、比较维度、引用要求和尚缺信息。字段同时保留来源和确认状态，任务进度按证据与完成条件推进。

例如用户先问本市政策，随后改为邻市，摘要和当前条件发生冲突时，以用户明确修改及来源消息核对，相关旧证据也要重新检查。

##### 验证与结果

<!-- question-id: q-2b1f21f72919 -->
###### 如何验证 Agent 规划和上下文管理有效，成本是否可控？

面试回答：

验证要看任务是否完成，也要看为此多花了多少调用。简单条款查询可以比较直接检索与 ReAct，多版本、多维度对比则比较固定流程、ReAct 和规划执行，重点检查是否漏掉比较维度、是否反复检索、工具选择是否正确，以及缺证据时能否合理停止。

上下文管理用长对话案例验证：将地区、时间、对象放在较早轮次，加入用户后续修改条件的情况，压缩后检查检索约束与引用版本。同时记录模型和工具调用次数、输入输出 token、总耗时及预算超限情况，评价任务覆盖与调用成本的关系。

任务评测以版本选取、比较维度覆盖、证据缺口处理和长对话条件保留为检查项，每个样例保留执行轨迹，便于定位规划、工具执行或摘要压缩环节的问题。

实现细节：

比较不同模式时固定文档快照、问题、可用工具和模型配置，避免把不同检索结果误判为规划收益。

| 验证场景 | 观察结果 | 同时记录的成本 |
| --- | --- | --- |
| 明确条款查询 | 是否引入不必要规划，能否直接取得依据 | 模型/工具调用次数与耗时 |
| 多版本多维度对比 | 维度遗漏、版本错用、无依据结论 | 规划和重规划次数、总 token |
| 附件缺失或工具失败 | 是否只补缺口、是否重复无效检索 | 重试、降级与预算消耗 |
| 长对话后修改地区或时间 | 当前要求是否覆盖旧摘要，旧证据是否被重新判断 | 压缩前后输入长度和摘要开销 |
| 达到执行上限 | 是否停止并说明未解决项 | 累计调用数与总时间 |

##### 补充记录

- 贡献与框架：个人参与设计、开发和接入的具体范围，实际 Agent 框架或执行循环。
- 决策与工具：入口模式路由、真实工具清单、重规划触发与接受规则、完成判断及内容核验主体。
- 计划存储：字段、步骤状态、存储位置、结果外置与计划版本管理。
- 恢复能力：用户暂停、进程重启恢复、checkpoint 保存时机与在途调用处理。
- 执行预算：步数、模型/工具调用和重规划次数的定义，超时规则与恢复后的累计方式。
- 上下文：滑动窗口和摘要触发配置、任务约束保存方式、摘要来源与确认状态、工具返回成组保留规则。
- 证据复用：Evidence ID 生命周期、稳定原文定位、请求复用和权限变化后的失效检查。
- 验证记录：实际模式对照、长对话条件保留案例、重复检索和成本统计。

#### 政策变化分析与证据溯源

简历表述：支持查询改写与多轮补充检索，按指定时间、政策有效期和文档版本筛选证据，并关联 Evidence ID、文档和页码。

##### 快速回顾

| 项目 | 内容 |
| --- | --- |
| 分析目标 | 明确比较对象和时间，逐维度提取条款，每项差异关联新旧证据 |
| 处理链路 | 明确范围 → 定位适用版本 → 查正文及附件 → 提取条款 → 比较 → 引用回答 |
| 时间与版本 | 区分发布、生效、失效、入库时间；区分政策版本与索引构建版本 |
| 补充检索 | 查询改写保留约束，针对缺失条款、附件和补充通知补查 |
| 证据溯源 | Evidence ID 关联文档版本、原文位置、页码和片段 |
| 结果检查 | 核对引用有效性与结论支持情况，明确缺失证据和未解决冲突 |

##### 职责与实现概述

政策变化分析的核心是把每项差异落到适用的新旧条款上。流程先明确地区、对象和比较时间，再通过查询改写、补充检索及版本筛选取得依据，按申请条件、补贴标准和材料要求等维度组织对比，帮助用户核对变化内容与出处。

处理时，先从问题中明确政策对象、地区、时间和比较维度，再定位调整前后的适用文件，提取条件、标准和材料要求。查询改写保留这些约束，涉及附件或补充通知时继续检索；版本判断区分发布时间与生效时间，并结合修订、替代和废止关系确定适用范围。

比较时保留条款的对象范围、单位和例外条件，每项变化关联新旧两侧证据。Evidence ID 记录文档版本、页码和原文片段；后端校验引用归属、来源与访问范围，内容核验检查原文对结论的支持情况。缺失附件和未解决的条款冲突按维度记录，作为补查与回答范围的依据。

##### 分析流程与检索

<!-- question-id: q-7117ab69204e -->
###### 政策变化分析具体在做什么？

面试回答：

政策变化分析要先确定比较的是哪个地区、哪项政策、哪个调整时间，再找到调整前后各自适用的文件。之后按照用户关心的维度提取条款，比如申请条件、补贴标准和申请材料，对齐后说明哪些新增、修改或保持不变。

每一项变化都关联新旧证据，并沿正文引用检查附件与补充通知。Agent 组织版本定位、条款提取和差异比较，生成前逐项核对维度覆盖与时间适用性，让用户能从结论回查两侧原文。

实现细节：

对齐记录保存“比较维度—旧条款—新条款—两侧来源—缺失项”，再生成自然语言说明。例如旧版材料要求指向附件 A、新版指向附件 B，就分别读取两份清单后比较；尚未取得旧清单时，将该维度保留为待补查项。

<!-- question-id: q-2c8afea18486 -->
###### 为什么需要查询改写和多轮补充检索？

面试回答：

用户用语和政策原文经常不一致，而且回答依据可能分散在正文、附件和补充通知里。所以第一步把用户表达转成明确的检索目标，同时保留地区、时间、政策项目等约束，缺条件就先澄清。

比如“补贴变了多少”，需要明确比较金额、覆盖对象还是发放方式。第一轮查到正文后，材料要求指向附件就继续读附件，金额规定引用补充通知就定向补查通知。每轮保留地区、时间和政策对象，围绕尚缺依据调整查询目标。

实现细节：

查询改写只改变检索表达，不擅自更改用户问题范围。补充检索以尚缺文档、条款或比较维度为目标，并复用已经取得且仍适用的证据。

例如用户已明确地区和新旧两个比较时间，原问题是“护理补贴材料变了吗”：

| 环节 | 示例输入或输出 | 保留的约束 |
| --- | --- | --- |
| 拆出目标 | 查询旧时点、新时点的护理补贴申请材料 | 地区、两个时间点、政策对象和“材料”维度 |
| 第一轮检索 | 分别取得两个时点适用的正文 | 不把两侧时间合并成仅查当前文件 |
| 发现缺口 | 旧版正文写“材料见附件 A” | 已定位的旧版本和附件关系 |
| 补充检索 | 定向读取或检索该版本附件 A | 不用其他地区或当前版同名附件替代 |

##### 时间、版本与差异

<!-- question-id: q-6d90630ccbc8 -->
###### 时间条件和文档版本怎么处理？

面试回答：

时间筛选要区分发布时间、生效时间和失效时间，版本判断还要结合修订、补充、替代与废止关系。查询时先判断用户问当前政策、历史某个时间点，还是新旧对比，再按地区、对象和适用时间选择对应证据。

比如文件六月发布、七月生效，查询六月规则时使用六月仍有效的文件，查询七月规则时再检查新规定的适用范围。政策版本记录修订与有效期，索引构建版本记录解析、分块和编码配置，入库时间记录系统收录时间，三者分别管理。

实现细节：

发布时间、生效时间、失效时间与入库时间的含义见表。版本选择以目标时间、适用对象及修订关系为依据，回查原文件的生效条款或权威发布信息确认。

文件关系记录区分整份替代、部分修订与补充适用范围，分别关联受影响的文件或条款，保留继续适用的原规定。

有效期与关系明确时，按目标时间和适用范围筛选；缺少生效时间或修订关系时，保留待确认状态并定向补查来源。日期区间端点和部分条款生效规则按原文件记录处理。

| 时间 | 含义 |
| --- | --- |
| 发布时间 | 文件什么时候发布 |
| 生效时间 | 规定从什么时候开始适用 |
| 失效时间 | 规定从什么时候不再适用 |
| 入库时间 | 系统什么时候收录文件 |

<!-- question-id: q-fc58080923d0 -->
###### 怎么判断变化，遇到版本冲突怎么办？

面试回答：

新旧条款按同一比较维度对齐，区分新增、删除、修改或未变化，同时保留对象范围、单位和例外条件。例如一个版本按每人每月补贴、另一个按服务次数结算，应先说明结算方式变化，取得可换算的服务次数等条件后再比较金额。

文件出现表面冲突时，先核对地区、对象与时间，再检查修订、替代、废止关系，以及正文附件和一般特殊规定的适用范围。关系仍待确认时，保留两侧原文及冲突项；判断要求是否取消时，补齐新版正文、附件和关联文件后核对。

实现细节：

变化分类与核对重点见表。删除判断需要文件关系或完整材料支持，检索未命中只是当前证据状态。比较金额前统一计量周期、对象与单位；无法统一的情形分别说明。

| 变化或冲突 | 判断重点 |
| --- | --- |
| 新增 | 新版本明确增加了什么要求，并保留依据 |
| 删除 | 核对修订或废止关系，不能只因新检索未命中就判断删除 |
| 修改 | 同一比较维度的新旧条款分别是什么 |
| 未变化 | 对应规定及适用范围保持一致 |
| 表面冲突 | 先检查地区、对象、时间、正文附件与文件关系，不能只按发布时间取最新 |

例如，在同一地区、对象和明确的新旧版本范围内比较申请材料：

| 比较维度 | 旧条款或清单 | 新条款或清单 | 可得出的结论 | 所需依据 |
| --- | --- | --- | --- | --- |
| 材料要求 | 旧版完整清单未列居住证明 | 新版明确要求居住证明 | 在所比较范围内新增该项材料 | 两版完整清单、修订或替代关系 |
| 金额标准 | 每人每月计算 | 按服务次数结算 | 结算方式变化，暂不能直接计算涨跌 | 两侧条款、单位与适用对象 |
| 某项要求 | 仅检索到旧版 | 新版或附件未取得 | 当前无法判断是否删除 | 需要补齐新侧证据 |

“新增”的判断依据是完整旧清单、新版明确要求及新旧适用关系；旧侧清单缺失时，继续补查旧版依据。

##### 引用与回答校验

<!-- question-id: q-2d6d9d6eb0ea -->
###### Evidence ID 和引用如何绑定原文片段？

面试回答：

检索结果经过有效性和权限检查后，整理为结构化证据记录，每条分配 Evidence ID，关联文档及版本、父子块、原文片段、页码和适用时间。模型只引用本次提供的已有 ID，最终由后端映射成文档和页码，方便用户回到原文核对。

生成后，后端检查引用 ID 是否存在、是否属于本次可用证据，以及用户当前是否有权访问。引用按具体结论绑定，例如“申请材料新增某项证明”同时关联旧版完整清单、新版要求及相应文件关系。

引用校验分为来源校验和内容核验。前者检查 ID 归属、定位与访问权限，后者通过规则、模型复核或人工评测检查原文是否支持具体结论。例如“新增居住证明”需要旧版完整清单、新版要求及适用关系共同支持，只有背景介绍的片段应判为支持不足。

实现细节：

Evidence ID 标识请求或任务内的证据记录，字段分工见表。校验时检查编号归属；跨轮复用与去重以文档版本和稳定原文位置识别来源。

长期溯源保存源文件版本、页码与页内范围，必要时关联解析构建版本和片段快照。索引重建后 chunk ID 可能变化，历史引用仍按保存的源文件定位信息解析；跨页结论关联实际支持它的各页原文。

| 字段 | 用途 |
| --- | --- |
| Evidence ID | 标识本条证据 |
| 文档 ID、版本 ID | 确认来源文件与版本 |
| 父子块 ID、原文位置 | 定位具体条款 |
| 页码或页码范围 | 跳转查看原文 |
| 原文片段 | 支持回答中的具体结论 |
| 适用时间、来源信息 | 判断证据适用性 |

结论与证据按下列形式对应：

```json
{
  "claim": "在已确认的新旧适用范围内，申请材料新增居住证明",
  "citations": ["E_old", "E_new"]
}
```

E_old 指向旧材料要求，E_new 指向新要求。程序检查两个 ID 的归属、来源和访问范围，内容核验检查清单完整性、政策关系与原文含义。结构检查失败时，重新生成合法引用或移除对应结论。

<!-- question-id: q-c4437af7e120 -->
###### 证据不足时如何响应？

面试回答：

证据不足需要区分缺少用户条件还是文档依据。地区、时间或对象不明确时，向用户澄清；正文指向的附件、通知还没取得时，继续针对缺口检索。已经确认的部分可以正常回答，尚缺依据的部分单独说明。

达到执行预算仍未查齐时，按比较维度返回已确认结论、尚缺材料和待确认项。例如新侧已有材料清单、旧侧附件缺失，就可以列出新版要求，并明确需要取得旧版附件后再判断新增或删除。

实现细节：

停止补查的原因与结论可信程度分别记录。服务故障、正常无命中和缺少用户条件需要区分，避免把系统暂时不可用表述成政策没有相关要求。

##### 验证与结果

<!-- question-id: q-7aa6832bf580 -->
###### 如何验证政策对比和引用溯源是否正确？

面试回答：

验证要以原文为标准，分别检查版本适用、差异判断和引用支持。先固定地区、对象和比较时间，准备两侧文件与参考结论，再看系统是否选对版本、是否把条件和单位对齐，以及每个变化是否都有足够依据。

引用核验逐项检查 ID 定位与原文支持。样例覆盖发布时间早于生效时间、当前已失效的历史版本、附件缺失、计量单位不同和单侧证据等情况。材料不足时，检查系统是否准确指出缺口，并将差异判断保留为待确认项。

政策分析按任务样例逐项核对版本选择、差异判断、引用定位与内容支持；证据不足样例检查是否保留已确认结果、是否准确指出待补依据。每个结论与两侧原文对应，便于复核和分类定位错误。

实现细节：

每个验证样例应保留问题、时间与对象范围、源文件版本、标准结论、两侧原文及预期缺失项。

| 场景 | 预期检查 |
| --- | --- |
| 文件六月发布、七月生效，查询六月规则 | 不把尚未生效的新规定当作六月适用依据 |
| 查询历史时点的已失效旧政策 | 按历史适用性使用旧版，同时检查当前访问权限 |
| 材料要求引用未取得的附件 | 说明该维度依据不足，不推断要求被取消 |
| 新旧计量单位不同 | 分别解释计量口径，不直接计算涨跌 |
| ID 合法但片段只讨论背景 | 结构检查通过，内容支持检查仍判不充分 |
| 同一原文跨轮获得不同编号 | 不误判新增证据或任务已有进展 |
| 索引重新分块 | 原引用仍定位到原文件版本与实际出处，不错误替换 |

核验分别记录版本选择错误、无依据的变化判断、引用定位错误和引用不支持结论，并保存所用复核方法、检查项定义和逐项记录。

##### 补充记录

- 政策元数据：时间和修订关系的来源、维护与确认者、部分修订的表示，以及未知或冲突状态处理。
- 证据标识：Evidence ID 的生命周期、跨轮复用规则及其请求/任务归属；与 Agent 的重复检索判断保持一致。
- 原文定位：源文件版本、页码/页内范围、chunk 与解析构建版本的关联，索引重建后的历史引用保留方式。
- 引用检查：实际结构校验项、结论与证据的对应形式、检查失败后的处理。
- 内容核验：语义支持复核方式、覆盖的结论类型与判定规则。
- 验证依据：已执行的政策对比与溯源样例、错误分类、复核记录及可报告的结果。

## 经历二：设备智能运维平台

### 项目概览

#### 项目背景与职责

##### 项目速览

- **研究背景**

  课题组在农业机械领域的大模型智能体应用研究

- **应用环境**

  以设备智能运维平台连接农机业务数据、专业资料与智能体工具

- **场景目标**

  知识查询有页码依据，故障排查结合设备记录，业务写入经冻结审批或明确委托后执行

- **个人职责**

  后端业务、SaaS 多租户与 RBAC 权限、Agent 工具调用、文档检索、记忆、图像识别及 MCP 接入

##### 项目背景

农机运维中的故障排查和作业调度，需要同时掌握专业知识与设备的当前状态。例如，判断液压故障要查维修手册和历史工单，安排作业要核对设备、人员、维保占用及已有任务。这些信息分布在专业资料和业务系统中，需要围绕同一台设备、同一个任务联合查询。

项目属于课题组在农业机械领域的大模型智能体应用研究，以设备智能运维平台承载资产、作业、维保和成本数据，将业务工具与知识检索接入 Agent。日常业务支持实际作业录入、执行计量、质量验收与返工，需要协调资源时提前安排；维保通过统一工单记录处理与复机验收，登记的保养周期用于到期提醒。业务工具提供当前设备和任务记录，文档检索提供手册、规范中的专业依据，Agent 据此组织查询、排查步骤和操作草案。

平台采用 SaaS 多租户结构，公共机型和知识由平台侧维护，成员、资产及业务记录由租户侧管理，租户内部按经营单元和场站控制数据范围。普通接口、Agent 和异步任务复用业务 Service，统一执行权限、状态流转和资源校验。

知识问答关联当前内容修订、发布代次和页码，便于核对原文；业务方案经冻结审批或有效委托，提交前复核当前授权、版本、指定人员与资源冲突，再写入实际记录及审计。主助手处理简单查询和最终答复，复杂调查可委派领域专家，明确的持续目标通过检查点和执行租约恢复。

##### 我的职责

**后端业务、SaaS 多租户与 RBAC 权限**

使用 Spring Boot、MyBatis 和 MySQL 开发农机资产、作业任务、维保、成本及经营分析相关接口，构建共享数据库的 SaaS 多租户体系。授权采用 RBAC，成员可以组合多个角色，每条角色授权独立绑定经营范围、范围内全部或本人相关的数据方式及有效期。

Spring Security 与 JWT 建立登录身份，后端按当前有效授权检查业务动作和数据范围，将范围条件统一应用到查询、统计与写入。负责人统一管理自定义角色、成员授权和自审策略，普通管理员按权限维护普通账号。业务 Service 同时供普通接口、Agent 和异步任务调用，执行时遵循相同的权限与业务规则。

**Agent 工作流与工具调用**

参与 Agent 工作流与工具调用实现，支持作业调度、维保建议、经营分析和知识问答。准备调度方案时查询任务要求和可用设备，检查资源与时间冲突；生成维保建议时结合设备记录和专业资料。工具执行统一处理参数、权限、超时和片段容量，业务写入绑定冻结方案及审批或明确委托，执行后记录业务回执与审计日志。AgentScope 承载 ReAct，Graph 调度动作内部 Workflow 与严格 P&E；恢复核对真实执行状态，成功或未知效果不自动重放。

**文档处理与检索**

负责文档处理与检索链路，通过 RabbitMQ 异步处理 PDF 渲染、原生文本提取和 ColQwen 页面编码，完整视觉索引成功后发布，缺文字再由 MinerU 独立补充 OCR。页面视觉检索利用维修资料的表格、图示和版面定位证据；回答前检查当前权限、内容修订和发布代次，读取对应页面或文字并返回引用。

**记忆、图像识别与 MCP 接入**

参与对话记忆和图像识别服务接入，并开发 MCP Server。首轮加载近期规范消息、摘要和显式偏好，必要时按需检索长期记忆并关联设备，再查询当前业务状态；图像识别返回候选机型及置信度，经人工复核后用于机型关联和资料查询；MCP Server 通过用户 OAuth 授权提供八项只读工具，覆盖识别、机型目录、知识、调度预览、维保准备与成本分析，后端逐次复核当前业务范围。

##### 评测结果

页面检索的离线测评中，Recall@10 达到 0.945，MRR@10 达到 0.798，NDCG@10 达到 0.839，分别衡量前十条结果的证据覆盖、首个相关结果的位置和整体排序质量。检索结果关联文档版本及页码，支撑维修资料查询中的证据定位与原文核对。
### 简历要点复盘

#### 后端业务模块、SaaS 多租户与 RBAC 权限

简历表述：负责农机资产、作业任务、维保、成本及经营分析等后端模块；构建共享数据库的 SaaS 多租户体系，基于 Spring Security、JWT 与 RBAC 实现动作权限、经营范围和本人相关数据授权，统一约束接口、Agent 与异步任务访问。

##### 快速回顾

| 项目 | 内容 |
| --- | --- |
| 业务模块 | 农机资产、作业任务、维保管理、成本管理、经营分析 |
| SaaS 结构 | 平台 → 租户 → 一层经营单元，场站用于进一步限定业务范围；共享数据库与业务表 |
| 账号归属 | 平台、租户两类账号和工作台；普通账号固定归属一个租户、一个成员关系 |
| RBAC 模型 | 成员组合多个角色，角色定义动作；六个只读模板及租户自定义角色 |
| 角色授权 | 每条授权绑定经营范围、范围内全部或本人相关、生效及到期时间 |
| 范围合并 | 同一动作的完整授权取并集，所需多个动作的范围取交集，空授权拒绝 |
| 认证与撤权 | JWT 绑定用户及会话；后端解析当前授权，成员停用撤销会话 |
| 查询与写入 | 统一 SQL 范围过滤；写入再检查状态、人员关系及并发约束 |
| 授权治理 | 负责人维护自定义角色、全部角色授权和自审策略；普通管理员按权限维护普通账号 |
| 异步与 Agent | 跨执行边界重建上下文，重新解析发起人当前授权，复用业务 Service |

##### 职责与实现概述

农机运营围绕资产、作业、维保和成本展开，经营分析需要汇总这些模块的有效记录。后端使用 Spring Boot、MyBatis 和 MySQL 实现接口、状态流转与统计查询，通过业务 Service 向普通接口和智能体工具提供统一的业务能力。

平台公共资料与租户业务分开管理，租户内部按经营单元和场站组织业务。平台账号承担租户开通和公共目录维护，租户账号固定归属本租户，业务数据采用共享数据库和应用层范围隔离。

授权采用 RBAC，将动作、经营范围、本人关系和有效期绑定为一条完整授权。同一动作的多条授权取并集，多动作共同要求的范围取交集，既支持成员跨经营单元承担不同职责，也保留各条授权原有的数据条件。统一范围条件覆盖列表、详情、统计、导出与写入，负责人统一维护角色和授权，普通账号管理与授权分配分别控制。

Spring Security 与 JWT 建立用户及会话身份，角色和范围按当前持久化记录解析。后台任务和 Agent 跨执行边界重新建立发起人上下文，执行时复核授权与业务状态，使成员停用、授权到期和资源变化在各类入口下按相同规则生效。

##### 业务划分

<!-- question-id: q-1079d857795d -->
###### 后端业务模块怎么划分？

面试回答：

后端按农机运营流程划分为资产、作业、维保、成本和经营分析模块。平台目录维护公共标准机型，资产模块维护租户的具体设备；作业模块管理任务和资源安排，维保模块处理维修保养流转，成本模块管理单据与审核，经营分析按统一时间和授权范围汇总数据。

接口层由 Controller 接收请求，Service 组织业务和校验，MyBatis 完成持久化。跨模块通过公开 Service 协作，比如调度时检查设备状态、已有任务和维保占用，不直接改其他模块的表。这样普通接口和 Agent 都能复用同一套权限、状态流转和资源规则，模型提出方案后仍由后端判断能否执行。

实现细节：

模块职责与主要规则见表。资产档案关联标准机型，统计按有效业务记录和时间口径汇总；跨模块调用统一经过目标模块的业务状态与数据范围检查。

| 模块 | 主要职责 | 需要处理的规则 |
| --- | --- | --- |
| 农机资产 | 关联公共标准机型，维护租户具体设备档案 | 资产归属、经营范围、生命周期及可调度状态 |
| 作业任务 | 实际作业录入或提前安排、执行计量、质量验收及返工 | 资源可用性、占用冲突、指定人员、轮次计量与冻结证据 |
| 维保管理 | 登记保养周期与到期提醒、统一维保工单、检查与复机验收 | 可选安排窗口、指定验收人、处理期间的设备使用限制 |
| 成本管理 | 成本单据、明细、提交与审核 | 汇总与明细分权、自审策略、单据状态 |
| 经营分析 | 汇总作业、维保和成本数据 | 动作授权、经营范围、有效记录和时间口径 |

##### 租户与权限设计

<!-- question-id: q-2bd5679893fc -->
###### SaaS 多租户结构怎么设计？

面试回答：

平台面向多个农机经营组织提供同一套业务能力，以组织作为租户，采用共享数据库和共享业务表，通过租户字段与后端授权隔离数据。平台下面是租户，租户内部有一层经营单元，并可以将授权进一步限定到场站；小租户使用默认经营单元。

账号分为平台账号和租户账号，分别进入对应工作台。普通账号固定归属一个租户和一个成员关系，不提供跨租户业务切换。平台维护公共机型、作物、作业类型和知识，租户管理自己的成员、资产及业务记录。平台普通业务与助手入口不读取租户业务明细，租户内部再通过角色动作和经营范围控制访问。专用 AI 诊断入口可审计读取已保存的跨租户会话与活动，用于运行排查；当前租户业务查询和任务控制仍由租户授权入口处理。

实现细节：

SaaS 结构承载租户开通、公共目录、成员管理和业务隔离；RBAC 决定租户内部的业务动作与数据范围。场站授权只覆盖目标场站，不扩大为父经营单元或其他场站。

| 数据对象 | 结构与约束 |
| --- | --- |
| `tenants` | 保存租户资料、负责人、默认经营单元、自审策略及治理版本 |
| `accounts` | 保存平台／租户身份、单租户归属、启停状态和授权版本；成员视图直接来自账号，成员 ID 使用账号 ID |
| `tenant_role_grants` | 账号的角色授权，独立保存经营范围、本人关系和生效／到期时间 |
| `organization_places` | 保存经营单元和场站，授权可以指定经营单元或场站 |
| 平台目录与租户业务表 | 公共标准机型、知识与组织具体资产、作业、维保、成本分开管理 |

共享表便于复用表结构、迁移流程和统计逻辑，平台通过统一授权解析与 SQL 范围片段完成租户隔离，多个组织共享数据库资源。按租户独立建库适用于需要独立资源与恢复能力的场景，同时需要分别管理建库、迁移和连接。项目围绕共享表方案，把隔离规则落实到各类查询和写入路径。

例如租户 A 有东区和西区两个经营单元，成员 U 固定属于 A，可以获得东区的农机管理授权及西区的本人相关作业授权。U 在本租户内按每条授权访问业务，不能通过请求参数把账号切换到租户 B。

<!-- question-id: q-cdce9a490d8f -->
###### Spring Security、JWT 和业务权限分别做什么？

面试回答：

JWT 绑定稳定用户 ID 和登录会话 ID，Spring Security 校验令牌并建立认证上下文，每次请求还会检查会话是否有效。角色和范围由后端根据当前账号、租户、成员及有效授权解析，业务 Service 再检查动作权限、资源范围和业务状态。

这样成员停用、角色修改或授权到期后，后续请求会按当前权限处理。停用成员还会撤销登录会话，退出撤销当前会话，修改密码撤销全部会话。租户身份来自服务端当前账号记录，请求、模型和工具参数都不能指定另一租户来取得权限。

实现细节：

用户会话令牌的 subject 是用户 ID，`sid` 关联 `account_sessions`，令牌不携带长期角色或数据范围。认证过滤器检查当前有效会话并加载账号，授权解析继续检查账号启用、租户未删除、有效成员身份和各条角色授权的生效、到期时间。

授权事实只在同一身份、同一经营单元筛选、同一线程的同步只读请求或一次只读工具尝试内复用。进入事务、变更上下文或跨异步边界时重新读取；知识、附件和向量记忆的外部调用之后也重新核权。敏感写入锁定租户治理行并核对当前授权与版本，经营单元筛选只在已有范围上追加限制。

| 环节 | 职责 | 后续校验 |
| --- | --- | --- |
| Spring Security / JWT | 校验签名、有效期和会话，建立当前账号身份 | 解析当前业务授权 |
| 成员与角色授权 | 检查有效成员、角色动作及授权有效期 | 计算资源范围及本人关系 |
| 资源与状态 | 核对归属、数据范围和当前业务状态 | 写入时按需附加预期状态并检查影响行数 |

<!-- question-id: q-5e39ce7b3ff7 -->
###### RBAC 如何建模，角色与数据范围如何配合？

面试回答：

RBAC 通过角色组织业务动作权限，成员通过角色授权获得相应能力。角色定义能做什么，例如读取资产、执行作业或审核成本；每条角色授权独立绑定全组织或指定经营单元、场站，以及范围内全部或本人相关的数据方式和有效期，限定这项能力能够作用于哪些记录。

成员可以组合多个角色，平台提供六个只读模板，租户可以复制为自定义角色。比如作业机手执行自己被指派的任务，农机主管管理授权范围内的资源；成本汇总、明细和审核分别授权，拥有汇总读取权不会自动得到财务明细。最终操作还要通过业务状态和指定人员检查，不能只看角色名称。

实现细节：

角色不继承，成员不直接挂个人权限；角色权限来自后端定义的动作目录，目录同时定义依赖及敏感标识。创建角色时显式提交依赖权限，拒绝未知权限、通配符及平台权限。

| 模型或表 | 保存内容 | 作用 |
| --- | --- | --- |
| `PermissionCatalog` | 动作代码、依赖、敏感标识及模板定义 | 例如 `asset.read`、`task.execute`、`cost.document.review` |
| `tenant_roles` / `tenant_role_permissions` | 租户角色及其动作权限 | 定义角色能做什么 |
| `tenant_role_grants` | 成员、角色、全组织标识、本人相关、生效及到期时间 | 保存一条完整的角色授权 |
| `tenant_role_grant_scopes` | 授权关联的经营单元或场站 | 指定该条授权的经营范围 |

六个模板为租户管理员、农机主管、作业机手、维修人员、成本经办和成本审核。模板只读，自定义角色只在本租户生效，已分配的角色须先解除或替换全部授权才能删除。

“本人相关”按业务对象分别解释：资产是登记给本人的设备；任务是本人执行、验收或允许读取的关联返工档案；工单是本人处理或验收；成本单是本人创建或当前提交轮次由本人提交。任务指派只提供完成任务所需的关联信息，不自动扩大完整资产或成本读取权。

维保技术处理与单价、金额独立授权，农机主管默认可看成本汇总，财务明细和审核属于敏感能力。动作、经营范围、本人关系和状态规则分别检查。

<!-- question-id: q-e372245f2e56 -->
###### 资源状态如何校验？

面试回答：

资源状态校验放在业务 Service 中，与权限检查分别执行。比如处理维保工单，先确认用户具有对应动作权限、工单在授权范围内，再判断当前状态是否允许处理。进入验收环节还要检查是否为该工单指定的验收人，负责人或管理员不能仅凭管理身份代替验收。

对于可能发生并发变化的操作，更新语句带上预期状态并检查影响行数。其他请求已推进状态时，本次更新返回状态变化结果；满足预期条件时才推进业务。这样把状态校验落实到实际写入，处理校验与更新之间的并发变化。

实现细节：

状态条件与资源 ID、组织范围共同进入需要保护的更新语句。更新影响零行时，结合资源与状态检查返回具体原因；权限检查确定可操作范围，状态检查确定当前能否流转。

并发控制按业务对象选择条件：单条记录流转使用预期状态，同一状态下的字段修改通过版本号识别旧版本更新，跨任务调度则在资源与时间范围上保护“查占用并写安排”的整体过程。后者需协调同一资源的并发请求，取得资源锁后重新核对时间占用，再写入安排。

##### 查询、写入与执行边界

<!-- question-id: q-4afe6cbc6848 -->
###### 怎么防止跨租户查询和越权修改？

面试回答：

租户由当前有效账号及成员关系确定，后端按具体业务动作解析授权，将租户、经营范围和本人关系共同应用到查询条件。MyBatis 使用统一范围片段，覆盖列表、分页总数、详情、统计、选择器和导出，空授权直接拒绝；写入在业务事务中再次校验当前权限、状态与版本。

新增记录的租户由服务端上下文确定，经营单元、场站和关联资源要处于本次动作允许的范围。关联选项只返回完成当前用例所需的标识和名称，不自动开放完整详情。批量操作逐项核对，附件和历史结果在读取时重新检查当前权限；Agent 和后台任务也通过同一业务 Service 执行。

实现细节：

`AuthorizationService` 检查当前主体和有效授权，`DataScopeService` 为所需动作构造授权组，MyBatis 的 `AuthorizationScope.filter` 将其转成组织条件、组间 AND 和组内 OR；没有范围时追加 `AND 1=0`。授权组内的经营范围与本人关系始终一起判断。

资产表为 `machinery_units`，作业表为 `operation_jobs`。资产查询以固定 Mapper 片段绑定字段与本人关系：

```xml
<include refid="com.amms.tenant.dao.AuthorizationScope.filter">
    <property name="scope" value="scope" />
    <property name="organization" value="a.organization_id" />
    <property name="unit" value="a.operating_unit_id" />
    <property name="site" value="a.site_id" />
    <property name="related" value="a.operator_id=#{authScope.userId}" />
</include>
```

字段表达式来自源码中的固定映射，身份与范围值使用参数绑定，客户端不能传入 SQL、表名或字段名。任务读取的本人关系包含执行人、验收人及允许读取的关联返工档案，不能统一简化为“创建人是自己”。

经营单元筛选作为独立 AND 组附加到授权组后面。只有某场站权限的成员筛选整个经营单元时，结果仍限定在原场站，不会获得其他场站数据。

创建任务的校验次序是：确认当前主体及动作权限 → 校验目标经营范围和关联资源 → 核对执行成员当前能力与范围 → 检查业务状态及冲突 → 写入。需要选择设备但不具备完整资产读取权时，使用专用关联选项返回必要信息，不把选择器转换成资产详情入口。

批量操作先按授权条件读取全部目标，再与去重后的请求 ID 集合核对。要求原子完成的批量更新遇到越权项时整批拒绝；支持逐项处理的接口分别返回成功、不可操作或失败结果，并且只修改已授权项。返回信息不泄露范围外资源的业务明细。

报告、导出和审计还要检查内容权限。成本汇总不携带单据明细，维保技术资料裁剪金额字段；历史分析无法按当前经营范围或费用权限安全裁剪时，拒绝正文或下载。业务导出按当前权限即时分批查询、直接返回，不创建独立导出任务或 OSS 成品；输出前先验证读取及导出权限。

<!-- question-id: q-bb8e9019962c -->
###### 租户范围如何贯穿异步任务和 Agent？

面试回答：

创建任务时会保存发起人、租户和目标资源，后台运行跨执行边界重新加载当前有效主体，建立执行上下文，再按实际动作解析当前授权。消息负责触发任务，消息里的身份、角色或模型参数不能授予权限；业务 Service 缺少执行上下文时直接拒绝。

Agent 先提出工具和参数，执行器检查准入，业务 Service 检查动作、经营范围、本人关系和状态。任务创建后成员停用、授权到期或范围收缩，都按执行时的当前事实处理。人工确认只表达对方案的同意，不能扩大业务权限；历史结果再次展示或下载，也要核对当前权限能否覆盖原证据范围。

实现细节：

普通请求由认证过滤器建立 `RequestContext`，后台和 Agent 通过 `RequestContext.background` 与受管理执行器建立发起人和租户上下文，再按动作重新解析授权。RabbitMQ 消费者按消息 ID 读取数据库任务，核对组织及主体后执行，不采用消息中保存的旧角色作为当前授权。

`RequestContextHolder.runWith` / `callWith` 在 `finally` 恢复原上下文，HTTP 过滤器结束时清理，避免线程复用串入另一任务的身份与组织。主体失效或范围不满足时拒绝业务动作；权限基础设施暂时故障进入可恢复失败处理，不能直接当成永久撤权，也不能换用管理员身份继续。

对已冻结的分析或报告，当前授权必须覆盖原证据涉及的各组经营范围及本人关系。仅能读取原结果的一部分且无法安全裁剪时，要求重新调查，不直接返回完整历史成品。执行写入前仍核对确认版本、设备状态和资源冲突。

内部 Agent 与对外 MCP 都由 Backend 解析当前用户和组织范围。MCP 额外受到客户端逐项同意能力及八项固定只读工具约束，可读取授权知识和业务汇总；Agent 的草案与写入另经冻结审批或有效委托。两类入口使用独立令牌与能力契约。

##### 授权合并与治理

<!-- question-id: q-b84d86579c29 -->
###### 多个角色的权限和数据范围如何合并，怎样避免范围被错误扩大？

面试回答：

同一个动作可以由多条角色授权提供，这些完整授权取并集；一个操作同时需要多个动作时，各动作允许的数据范围取交集。每条授权的经营范围和本人关系作为整体判断，因此成员在不同范围下可以具有不同的数据访问方式。

比如同一个成员能读取东区本人相关资产，也能读取西区全部资产，结果集合就是“东区本人”与“西区全部”的并集。如果导出还需要导出权限，就同时满足读取和导出的范围；任一动作缺少授权时拒绝操作。合并后的 SQL 保留完整授权条件，准确表达每项能力在各经营范围中的适用方式。

实现细节：

设 `E`、`W` 表示东区与西区，`self` 表示本人相关：

```text
asset.read 的授权组：
    (E AND self) OR W

asset.export 的授权组：
    E

导出时同时满足读取与导出：
    ((E AND self) OR W) AND E
    = E AND self
```

`DataScopeService.ScopeSnapshot` 保存 `List<List<RoleGrant>>`，每个内层列表是一项动作的完整授权并集，外层列表按 AND 计算；动作依赖也形成独立授权组。SQL 将每条授权渲染为 `(经营范围 AND 本人关系)`，再组内 OR、组间 AND。不能先将所有单元、场站提取成一个 IN 集合，再把某条“范围内全部”条件套到整个集合上。

场站授权不会向父经营单元扩大；经营单元授权可覆盖所属场站。缺少动作、没有有效授权、空组或缺失范围都拒绝访问，不将空范围解释为全组织。

<!-- question-id: q-a094c6203062 -->
###### 如何防止管理员越权授权，负责人和普通管理员有什么区别？

面试回答：

每个租户有一名负责人，身份与普通业务角色分开保存。负责人统一管理自定义角色、全部角色授权和成本自审策略；普通管理员按动作权限维护普通账号，创建账号时不附带角色，也不能接管负责人或敏感账号。

角色与授权修改在事务中锁定租户治理行，重新检查负责人身份、当前版本和范围，写入前后变化及审计。负责人必须保留全组织租户管理员授权，停用、删除或解除归属前先交接。平台可以通过专用流程恢复负责人，恢复操作记录原因和前后责任人。

实现细节：

| 主体或操作 | 规则 |
| --- | --- |
| 租户负责人 | 维护自定义角色、全部成员角色授权和成本自审设置，保留有效的全组织租户管理员授权 |
| 普通管理员 | 按权限维护普通账号，角色定义及授权修改由负责人完成 |
| 敏感账号 | 按角色实际包含的敏感动作判断，普通管理员不能接管负责人或敏感账号 |
| 自定义角色修改 | 模板只读；动作及依赖由 `PermissionCatalog` 校验；旧版本更新冲突，记录前后变化 |
| 成员授权修改 | 账号 ID 是成员标识；提交授权版本，修改已有授权通过移除后新增，保留项须与当前值一致 |
| 负责人交接 | 同租户有效成员，校验本人密码，原负责人保留其他授权 |
| 平台恢复 | 专用入口核对有效平台身份，记录原因和前后负责人，不代入租户办理业务 |

`tenants` 保存负责人、默认经营单元、自审策略及治理版本，`accounts.authorization_version` 保护成员授权更新；角色及范围分别落在 `tenant_roles`、`tenant_role_permissions`、`tenant_role_grants` 和 `tenant_role_grant_scopes`。

治理行加锁后复核身份与版本，业务变更和审计一起提交。成员授权替换会撤销其已有登录会话和 MCP 授权；角色动作变化在后续访问时重新解析。成本自审默认关闭，同时有经办和审核角色的成员也不能批准或驳回本人创建、当前由本人提交的单据；负责人显式开启后，仍须具备相应动作与数据范围。

##### 权限验证

<!-- question-id: q-dea42082b5bc -->
###### 如何验证多租户隔离和数据权限正确？

面试回答：

权限测试覆盖租户、动作、经营范围、本人关系和有效期。测试数据包含两个租户及各自成员，同一租户内配置经营单元、场站和不同角色授权，核对列表、分页总数、统计、详情、写入与导出的范围一致，既验证合法操作成功，也验证伪造租户或资源参数不能越权。

重点测试多角色并集是否保留每条本人条件、多动作交集是否生效、场站权限是否被父级筛选扩大，以及授权到期和成员停用是否及时生效。管理员测试还要覆盖角色或授权修改被拒绝、创建账号不能附带角色，以及负责人和敏感账号保护。异步任务在执行前重新撤权，历史报告在下载前收缩权限，最终核对返回内容、实际写入和审计记录。

实现细节：

| 用例 | 预期结果 |
| --- | --- |
| 租户 A 账号访问租户 B 的详情、附件或修改接口 | 不返回私有内容，不发生写入；请求参数不能切换租户 |
| 平台身份请求租户资产和工单 | 平台治理身份不能取得租户业务明细 |
| 同租户多个角色分别覆盖东区本人、西区全部 | 只返回东区本人及西区全部，不扩大为东区全部 |
| 读取与导出动作的范围不同 | 只导出两项动作交集内的数据 |
| 只授权一个场站，再筛选其父经营单元 | 不扩大到同单元的其他场站 |
| 缺少授权、空授权或授权尚未生效／已到期 | 拒绝对应动作或不返回记录，不降级为全组织 |
| 任务指派成员请求完整资产或成本详情 | 仍按资产、成本的独立动作与范围判断 |
| 同一范围下比较列表、计数、统计及导出 | SQL 口径一致，范围过滤发生在分页和聚合前 |
| 新建记录伪造组织或关联外组织资产 | 服务端组织赋值，非法关联拒绝 |
| 批量 ID 混合可操作项与越权项 | 按接口原子或逐项语义处理，不越权写入 |
| 普通管理员修改角色、成员授权，或接管负责人及敏感账号 | 拒绝变更，原授权和账号事实保持 |
| 两个页面同时修改同一成员授权 | 旧版本提交冲突，不覆盖最新授权 |
| 成员停用后持旧 JWT 访问，或 Worker 随后执行 | 会话撤销，后台当前授权复核失败，不创建业务记录 |
| 报告生成后费用权限或经营范围收缩 | 不能安全裁剪的正文或下载被拒绝 |
| 同一线程先后处理组织 A、B 的任务 | B 的查询与写入不带入 A 的上下文 |
| MCP 请求跨租户资源、未同意能力或超出当前用户范围 | 拒绝调用，不返回受限数据 |
| 平台读取跨租户 AI 诊断 | 仅专用入口可读取已保存历史，读取写审计，不能查询当前业务或控制任务 |

SQL 回归通过 Testcontainers 使用隔离 MySQL 和合成数据，覆盖完整授权的并集、动作交集、本人条件、场站隔离、空范围，以及列表、统计和选择器的结果。验证同时核对具体记录集合、聚合值与实际写入，确认范围条件在各条访问路径中的效果一致。

##### 易混点与回答检查

角色决定业务动作，每条授权同时限定经营范围、本人关系和有效期；负责人身份、普通账号管理权限与实际业务验收资格分别判断。

- [ ] 能解释同动作完整授权取并集、多动作范围取交集。
- [ ] 能说明账号即成员标识，授权有效期保存在角色授权中。
- [ ] 能区分负责人授权治理、普通管理员账号维护和指定人员验收。
- [ ] 能说明异步执行、外部取证和写入事务中的当前权限复核。
- [ ] 能区分普通平台入口、专用 AI 诊断和用户授权 MCP 的能力。
#### Redis 缓存与查询优化

简历表述：缓存业务数据、检索向量和近期对话，采用 Cache Aside 并设置 TTL。

##### 快速回顾

| 项目 | 内容 |
| --- | --- |
| 缓存对象 | 部分业务展示列表与统计、公共选项、ColQwen 查询多向量、近期工作记忆 |
| 范围限制 | 业务缓存仅接收当前全组织授权且符合筛选条件的查询；局部及本人范围回源 |
| Cache Aside | 鉴权 → 查缓存 → 未命中查库 → 回填前检查依赖代际和日期 |
| 失效方式 | 业务事务登记持久事件，提交后递增平台引用、组织引用或组织业务代际 |
| 并发回填 | 进程内合并同键读取，按旧代际生成的结果不能回填为新代际 |
| 当前事实 | 权限、业务详情、冲突、审批资格和签名链接直查；列表状态命中后再核对 |
| 故障与观测 | Redis 故障回源，失效事件保留重试；观察命中、旁路、回源、合并和丢弃 |

##### 职责与实现概述

资产和任务首页、经营统计、公共选项存在重复读取，ColQwen 也会重复编码相同问题。Redis 缓存符合条件的展示快照、查询多向量和近期工作记忆，减少重复 SQL、聚合和视觉查询编码。

业务读取先解析当前权限，只对全组织授权及允许筛选组合使用缓存。Key 绑定组织、完整筛选、日期和依赖代际；写入在同一事务登记失效事件，提交后递增对应代际，后续请求读取新的缓存空间。回填前检查代际和日期，避免并发旧查询污染新空间。

近期消息以带 MySQL 消息版本的快照缓存，持久偏好保存在 MySQL。业务展示允许短暂延迟，调度、审批、授权和详情在当前事实上判断；缓存命中后的列表还会重新核对版本、人员资格、计量及冲突，动态生成可用动作和链接。

##### 缓存对象与读写流程

<!-- question-id: q-e9f26b7177cb -->
###### 为什么引入 Redis？

面试回答：

Redis 主要减少重复读取和计算。资产、任务等首页及部分统计会重复执行 SQL 和聚合，机型目录与农业选项访问频繁，相同知识问题还会重复进行 ColQwen 查询编码。符合条件的结果缓存后，后续请求可以复用展示快照或问题编码。

缓存前先检查当前授权，业务执行仍读取当前事实。MySQL 保存业务、权限、消息与偏好，Redis 中的展示结果和近期消息都可以重建；查询向量丢失后重新编码。这样优化查询开销，同时保留权限和状态校验。

实现细节：

观测按缓存种类拆开：业务缓存看 SQL 与聚合耗时，ColQwen 缓存看实际编码次数，工作记忆看近期消息加载。缓存命中和执行前复核属于不同环节，不能把少做权限检查计作优化。

<!-- question-id: q-b38d5e76e391 -->
###### 具体缓存哪些内容？

面试回答：

缓存分三类：业务展示缓存保存部分首页、汇总和公共选项；查询向量缓存保存 ColQwen 查询多向量；工作记忆缓存保存组织、用户、会话范围内的近期规范消息。

业务缓存有明确的资格限制。列表和统计要求当前全组织授权，并符合首页、关键词及日期组合等条件；本人相关、局部范围、搜索和深分页直接查库。权限、详情、资源冲突、待审资格和证据直接查询，消息快照命中也要校验 MySQL 版本与来源。

实现细节：

| 缓存类型 | 内容与使用条件 |
| --- | --- |
| 业务展示 | 资产、任务、维保、成本首页，状态数量、部分经营汇总和趋势；各实际读取范围均须为全组织 |
| 目录与选项 | 机型目录首页、品牌、类型、无关键词机型选项、作物与作业类型选项、展示配置 |
| 查询向量 | ColQwen 的问题多向量；Key 绑定编码版本与查询摘要 |
| 工作记忆 | 近期规范消息的 JSON 快照，包含 MySQL 消息版本，按组织、用户和会话隔离 |

MySQL 保存手动表达偏好和自动画像，记忆文本编码在 `memory.search` 按需执行。业务详情、账号授权、冲突、验收待办、签名链接等不进入业务展示缓存。

<!-- question-id: q-d86dd6644d6d -->
###### Cache Aside 是怎样的流程？

面试回答：

读取时先完成鉴权并判断缓存资格，再按依赖代际、组织、日期和筛选生成 Key。命中后取出独立快照，未命中就查 MySQL；回填前再次检查代际和日期，确认本次读取仍属于同一缓存空间。

写入时在业务事务内登记缓存失效事件，提交后尝试递增受影响的代际。成功提交后，下一次读取使用新的 Key；Redis 暂时不可用时保留持久事件重试。事务回滚不触发成功变更的失效，提交后的缓存故障也不会把已经成功的业务返回成失败。

实现细节：

以费用审核为例：

1. 事务内锁定并核对费用单、当前权限与状态，写入审核结果、审计和组织业务缓存失效事件。
2. 事务提交后快速递增该组织业务代际；持久监听器负责完成或重试事件。
3. 后续列表和汇总组合新的组织业务代际读取，未命中时按已审核记录重新聚合。
4. 提交前已经开始的旧查询仍属于旧 Key，回填检查发现代际变化时丢弃缓存写入。

展示快照命中后，列表继续核对当前版本、人员资格、计量及资源冲突；不匹配时回源，签名 URL、可用动作和阻断原因每次重新生成。

##### Key 与过期策略

<!-- question-id: q-9bc1dd4cae3a -->
###### 多租户系统中，缓存 Key 怎么设计？

面试回答：

Key 需要包含会影响结果的身份范围、筛选、日期和依赖版本。当前业务缓存只处理全组织授权，局部范围和本人数据直接回源；组织 ID 区分租户，类别和完整筛选区分查询，代际区分数据变化前后的快照。

公共目录依赖平台引用代际，组织选项再依赖组织引用代际，业务展示继续加入组织业务代际。工作记忆单独按组织、用户和会话隔离，查询向量按 ColQwen 编码版本和问题摘要复用。每次请求先解析授权，再决定是否能用对应缓存。

实现细节：

| 对象 | Key 依据 |
| --- | --- |
| 业务列表与统计 | 缓存版本、类别、组织、组合依赖代际、Asia/Shanghai 日期、完整筛选 |
| 平台／组织选项 | 对应引用代际、归属与筛选，组织内容额外依赖平台目录 |
| 近期工作记忆 | 组织、用户、会话的摘要键，值中保留规范消息版本 |
| ColQwen 查询多向量 | `amms:vec:colqwen:` 加编码版本和规范化问题的摘要 |

业务 Key 的结构为：

```text
amms:read:{readVersion}:{category}:{platform或org:组织ID}:{组合代际}:{日期}:{筛选编码}
```

组织、代际和权限资格来自后端。筛选编码完整保留条件，避免相同日期下的不同状态列表共用结果。业务缓存资格收窄后，无需为任意成员权限组合创建独立快照。

<!-- question-id: q-64074b6a35e7 -->
###### 查询向量缓存为什么要包含模型版本？

面试回答：

查询多向量必须与页面索引处在兼容的向量空间，模型、维度或预处理变化都会改变编码含义。因此当前 ColQwen 查询缓存把编码版本和规范化问题一起计算摘要，升级编码契约时形成新的 Key。

缓存的是问题表示，文档新增或替换后仍对当前索引重新检索，并回查修订、发布代次和权限。记忆使用独立的文本 embedding 和集合，不能把 ColQwen 的多向量矩阵当成记忆单向量使用。

实现细节：

编码版本覆盖模型、维度及相关处理配置。读取缓存校验矩阵有效性，异常时重新编码；相同问题的在途编码在进程内合并。规范化不移除日期、地区或机型编号等有语义的信息。当前查询向量缓存 TTL 为 24 小时，并限制单值大小。

<!-- question-id: q-ec19b2dfcd73 -->
###### TTL 怎么设置？

面试回答：

当前业务展示 TTL 上限为 30 秒，目录和常用选项为 300 秒，空列表或空页为 5 秒；实际 TTL 在上限的 80% 到 100% 之间抖动，并保证展示快照在中国标准时间次日零点前到期。ColQwen 查询多向量保留 24 小时，工作记忆使用自己的配置和消息数量限制。

TTL 负责容量和旧快照淘汰，数据修改还会递增代际。权限和执行资格每次判断，不能因为快照未过期就沿用旧状态。MySQL 与 Redis 分别提交，短 TTL 也不能视为业务提交后更新可见延迟的严格保证。

实现细节：

| 对象 | 当前 TTL 策略 | 配合机制 |
| --- | --- | --- |
| 业务展示 | 上限 30 秒 | 事务失效事件、业务代际、当前状态再核对 |
| 目录和常用选项 | 上限 300 秒 | 平台及组织引用代际 |
| 空列表／空页 | 上限 5 秒 | 减少新数据被旧空结果遮挡 |
| ColQwen 查询多向量 | 24 小时 | 编码版本与单值大小限制 |
| 工作记忆 | 配置化 TTL 与消息上限 | MySQL 规范消息版本及证据检查 |

展示缓存的日期维度和到期边界共同避免跨日统计继续复用昨天的快照。日期窗口仅覆盖明确支持的常用组合，任意期间、搜索及深分页直接回源。

##### 一致性与故障处理

<!-- question-id: q-9b246bcbb848 -->
###### 缓存和数据库怎么保持一致？

面试回答：

业务事务同时登记失效事件，提交后递增缓存代际；失败事件持久保留并重试。Key 包含依赖代际，数据更新后后续读取进入新的空间。与逐个删除详情、列表 Key 相比，这种方式可以覆盖同一依赖下的多个展示查询。

并发回填还要再检查代际。例如 A 查到旧值后，B 提交审核并递增代际，A 准备回填时发现依赖已变化，就放弃写缓存。展示允许短暂延迟，关键业务写入在事务内重新校验当前事实。

实现细节：

三个命名空间分别维护平台引用、组织引用和组织业务代际，读取按依赖组合。快速失效在提交后执行，持久监听器只有递增成功才完成事件；重复递增只使旧缓存进一步失效。

Redis 不可用时查询绕过缓存，持久事件等待恢复。停用后重新启用缓存前，先重放失效积压并切换未使用的新缓存版本；旧空间由 TTL 淘汰。回填复核保护缓存空间，业务占用和幂等仍由数据库锁及事务保证。

<!-- question-id: q-56190db57640 -->
###### Redis 不可用或热点缓存失效怎么办？

面试回答：

Redis 读取、写入或代际查询失败时，业务展示回源 MySQL，ColQwen 问题编码重新计算，工作记忆从 MySQL 加载。业务正确性依靠持久事实和当前授权，缓存故障不改变这些判断；失效事件继续保留等待重试。

热点展示 Key 的并发未命中通过进程内 single-flight 合并，一个请求加载，其他请求共享这次结果，并各自解码为独立快照。相同 ColQwen 查询也合并在途编码，模型服务使用自身的有界队列和期限控制计算压力。

实现细节：

| 情况 | 当前处理 |
| --- | --- |
| 代际或缓存读取失败 | 绕过展示缓存，查询数据库 |
| 回填失败或单值超限 | 返回已经查到的结果，本次不存缓存 |
| 失效递增失败 | 保留事务内持久事件，后续重试 |
| 同 Key 并发未命中 | 进程内合并加载，完成或失败后移除占位 |
| 查询向量缓存故障 | 在检索总期限内重新调用 Runtime 编码 |
| 工作记忆缓存故障或版本不符 | 按 MySQL 规范消息重建 |

观测分别记录命中、未命中、因范围或事务旁路、故障回源、合并读取、代际变化丢弃及加载耗时。single-flight 的范围是单进程，同一资源的业务写入继续经过数据库并发控制。

##### 评测与结果

<!-- question-id: q-2038f63b288d -->
###### 怎么证明缓存带来了查询优化？

面试回答：

我会固定数据规模、请求分布和并发条件，对比启用缓存前后的完整请求。业务查询看缓存命中率、数据库查询次数，以及平均耗时和 P95；查询向量缓存看 ColQwen 的实际编码次数；同时检查数据更新后多久能在查询结果中看到。

对照分别记录冷缓存和预热状态，统计重复 SQL、编码调用次数及完整接口耗时，再核对更新可见延迟。业务查询、向量编码和上下文加载分别归因，能够明确缓存节省了哪类开销，以及对应的用户等待变化。

实现细节：

指标定义见表。前后请求条件保持一致，预热状态单独记录，查询性能与更新可见延迟共同衡量缓存配置。

| 指标 | 观察内容 |
| --- | --- |
| 缓存命中率 | 是否存在足够的重复访问 |
| 数据库查询次数 | 重复 SQL 和聚合查询是否减少 |
| ColQwen 查询编码实际调用次数 | 查询向量缓存是否减少重复编码 |
| 请求平均耗时、P95 | 用户等待是否改善 |
| 数据更新后的可见延迟 | 是否出现不可接受的陈旧结果 |

每组对照记录数据版本、请求总数、并发数、查询重复比例、冷缓存或预热状态，以及命中数、数据库访问数、ColQwen 查询编码调用数、接口平均耗时和 P95。另记录成本单据审核提交时间、详情及统计首次显示新值的时间，并核对成员范围与实际结果，防止将少查数据或错误复用范围当成优化。

##### 易混点与回答检查

缓存资格、身份授权和业务执行条件分别判断；TTL 控制保留时间，依赖代际控制后续读取空间，事务内持久事件负责失效恢复。

- [ ] 能说明全组织授权、首页和常用筛选的缓存资格。
- [ ] 能按费用审核讲清持久失效事件、代际递增及回填复核。
- [ ] 能区分业务展示快照、ColQwen 查询向量和近期工作记忆。
- [ ] 能说明事务内读取、详情、冲突和当前权限为何直接查事实。
- [ ] 能解释 Redis 故障回源及单进程合并加载的范围。
#### Agent 工作流与工具调用

简历表述：覆盖作业调度、维保建议、经营分析和知识问答；校验资源可用性与任务冲突，生成人工确认后执行的草案并记录审计日志。

##### 快速回顾

| 项目 | 内容 |
| --- | --- |
| 执行分工 | AgentScope 承载对话与 ReAct，Graph 调度动作内部 Workflow 和严格 P&E，Backend 管理持久运行 |
| 业务场景 | 作业安排与实际记录、维保建议、经营分析和知识问答 |
| 入口与专家 | 首轮理解并选择路径，简单查询由主助手完成，复杂调查可委派四类领域专家 |
| 工具入口 | 统一 Schema、当前授权、期限、复用和容量控制，具体操作复用业务 Service |
| 写入授权 | 冻结审批、精确方案委托；范围委托仅允许新建作业 |
| 持久恢复 | 显式持续目标使用租约和 checkpoint；模型或业务效果未知先核对，不自动重放 |
| 预算与审计 | 片段容量和根有效期共同控制执行；累计配额可选开启，真实调用及业务回执持久记录 |

##### 职责与实现概述

故障排查要联合查询资产、工单和手册，作业安排要核对设备、人员和占用。Agent 首轮理解请求并选择执行路径，主助手负责最终回答，复杂调查按需委派作业、维保、成本和知识专家；工具取得的真实回执与已读来源构成回答依据。

Backend 在模型外管理当前授权、冻结上下文、工具能力、执行期限、检查点和业务回执。AgentScope 运行对话与 ReAct，Graph 承载动作内部的固定流程及严格计划执行。领域专家共用当前用户范围、期限和取消信号，准备草案后统一进入父级冻结与执行链。

业务写入经冻结审批或有效委托，执行前复核授权、版本、指定人员与资源冲突。稳定幂等输入与逐项回执防止重复提交，租约和 checkpoint 支持持久目标恢复；审计关联请求、证据、授权及实际业务记录，使建议、待确认和已执行分别可查。

##### 工作流与业务场景

<!-- question-id: q-aafac67a0c91 -->
###### Agent 工作流是什么样的？

面试回答：

后端受理消息后先冻结本轮输入和有效 AI 设置，建立唯一运行记录。首次模型调用完成理解、参数提取和路径选择：普通交流直接回答，简单查询调用必要工具，开放调查使用 ReAct，固定业务动作进入内部 Workflow；用户明确要求持续推进时才启用持久目标。

主助手负责整合结果和最终答复，复杂调查可以委派作业、维保、成本、知识专家。只读查询取得足够证据就结束；需要办理业务时准备草案，经过冻结审批或有效委托后，由 Backend 再核对当前权限、版本、人员与冲突，写入并保存真实回执。

实现细节：

| 层次或策略 | 当前职责 |
| --- | --- |
| Backend Harness | 管理运行、冻结上下文、租户、工具、租约、检查点、证据依赖、审批与回执 |
| AgentScope / ReAct | 普通对话及开放调查中的工具选择和动态补证 |
| Graph Workflow | 在动作函数内部执行固定版本的必要节点，受阻时停止该动作 |
| 严格 P&E | Planner 提交计划，Backend 冻结依赖，Graph 调度 read／workflow／synthesis 步骤；Executor 只持有当前步骤能力 |
| 领域专家 | investigate 取证，prepare 在父级允许时准备本领域草案；知识专家只读 |

例如安排下周作业：

1. 明确经营单元、作业类型、时间和资源要求，缺少关键条件通过结构化补问确认。
2. 查询候选资产、执行人和当前任务／维保占用，读取与要求有关的业务依据。
3. 动作函数按固定流程校验，冻结草案、依据及指纹，交给审批或明确委托入口。
4. 实际提交在事务和资源锁内复核，登记授权消耗与实际业务记录。
5. 按真实回执展示成功、失败或未知；业务回答经证据、权限与完成条件检查后持久化发布。

专家能力取当前用户与目标能力、首轮冻结工具、领域清单、委派工具和当前启用状态的交集。纯调查可有界并发，含 prepare 的批次串行推进；专家共用父级期限和取消，不能递归委派、自行批准或直接发布用户正文。

<!-- question-id: q-16a7d463f581 -->
###### 不同业务场景怎样调用工具？

面试回答：

工具选择取决于业务场景需要的信息。作业调度查询任务、设备、人员和已有安排；维保建议结合设备档案、维修记录与手册检索；经营分析从业务记录中取得指标；知识问答则检索说明书、规范和资料页，保留引用。

动态状态通过业务工具查询，维修方法通过专业资料检索取得，历史对话用于定位用户讨论的设备和任务。金额、工时等指标由业务查询和确定性计算产生，模型据此解释结果或组织方案。各场景最终返回草案、指标或带证据的答案，写操作经冻结审批或有效委托，并通过业务校验后执行。

实现细节：

各场景的信息来源和输出见表。统计结果同时保留组织、时间和有效记录口径；缺少期间先澄清，缺少面积或工时分母返回 null 和原因。业务状态、专业知识和历史背景各有来源。

| 场景 | 获取的信息 | 输出 |
| --- | --- | --- |
| 作业调度 | 任务要求、候选设备、人员及已有安排 | 调度草案、冲突与待补充条件 |
| 维保建议 | 设备档案、维保记录、相关手册 | 维保建议及资料依据 |
| 经营分析 | 明确期间、已审核 CNY 费用、有效计量与当前授权范围 | Backend 计算指标、排除范围和不可计算原因 |
| 知识问答 | 说明书、维修资料和操作规范 | 带页码引用的回答 |

##### 工具设计与资源校验

<!-- question-id: q-d15122b6b650 -->
###### 工具怎么定义，为什么不直接让模型操作数据库？

面试回答：

工具按业务能力定义，注册表保存名称、说明、严格参数 Schema、动作权限、副作用、幂等和重试政策。模型选择工具与参数，执行器先核对身份、当前授权、参数和期限，再调用业务 Service；业务写入继续执行状态流转、指定人员和资源冲突校验。

这样普通接口和 Agent 复用同一套业务规则。例如创建工单先检查资产、权限和必填信息，再按冻结授权办理。模型拿到的是有限能力，数据库访问和事务由所属业务模块完成。

实现细节：

| 内容 | 控制方式 |
| --- | --- |
| 名称、说明、Schema | 帮助选择工具；严格校验必填项、类型及枚举，不隐式把字符串转换成数值 |
| 权限与副作用 | 取当前用户及当前任务能力交集，读取、草案准备和提交分别控制 |
| 期限与容量 | 受管理执行器、总期限、工具次数及重试政策 |
| 结果结构 | 状态、规范化范围、分页、观察时间、稳定证据 ID、类型化问题与回执 |
| 只读复用 | 成功或合法空结果在窗口内复用，复用前重验可见性；同键在途请求共享物理执行 |
| 写入幂等 | 冻结授权、稳定动作标识和真实业务 ID，不复用草案生成作为提交结果 |

复用标识包含租户、用户、冻结授权范围、引擎、Schema 版本和规范化参数；同批独立幂等读取可有界并行，动作、状态及发布串行。服务失败保留失败状态，未遍历完分页不能证明全范围无记录。

平台 AI 工作台沿同一注册表管理工具启停，在线维护模板正文和运行参数。提示词按首轮、调查、规划、步骤执行、最终回答及核验阶段装配，固定协议继续由后端维护；新运行冻结有效设置与模板版本，继续和恢复沿用原快照。工具当前启停在调用及复用前重新检查，平台诊断从已有活动读取真实记录并写读取审计。

<!-- question-id: q-b7720a8df5f2 -->
###### 调度方案如何检查资源和任务冲突？

面试回答：

后端根据草案中的设备、执行人和时间范围做确定性检查。先确认资源存在且在授权范围内，再看设备当前状态、维保占用、已有任务，以及人员和设备在相关时段是否冲突，同时核对作业要求和候选资源是否匹配。

失败时返回具体资源、冲突记录和原因，Agent 据此换设备、调时间或请求补齐条件。草案记录候选安排，资源占用在业务写入时建立。用户确认期间其他请求可能改变安排，因此执行前再次复核，并在业务写入环节控制并发，保证同一资源的有效安排符合时间约束。

实现细节：

检查项与处理方式见表。方案校验判断草案在当前条件下是否可行，执行复核与并发控制处理确认等待期间的资源变化。

| 检查项 | 依据 | 失败后的处理 |
| --- | --- | --- |
| 资源与范围 | 设备、执行人及当前授权范围 | 返回具体资源和原因 |
| 可用状态 | 设备当前状态及维保占用 | 更换候选或调整安排 |
| 时间冲突 | 已有任务与相关时段占用 | 调整时间或候选 |
| 作业匹配 | 作业要求与候选资源条件 | 补齐条件或重新准备方案 |
| 写入前复核 | 当前安排与并发约束 | 避免检查后被其他请求占用 |

对有明确安排窗口的占用，以左闭右开区间 `[start, end)` 判断重叠，条件为 `existing.start < proposed.end AND existing.end > proposed.start`。执行中作业（含暂停）、处理中及待验收维保在明确释放前持续占用，超过预计结束时间也不会自动释放；设备、机手及维保分别核对。

执行时的再次查询仍可能被并发穿透。例如两个请求同时看到设备空闲，再分别插入不同任务，单条任务的状态条件无法阻止它们。当前保护覆盖同一资源的“查冲突与写占用”：事务使用 READ COMMITTED，先取得治理及业务锁，再按既定顺序锁人员与按 ID 排序的资产；锁内读取最新已提交占用后写入，所有相关入口遵循同一顺序。并发冲突后返回明确失败，不把未落库的草案当作预约成功。

##### 人工确认与执行恢复

<!-- question-id: q-c8eba6350dab -->
###### 人工确认确认的是什么？

面试回答：

确认绑定内容确定的冻结方案，包括动作、设备、人员、时间、关键字段和证据依据。后端使用冻结指纹保证展示、授权和执行对应同一份内容；关键参数或依据变化后重新冻结并确认。

写入授权可以来自审批，也可以由用户对精确方案明确委托。持续目标还支持限定资源、字段、数量和时间的范围委托，但这种方式只允许新建作业。维保、返工、实际作业、验收、计量更正和费用动作都必须绑定精确方案，实际提交仍检查当前业务权限、指定人员和自审规则。

实现细节：

| 授权方式 | 绑定内容与适用条件 |
| --- | --- |
| 冻结审批 | 审批请求关联完整方案与证据，参与人当前权限须覆盖冻结依据 |
| 精确方案委托 | 绑定发起人、组织、根目标、冻结指纹、动作／字段／数量、有效期及撤销状态 |
| 新作业范围委托 | 限定资产和人员集合、可选字段、业务时间、数量上限；经营单元、作业类型等农业字段固定精确值 |

例如用户批准某台设备明天的作业方案，等待期间设备被其他任务占用，提交返回冲突。换设备或时间须重新取得精确确认；已有有效范围委托时，新方案也必须完全位于授权集合与约束内。

审批或委托表示真实用户的授权动作，模型文本“用户已同意”不能替代。授权消耗与业务写入在同一事务提交或回滚，撤销只阻止后续动作；已成功的业务保留事实和回执。显式只读、历史再生成、重试子任务和周期调查不能升级为写入。

<!-- question-id: q-b39525d28ba3 -->
###### 执行失败或重复调用怎么办？

面试回答：

每个提交动作绑定稳定幂等输入和持久执行记录，后端在事务内检查目标、冻结授权和当前业务事实，成功后返回实际业务 ID。重复提交先查已有回执，已成功动作不重复创建；批量方案逐项保留结果，只继续仍可执行的部分。

模型请求和业务提交都可能出现结果未知。模型调用检查点未完成时标为 `model_unknown`，业务效果无法确定时标为 `unknown_effect`，先核对真实状态，不自动重放。只读临时故障可以按政策有限重试，确定失败的动作修正后重新取得所需授权。

实现细节：

| 结果 | 后续动作 |
| --- | --- |
| 明确成功 | 保存业务 ID 与回执，同内容跨片段不再提交 |
| 明确失败 | 保留原因，修正参数或重新准备方案；已拒绝动作需新的显式执行代次 |
| 业务效果未知 | 只查询执行记录与实际业务，不释放资格重新提交 |
| 模型效果未知 | 保留调用检查点与状态，不自动再次生成 |
| 批量部分成功 | 成功项保持，未完成项按冻结授权、当前版本及资源规则处理 |

普通问答断线只恢复持久状态和已发布正文，不自动重发生成。用户明确要求持续推进的目标使用同一 taskId 新增片段；Graph checkpoint 决定 Workflow／P&E 下一节点，SDK snapshot 保存 ReAct 上下文，恢复由 lease 和版本共同保护。

继续时重新过滤当前能力并刷新过期读取；内容指纹变化使依赖的结论、草案和步骤失效，无关成果保留。实质修订追加目标版本并撤销旧授权，普通继续沿用有效约束；同片段恢复不延长原期限，等待也计入根有效期。

##### 审计与结果追踪

<!-- question-id: q-6f9ebee4b6da -->
###### 审计日志记录什么？

面试回答：

审计要能够还原谁提出了什么目标、授权了哪份方案、调用过哪些工具，以及最终影响了哪些业务记录。因此会记录发起人、组织、运行及目标版本、冻结指纹、审批或委托，关键参数、工具调用时间、状态、错误、证据和执行回执。

审计分别记录建议、待确认草案和已执行结果。草案生成后保存版本与待确认状态，执行后关联创建或修改的业务记录 ID，并逐项记录成功或失败。界面和日志使用一致的状态，便于处理重复请求、定位失败和回溯实际变更。

实现细节：

审计同时保存工具调用状态、用户确认和业务回执，支持从任务查调用、从调用查业务结果，并核对实际执行与确认版本是否一致。

##### 正确性与成本验证

<!-- question-id: q-c316b5bb02cb -->
###### 如何验证 Agent 工作流执行正确，调用成本是否可控？

面试回答：

工作流验证需要核对最终业务结果。只读查询检查数据和引用，写入任务检查草案、确认版本、权限、资源约束以及真正生成的业务记录。重点覆盖确认后资源变化、重复提交、执行超时和部分失败，要求系统既不越权，也不重复创建或擅自执行变更后的方案。

成本按一次完整任务统计，包括模型和工具调用次数、检索次数、输入输出 token、总耗时与失败重试，结合任务成功率和结果正确性评估。单个执行片段限制调用容量、期限和输入窗口；持久目标还有根有效期。累计模型／工具／Token 配额默认只统计，显式开启后才对持久目标执行锁内预留；片段容量或配额触顶时暂停并保留原因，普通查询按已有证据收尾。

实现细节：

| 验证场景 | 核对标准 |
| --- | --- |
| 只读查询与分析 | 不进入业务写入；指标来自指定范围的业务查询 |
| 两个请求同时安排同一设备的重叠时段 | 最终不产生相互冲突的有效任务 |
| 确认后改变设备或时间 | 旧确认不能执行新版本 |
| 确认后设备被占用或成员被撤权 | 执行复核失败，不写入任务 |
| 同一动作并发提交或重复提交 | 最多一份业务结果，重复请求可查原回执 |
| 写入成功但响应超时 | 核对后返回原结果，不再次创建 |
| 批量动作部分失败 | 已成功项保留，剩余项按确认与恢复规则处理 |
| 工具持续失败或重复返回相同信息 | 有限重试，触达预算后停止调用 |

对每个任务记录 `taskId`、草案版本、确认与执行标识、最终业务 ID、调用次数、token、总耗时及失败原因。结合人工核对的目标结果，分别统计建议正确性和实际写入正确性，将完成情况落实到业务记录与执行回执。

##### 易混点与回答检查

调查计划、持久目标、业务授权和真实执行分别保存；草案与专家结论经父级核验，完成状态由当前证据和实际回执决定。

- [ ] 能区分 ReAct、动作内部 Workflow 和严格 P&E 的职责。
- [ ] 能说明四类专家的工具交集、共享期限和父级冻结执行链。
- [ ] 能区分冻结审批、精确委托和仅限新作业的范围委托。
- [ ] 能说明资源锁、当前授权与指定人员检查如何保护实际提交。
- [ ] 能解释 checkpoint、执行租约和成功／未知效果不重放。
- [ ] 能区分片段容量、根有效期和可选累计配额。
#### 短期、长期及实体记忆

简历表述：MySQL 持久化消息、历史事件与明确偏好，Redis 缓存近期对话，Qdrant 提供可重建的语义检索；通过滑动窗口与摘要压缩支持长期记忆召回。

##### 快速回顾

| 项目 | 内容 |
| --- | --- |
| 短期记忆 | 当前会话的近期消息与条件，滑动窗口结合历史摘要 |
| 长期记忆 | 有来源的历史背景、重要事件和明确偏好，支持跨会话召回 |
| 实体记忆 | 用稳定业务 ID 关联设备、机型与任务，辅助指代消解 |
| 存储分工 | MySQL 保存消息、摘要、情景和显式画像；Redis 缓存近期规范消息；Qdrant 保存情景及画像投影 |
| 召回链路 | 首轮装配摘要、近期消息和显式偏好；需要历史时调用 memory.search，分层召回后回查当前事实 |
| 更新与删除 | 独立整理游标、事实版本、遗忘水位与墓碑；精确旧版本投影持久登记删除 |
| 业务边界 | 记忆帮助理解背景与定位对象，动态状态和权限仍通过业务服务校验 |

##### 职责与实现概述

用户追问“上次那台收割机的维修进展”时，需要先找回历史讨论、定位具体设备，再查询当前工单。对话记忆通过近期上下文、跨会话召回和实体关联延续任务背景，减少用户重复提供设备和历史信息。

存储上，MySQL 保存消息、摘要、情景记忆、显式画像及来源，Redis 缓存近期规范消息，Qdrant 保存可重建的情景和画像投影。首轮只装配有界摘要、近期消息和启用注入的明确偏好，需要长期背景时再通过 `memory.search` 按层召回。实体关联使用稳定业务 ID，多个候选通过查询和用户确认消歧。

召回时先按组织和用户过滤，再回查来源、权限与有效状态，最后按预算装配上下文。历史信息提供背景和对象线索，业务工具提供设备状态、任务冲突和维修进展，两者共同支持连续追问与后续操作。

##### 记忆类型与存储分工

<!-- question-id: q-b5ecc749f281 -->
###### 短期、长期及实体记忆分别是什么？

面试回答：

短期记忆服务于当前对话，比如保留刚确认的设备和时间，理解下一句里的“它”或“改到明天”。长期记忆保存跨会话可复用的背景、重要事件和明确偏好。实体记忆则把用户提到的机器、机型或工单关联到稳定业务对象，解决到底说的是谁。

例如先查资产 A 的维保记录，再问它为什么停机，近期对话帮助确定指代；过一段时间问上次那台收割机的维修进展，长期记忆找回讨论背景，实体关联定位资产，再用业务工具查当前进展。三类记忆按用途划分，同一条历史记录可以同时提供背景和实体线索，存储按持久化、缓存和语义索引分工。

实现细节：

三类记忆的对象和目的见表。实体关联回答对象是谁，历史背景回答过去发生或表达过什么；设备当前能否调度和维修是否完成，仍以当前业务查询为准。

| 类型 | 保存什么 | 解决什么问题 |
| --- | --- | --- |
| 短期记忆 | 当前会话的近期消息、刚补充的条件 | 理解追问、指代和当前任务 |
| 长期记忆 | 历史任务背景、重要事件和明确偏好 | 跨会话找回相关信息 |
| 实体记忆 | 用户提到的设备、机型、任务等实体及关联 | 识别这台机器、上次那张工单等指代 |

<!-- question-id: q-5ef829c6a819 -->
###### MySQL、Redis 和 Qdrant 怎么分工？

面试回答：

MySQL 保存规范消息、滚动摘要、情景记忆、显式画像和来源，是判断记忆是否有效的事实来源。Redis 缓存近期规范消息的带版本快照，命中时仍检查 MySQL 消息版本和证据可读性；Qdrant 保存情景与画像的文本向量，用于按需语义召回。

偏好分两类：个人中心手动设置称呼、风格和详略，自动画像只整理用户明确表达的偏好、习惯、约束或实体 ID，两者都保存在 MySQL。画像直接读取即可参与首轮表达，不需要先做向量检索。向量候选返回后再核对当前记录、版本和来源权限。

实现细节：

| 内容 | 事实来源与投影 |
| --- | --- |
| 工作记忆 | `assistant_messages` 保存规范消息；Redis STRING 保存带版本 JSON 快照 |
| 会话摘要 | `assistant_conversations` 保存增量滚动摘要与处理水位 |
| 情景记忆 | `assistant_memory_episodes` 保存历史目标、上下文和事项；Qdrant 保存投影 |
| 显式画像 | `assistant_memory_facts` 保存每个事实键的当前值或墓碑，关联来源消息；Qdrant 保存版本化投影 |
| 手动表达偏好 | 账号的 `assistant_preferences` 保存称呼、风格、详略和版本 |

记忆检索使用文本 embedding，知识页面使用 ColQwen 多向量，两者分别管理集合和编码契约。向量故障跳过语义召回，MySQL 中仍有效的明确偏好可以继续读取。

##### 记忆形成与实体关联

<!-- question-id: q-c8e2cc3d0ac2 -->
###### 短期记忆怎么管理？

面试回答：

短期记忆保留近期规范消息，较早的对话通过后台滚动摘要压缩。首轮按预算加载摘要、近期消息和显式偏好，完整保留选中的消息，避免逐条截断后丢失条件。长期情景不在首轮自动向量检索，需要时由模型调用记忆工具。

任务目标、计划、草案、审批和执行回执独立持久化。再生成或恢复使用原轮冻结上下文，并重新过滤失权来源；这样能继续理解原问题，也能按结构化状态恢复执行位置。

实现细节：

正常轮次以当前用户消息 ID 为排他上界读取历史，排除本轮及后来消息；近期规范消息保留用户输入和每轮最新成功回复，失败、取消或被替代的回复不作为规范回答。这个历史读取绕过最新工作记忆缓存，防止后续消息混入原轮。

工作记忆缓存用于相应近期读取入口，值包含 MySQL 消息 ID／更新时间版本。命中后逐项检查证据可读性，版本不符或 Redis 故障时回源重建。输入预算合计协议、工具 Schema、消息、记忆和回执，预留输出空间；运行内压缩保留完整工具调用／返回配对，历史语义摘要在后台完成。

<!-- question-id: q-e911e75081bd -->
###### 长期记忆怎么形成，哪些内容值得保存？

面试回答：

后台通过持久事件和 RabbitMQ 整理规范对话，保存可跨会话复用的历史目标、背景和事项，同时提取用户明确表达的偏好、习惯、约束与实体 ID。每条内容保留组织、用户、来源和时间，模型建议与真实业务完成分别表达。

摘要、情景和画像各有自己的处理进度。摘要合并旧摘要和新增规范消息，情景按来源区间去重，画像按事实键维护当前值或墓碑。先写 MySQL，再更新 Qdrant 投影；失败保留状态，后续可以重试或重建。

实现细节：

1. Worker 先复核 active 账号、成员、用户记忆开关及来源有效性。
2. 摘要处理水位之后的规范消息，排除仍保留在近期窗口中的部分；提交时锁会话并检查来源和旧摘要未变化，失败不推进水位。
3. 情景按会话、用户及结束消息 ID 去重；已有明确业务引用可保留，自由文本不猜补实体 ID。
4. 画像只保存明确表达。同一事实键的新来源必须晚于当前来源和遗忘水位，旧消息不能覆盖新事实。
5. MySQL 提交后更新情景和画像投影；画像点 ID 包含事实 ID 与版本，召回时与当前 MySQL 版本比对。

例如“默认用表格展示”形成明确的展示偏好，“本次用列表”只影响当前回答；“建议维修”保留为历史建议，设备现在是否修好仍查询当前工单。情景与画像使用独立整理游标，关闭记忆期间不继续抽取，重新开启也不补抽这段停用期。

<!-- question-id: q-a1642369d84a -->
###### 实体记忆怎么保存，如何避免认错设备？

面试回答：

实体关联用稳定业务 ID 保存，名称、别名、机型和来源消息辅助匹配。用户说“那台收割机”时，最终要关联到具体 assetId，不能只记住机型，因为同一机型可能对应多台资产，一台资产又可能有多张工单。

召回候选后，通过业务查询确认对象和当前访问权。多个设备符合描述时，让用户选择或补充信息。实体类型和稳定 ID 一同保存，机型、资产和工单分别关联，后续追问据此定位到正确业务对象。

实现细节：

实体关联同时保留类型、稳定 ID 与来源，以区分跨类型的同名对象。每次使用时检查当前访问权，已撤权对象的关联信息从本次上下文中排除。

用户问“上次那台收割机的维修进展”时，先在当前组织和用户范围内找出历史讨论，将候选关联到 `assetId` 及当时的维修工单。两台同名收割机或同一资产有多次维修时，用资产编号、时间和工单区分；仍无法唯一定位就请用户确认。确认对象后调用业务服务查询当前工单状态，记忆提供定位线索，业务记录提供进展。

##### 召回、更新与隔离

<!-- question-id: q-75a4c1b9012c -->
###### 长期记忆怎么召回并放进上下文？

面试回答：

首轮先用当前问题、滚动摘要、近期规范消息和明确偏好理解请求，需要跨会话历史时再调用 `memory.search`。每次指定情景或画像中的一层，编码一次查询并检索对应向量集合，然后回查 MySQL 的当前版本、来源和权限。

语义相似度筛选候选，当前有效性决定能否采用。历史片段按预算装配并标为历史线索，设备状态、资源占用、费用和审批由业务工具查询。用户说“上次那台收割机”时，记忆先找回对象线索，再用当前记录回答维修进展。

实现细节：

| 环节 | 处理方式 |
| --- | --- |
| 首轮装配 | 有界摘要、近期规范消息、启用注入的显式偏好；不执行情景向量检索 |
| 按需检索 | `memory.search` 每次选择 `episode` 或 `profile`，编码与检索共用一次期限预算 |
| 候选过滤 | 当前组织、用户、有效状态，必要时核对稳定实体引用 |
| MySQL 回查 | 当前版本、来源消息、遗忘状态、有效期和实体权限 |
| 上下文装配 | 去重、保留时间与来源，在目标、约束和当前证据之外按预算补充 |

原轮上下文以历史上界冻结，再生成和恢复沿用同一快照，并重新过滤不可读来源。摘要或情景包含不能读取的目标证据时整段不注入。Qdrant 或编码故障保留当前请求和有效近期背景，缺少关键历史再澄清；画像偏好可以直接从 MySQL 获取。

<!-- question-id: q-f074683f105b -->
###### 新旧记忆冲突、用户修改偏好怎么办？

面试回答：

先区分当前请求、手动表达偏好和自动画像。当前明确要求优先，个人中心手动设置其次，自动记忆偏好再次；这些内容只影响表达和理解，实际动作、统计期间和资源选择仍按本次请求及业务规则确认。

用户明确修改长期偏好时，同一事实键更新为新的当前值，保留来源和版本，并登记旧投影清理；临时指令只用于本次回答。历史任务和维修事件按时间分别保留，查询现状时重新读取当前业务事实。

实现细节：

| 内容 | 保存与生效 |
| --- | --- |
| 当前请求 | 本次回答优先采用，例如“这次用列表” |
| 手动表达偏好 | 账号内保存称呼、风格和详略；版本校验后写入，新运行冻结有效设置 |
| 自动显式画像 | 从用户明确表达中提取，例如“默认用表格”；同键当前值或墓碑，来源消息有先后约束 |
| 历史情景 | 保留事件时间、来源和当时背景，当前状态通过业务工具核实 |

自动画像提取与遗忘共用用户锁，旧来源不能越过遗忘水位或覆盖新来源。投影滞后时以 MySQL 当前版本决定是否可用，精确删除旧版本点，避免清理任务误删新事实。称呼内容按数据处理，不能改变系统指令或授权。

<!-- question-id: q-8e9c20e39e90 -->
###### 多租户隔离和删除怎么处理？

面试回答：

工作记忆按组织、用户和会话隔离，向量召回按组织与用户过滤，再检查来源、版本和当前访问权。平台助手只使用本人有界会话历史，租户长期记忆留在租户范围内。

用户遗忘画像时，在 MySQL 保存删除墓碑和消息抑制水位，后续旧消息不能重新提取同一事实。旧版本向量删除通过持久任务交给 Worker，失败重试；删除会话还清理近期缓存、情景和仅由该会话支撑的画像。查询侧立即按 MySQL 排除失效记录。

实现细节：

| 操作 | 当前处理 |
| --- | --- |
| 删除一条画像 | 同用户锁内保存墓碑和遗忘水位，登记该旧版本点的删除任务 |
| 清空记忆 | 推进相应处理游标与抑制水位，阻止旧消息再次生成已遗忘内容 |
| 删除会话 | 清理工作缓存、软删情景、登记向量删除，清理仅由本会话支撑的画像 |
| 变更组织 | 在原事务清理旧组织事实并登记删除，Worker 按原稳定范围处理 |
| 投影删除失败 | Outbox 持久任务进入重试／死信，全部外部删除成功后才完成 |
| 关闭长期记忆 | 停止相应整理与注入，保留已有事实和 checkpoint；手动表达偏好、当前工作记忆独立生效 |

新消息明确重申某个偏好时，来源晚于遗忘水位才可恢复该事实键。删除任务使用精确旧版本点 ID，旧清理与新投影并发时不会删除新值；会话删除后的迟到任务也不能重新整理其内容。

##### 评测与结果

<!-- question-id: q-cbcf97916232 -->
###### 怎么判断记忆有没有帮助？

面试回答：

记忆效果通过同一批历史任务的对照评估判断，比较启用长期召回与只用近期对话的表现。评估关注相关背景是否找回、设备或工单是否定位正确、用户是否减少重复说明，以及跨会话任务能否正确完成。

对照同时检查历史背景的有效性、实体定位准确性和当前业务状态，覆盖偏好更新、来源撤权及设备进展变化。再记录上下文 token 和额外耗时，将背景复用、任务完成情况与召回开销放在同一组条件下评估。

实现细节：

指标与核对内容见表。对照保持任务、历史来源和执行条件一致，分别观察背景复用、实体定位、当前事实正确性及成本，以跨会话任务的实际结果衡量记忆价值。

| 指标 | 检查内容 |
| --- | --- |
| 召回相关性 | 历史信息是否与当前问题相关 |
| 实体定位准确率 | 是否关联正确资产、机型或工单 |
| 过时与冲突比例 | 是否注入被替代或不再适用的信息 |
| 跨会话任务完成情况 | 是否减少重复背景补充且正确完成任务 |
| 上下文 token 与耗时 | 记忆带来的额外成本 |

| 测试样例 | 判断规则 |
| --- | --- |
| 同组织两台同名设备，追问“上次那台” | 关联正确业务 ID，信息不足时澄清，不默认第一条 |
| 已讨论设备的维修进展发生变化 | 用历史定位对象，用业务查询回答当前进展 |
| 默认表格，用户说“这次用列表” | 本次使用列表，长期展示偏好不变 |
| 用户明确修改默认展示格式 | 新版本生效，旧来源和旧向量不覆盖新值 |
| 来源被撤权、删除或失效 | 派生记忆不进入上下文 |
| 遗忘后再次处理保留的来源消息 | 遗忘控制阻止同一信息重新形成记忆 |
| Redis 过期或语义检索服务故障 | 能加载有效近期信息；缺失历史时澄清，不虚构背景 |

每条样例记录期望实体、可用来源、应排除信息、实际注入片段与任务结果，同时记录输入 token 和额外检索耗时。将对象选错、旧偏好覆盖、来源越权分别归因，便于区分检索相关性问题与权限、更新流程问题。

##### 易混点与回答检查

工作记忆、历史摘要、情景与显式画像分别维护；首轮装配和按需语义召回分开，历史线索通过业务工具衔接当前事实。

- [ ] 能说明首轮为何不自动执行情景向量检索。
- [ ] 能区分手动表达偏好、自动画像和当前任务指令。
- [ ] 能解释原轮历史上界、冻结上下文及规范消息版本。
- [ ] 能按遗忘水位、墓碑和独立游标说明如何阻止旧消息复活。
- [ ] 能说明精确旧版本投影删除与 MySQL 当前版本复核。
#### 文档处理、视觉检索与问答评测

简历表述：RabbitMQ 异步处理 PDF 页面渲染与文本提取，MinerU 补充 OCR；ColQwen 实现页面视觉检索，校验文档权限和版本并生成带页码引用的回答；Recall@10、MRR@10、NDCG@10 分别为 0.945、0.798、0.839。

##### 快速回顾

| 复盘点 | 核心内容 |
| --- | --- |
| 业务问题 | 农机手册包含表格、结构图和操作示意，纯文本提取容易丢失版面和图文关系 |
| 入库链路 | 上传 → 持久事件与 RabbitMQ → 渲染和原生文本 → 完整视觉索引发布 → 独立补文字 |
| 数据分工 | OSS 保存原件和页面图片；MySQL 保存当前内容修订、发布页面、文字和任务；Qdrant 保存派生索引 |
| 视觉检索 | ColQwen 对页面和查询生成多向量，通过后期交互匹配相关页面 |
| 生成依据 | 读取页面图片或对应文本，校验权限和版本，返回支持结论的页码引用 |
| 评测单位 | 按问题标注标准证据页，区分召回覆盖、排序质量和最终回答质量 |
| 测评结果 | Recall@10 = 0.945；MRR@10 = 0.798；NDCG@10 = 0.839 |

##### 职责与实现概述

农机维修资料中的故障码表依赖行列和附注，结构图依赖部件位置及连线，操作步骤还可能跨页。文档入库同时保留文本和页面图片，通过页面视觉检索定位这些证据，使知识问答能够使用完整的图文资料。

入库侧通过持久事件和 RabbitMQ 异步执行页面渲染、原生文本提取和 ColQwen 编码，完整视觉索引成功后发布当前内容修订；缺文字时再独立调用 MinerU 补充解析。OSS 保存原件和页面图片，MySQL 保存当前修订、文字、页面与任务，Qdrant 保存派生索引。回答时读取同修订、同发布代次的页面或文字，核对当前权限并返回页码引用。

离线评测按问题标注标准证据页，Recall@10 达到 0.945、MRR@10 达到 0.798、NDCG@10 达到 0.839，分别衡量证据覆盖、首个相关结果的位置和整体排序质量。回答侧核对数值、适用条件及页码引用，将检索到的页面落实为可核对的答案依据。

##### 文档处理与异步任务

<!-- question-id: q-2c342a6b06a0 -->
###### 文档从上传到可检索，经过哪些步骤？

面试回答：

上传先登记原件存储意图，再把 PDF 存入 OSS，在业务事务中绑定文档当前内容修订并登记摄取事件。RabbitMQ 触发 Worker，调用 Runtime 渲染页面、提取原生文本，再使用 ColQwen 编码并把页面多向量写入 Qdrant。

完整视觉索引成功后，后端在文档锁和任务租约校验下发布页面及发布代次。缺文字的文档同时登记独立 `parse_text` 任务，由 MinerU 补充 OCR；文字解析失败保留其错误和重试状态，已经发布的视觉检索继续可用。原件阅读可以直接经过授权入口完成。

实现细节：

| 阶段 | 产物与控制 |
| --- | --- |
| 原件上传 | 精确对象键及上传意图先登记，失败或未知结果进入存储清理 |
| 摄取登记 | 当前内容修订、任务和持久发布事件一起提交 |
| 页面处理 | Runtime 返回页数、页面图片及原生文本，图片存 OSS |
| 视觉索引 | 按批调用 ColQwen，写入本次执行代次隔离的 Qdrant 页面点 |
| 发布 | 锁内复核当前修订、租约及执行资格，原子发布页面和代次 |
| 独立补文字 | 缺文字时登记 `parse_text`，MinerU 结果校验页数、顺序及目标代次后更新 |

内容修订 `content_revision` 标识当前文件，执行代次 `execution_generation` 隔离处理尝试；发布指针决定哪一代页面可供检索。页面 ID 由文档、修订、代次和页码派生，查询命中后还要回查 MySQL 的当前修订与发布代次。尚未发布的页面点即使已写入 Qdrant，也不能进入回答上下文。

<!-- question-id: q-79b0452cdab7 -->
###### 为什么用 RabbitMQ 异步处理？

面试回答：

文档页面渲染、OCR 和模型编码耗时长，大文件、扫描件的资源消耗差异也很大。如果都放在上传接口里，会长时间占用请求线程，用户也不容易区分上传失败还是后台解析失败。所以接口上传后返回任务标识，后台按资源能力处理，用户查询进度。

这里采用 RabbitMQ，主要因为它的任务队列、消费确认和路由机制适合平台当前的任务分发需求，也与已有技术栈匹配。MySQL 保存任务状态，消息触发执行，产物和状态持久化后再确认消息。临时故障有限重试，损坏文件等确定性错误记录原因并终止无效重试。

实现细节：

消费者并发按照页面渲染、OCR 和编码服务的资源能力控制。队列消息确认与业务可检索状态分开，处理成功后同时核对产物与状态，避免只确认消息却丢失阶段结果。

<!-- question-id: q-7348aef4296d -->
###### RabbitMQ 任务如何保证可靠投递、失败恢复和重复执行安全？

面试回答：

任务和持久事件在同一 MySQL 事务中登记，消息发布需要生产者确认并验证可路由；未完成发布的事件保留并重投。消费者按消息 ID 读取数据库任务，重新检查主体、组织和执行资格，完成负责的状态写入后再手动确认消息。临时错误有限重试，耗尽后进入死信。

并发和重投依靠任务的 owner、generation、lease 及当前内容修订隔离。每次取得新的摄取执行代次，都构建独立的页面和索引产物；发布前锁内重新验证，迟到 Worker 不能发布过期结果。文字补解析单独绑定已发布代次，过期目标不能覆盖新文件。

实现细节：

1. **事务到消息**：任务与 Modulith 持久事件共用数据源和事务。Broker 不可用时保留发布登记，等待重投；确认消息进入有效路由后才完成登记。
2. **领取与续租**：领取生成 owner 和执行代次，长任务续租；每次外部调用或关键写入前检查当前执行资格。失租约后停止发布。
3. **摄取重试**：新代次使用独立对象前缀和页面点，重新构建完整视觉索引；同一代次中的稳定 ID 支持安全 upsert，新执行不会沿用旧代次的完成进度。
4. **发布与清理**：文档锁和任务锁内复核修订、代次与资格；清理按精确对象键或代次前缀登记，并排除当前原件、发布页面和有效租约引用。
5. **失败与确认**：失败先持久化任务状态，再进入重试或死信流程；消息确认与文档发布状态分别判断。消费者并发、预取及计算队列共同限制积压对 Runtime 的压力。

替换文件时取消旧任务并清空发布指针，旧 Worker 的迟到结果不能重新成为当前资料；外部上传结果未知时保留清理记录，持续复查迟到对象。

<!-- question-id: q-d01432e2fe1e -->
###### 已经提取文本，为什么还需要 MinerU？

面试回答：

原生文本提取适合带文字层的 PDF，扫描件或文字缺失页还需要 OCR。MinerU 用于补充这部分可读文字与复杂版面内容，帮助回答环节核对故障码、单位、表格附注和操作条件。

当前链路先发布完整视觉索引，再对缺文字的文档登记独立解析任务。Worker 把当前原件交给 MinerU，核对返回页数和顺序，填补缺失文字，并更新同修订、同发布代次的元数据。用户已能通过 ColQwen 找到页面，文字补齐后可以更方便地阅读和取证。

实现细节：

文字解析与视觉索引有独立的进度和失败状态；解析失败进入自身的重试流程。写回前再核对目标发布代次，文件被替换或任务被取消时，旧解析结果失效。表格题读取完整行列标题和附注，结构图题还需读取页面图片、图例或相关区域，按实际读到的内容支撑结论。

##### 视觉检索与证据使用

<!-- question-id: q-61ccf0dfe3d7 -->
###### ColQwen 是什么，为什么适合这个场景？

面试回答：

ColQwen 是面向文档页面的多模态检索模型，可以把页面图片编码成多个向量，再与查询做细粒度匹配。农机资料中有大量表格、结构图和操作示意，纯文本提取可能丢掉布局或部件位置关系，页面检索能利用这些局部视觉信息查找相关页。

比如查询液压回路中某个阀的位置，页面多向量可以利用图中的局部信息定位相关页，再将页面图片、文字和图例送入回答环节核对。这个场景的价值是保留部件与管路的位置关系。页面编码、向量存储和匹配开销按页统计，查询时控制候选页数和证据量，使图文证据的使用与资源预算相匹配。

实现细节：

常见文本检索与页面检索的差异见表。ColQwen 定位相关页面，回答环节再读取原文中的型号、数值和图例，将局部匹配结果转成具体证据。

| 比较点 | 常见文本向量检索 | ColQwen 页面检索 |
| --- | --- | --- |
| 检索对象 | 提取后的文本块 | 文档页面图片 |
| 向量表示 | 通常每个文本块一个向量 | 每个页面多个向量 |
| 主要保留的信息 | 提取出的文字语义 | 页面文字、布局和视觉信息 |
| 资源开销 | 通常较低 | 页面编码、存储和匹配开销更高 |

<!-- question-id: q-52c255ef78ad -->
###### 多向量检索怎么匹配？Qdrant 保存什么？

面试回答：

查询和文档页面都编码成多向量，通过 MaxSim 后期交互计算相关性。可以理解成查询的每个向量去页面向量中找最相似的一项，再汇总这些最大相似度，这样保留问题不同部分与页面局部内容的匹配关系，不必先把整页压成单个向量。

Qdrant 保存页面多向量，以及文档、内容修订、执行代次、页码和组织等过滤元数据。原文件与页面图片仍在 OSS，文档和页面业务关系在 MySQL，召回后要回查原始证据。查询与页面编码保持模型和配置兼容，升级导致向量空间变化时要重建相应索引，不能把不同模型的向量直接混用。

实现细节：

设查询向量为 `q_i`、页面向量为 `d_j`，分数为 `sum_i max_j sim(q_i, d_j)`，即对每个查询向量取页面侧最大相似度后求和。以归一化向量点积得到的相似度为例：

| 查询向量 | 页面向量 d1 | 页面向量 d2 | 页面向量 d3 | 本行最大值 |
| --- | --- | --- | --- | --- |
| q1 | 0.2 | 0.8 | 0.1 | 0.8 |
| q2 | 0.6 | 0.3 | 0.4 | 0.6 |

该页 MaxSim 得分为 `0.8 + 0.6 = 1.4`。最大值分别来自不同页面向量，因此能保留问题不同部分的局部匹配。各候选页按此相关性分数排序，选出供后续读取和核对的证据页。

页面点使用名为 `colqwen` 的多向量字段，payload 包含如下定位与过滤信息：

```json
{
  "document_id": "doc-7",
  "page_id": "8c77c6e1-752f-50b0-84f6-aac832a0ea24",
  "content_revision": 3,
  "execution_generation": 8,
  "page_number": 12,
  "organization_id": "42",
  "library_scope": "organization",
  "model_version": "encoder-v1"
}
```

集合使用 MaxSim 匹配，向量维度和模型配置一致。payload 用于候选过滤；最终有效性还需核对 MySQL 当前修订、发布代次及权限。页面图片、文字与引用沿同一定位读取，替换文件后旧页面不能因索引清理滞后而再次生效。

<!-- question-id: q-7e72533ba58c -->
###### 视觉检索和 OCR 是什么关系？

面试回答：

视觉检索负责定位相关页面，原生文本或 OCR 提供模型可读取的文字、表格与注释。比如用户查故障码，先找到故障码表所在页，再读取对应行、列标题和适用条件，形成有具体内容支撑的回答。

回答链路将召回结果关联回具体版本和页面，校验后从 OSS 读取页面图片，并加载对应原生文本或 MinerU 结果。查故障码时加载表格行、列标题、单位和附注，问阀的位置时加载结构图及图例。页面向量完成相关性匹配，原图和解析内容提供生成证据。

实现细节：

例如召回“故障码 E01”所在页后，证据内容需要包含 E01 对应行、含义列、排查步骤及适用机型，并保留页面 ID；只给一段缺少列标题的 OCR 文字可能造成错配。结构图问题则将页面图片连同图例交给具备视觉输入能力的生成环节。文本生成链路只使用已提取、能支撑结论的文字与结构化证据，缺少图中关系时需要补充图像理解结果或说明证据缺口。

页面图和文字通过同一内容修订、发布代次及页面 ID 对齐。候选只由 ColQwen 页面检索产生，原生文本和 OCR 用于命中后的阅读取证；视觉读取失败时可使用已有文字，ColQwen 检索故障则返回服务失败。

| 环节 | 输入与输出 | 主要职责 |
| --- | --- | --- |
| 视觉检索 | 查询与页面多向量 → 相关页面 | 定位证据页 |
| 原生文本 / OCR | 页面 → 可读文本或结构化内容 | 提供文字、表格行列及注释信息 |
| 多模态生成 | 页面图片及相关文本 → 回答 | 结合视觉证据解释内容 |
| 纯文本生成 | 原生文本、OCR 或结构化内容 → 回答 | 需先提供可读证据，不能输入检索向量代替原文 |

<!-- question-id: q-25f95709cd34 -->
###### 文档权限、版本和页码引用怎么处理？

面试回答：

检索前按知识范围和元数据过滤，命中后回查 MySQL 的当前授权、文档生命周期、内容修订和发布代次。只有仍然有效的当前页面才能用于回答，索引滞后时的旧页面会被排除。

引用保留文档、内容修订、发布代次、页面 ID 和 PDF 物理页码，原文预览和下载时再次授权。替换文件会立即切换当前修订、清空旧发布指针并取消旧任务，旧引用随即失效；新文件处理失败保留当前处理错误，等待重新处理。

实现细节：

| 标识或状态 | 作用 |
| --- | --- |
| 文档 ID | 持续标识同一份资料记录 |
| `content_revision` | 标识当前原件的内容修订，替换时增加 |
| 发布代次 / 页面 ID | 确认引用来自当前成功发布的那次处理 |
| `page_number` | PDF 物理页序，用于原文定位 |
| 当前授权与生命周期 | 检索、页面读取、引用预览及原件下载分别复核 |

例如当前修订为 3、发布代次为 8，引用指向物理第 12 页；若正文印刷页码为 8，可在解释中标明两者关系，跳转仍按系统保存的物理页序。跨页步骤和警告条件分别关联支持页面。系统维护当前文件与当前发布页面，失效引用不能跳转到同名新文件的相似页。

##### 评测与结果

<!-- question-id: q-5b7dfea9cbcc -->
###### 离线评测集怎么构建？

面试回答：

我们从农机手册、技术规范和操作资料中整理问题，覆盖文字参数、表格行列、图示部件、跨页条件，以及无答案或信息不足的场景。题目既有直接查询，也有业务中的自然表达，比如保养周期、适用型号、部件位置和多页操作要求。

每道题标注文档版本、参考答案及支持回答的证据页或片段，以标准证据页计算命中。调参集和测试集分开，同一道题的近似改写放在同一组；固定版本、证据和指标口径后比较检索配置，无答案题单独检查澄清和证据不足处理。

实现细节：

各题型的标注重点见表。跨页问题保留完整证据页集合，表格标注对应行列、单位与注释，图示题标明支持信息。

| 题型 | 主要检查 | 标注重点 |
| --- | --- | --- |
| 文本查询 | 条文与参数是否召回 | 文档版本、证据页或片段 |
| 表格查询 | 对应行列、单位与注释 | 能够支持结论的表格位置 |
| 图示查询 | 部件、结构或操作图定位 | 图示所在页及支持信息 |
| 跨页查询 | 多项证据是否覆盖 | 完整证据页集合 |
| 无答案或信息不足 | 是否正确拒答或澄清 | 不足原因，单独评估 |

<!-- question-id: q-67f0502a4555 -->
###### Recall@10、MRR@10 和 NDCG@10 分别说明什么？

面试回答：

Recall@10 看前十条结果找全了多少标准证据；MRR@10 看第一个正确结果有多靠前；NDCG@10 进一步看高相关内容在整体排序中的位置，按名次折损收益，再与理想排序比较。

比如一道题有三个证据页，前十条找到了两个，Recall 就是三分之二；第一条正确结果在第二位，倒数排名就是二分之一。项目测得 Recall@10 为 0.945、MRR@10 为 0.798、NDCG@10 为 0.839，分别反映检索覆盖、首个相关结果位置和整体排序。回答侧继续核对事实、条件和引用，完整链路统计耗时与成本。

实现细节：

计算含义见表。MRR 在前 10 条没有相关结果时记 0，再按题平均；NDCG 可以采用二元或分级相关性，但对照时标注与计算方式必须一致。无答案题单独检查拒答和澄清，不混入普通证据召回分母。

| 指标 | 计算含义 | 关注点 |
| --- | --- | --- |
| Recall@10 | 前 10 条命中的标准证据数 ÷ 标准证据总数，再对问题取平均 | 证据是否找全 |
| MRR@10 | 第一个相关结果排名的倒数；前 10 条无相关结果记 0，再取平均 | 用户多久能看到第一个正确结果 |
| NDCG@10 | 对相关性收益按位置折损，再除以理想排序的收益 | 高相关结果是否整体排在前面 |

NDCG 的计算形式为 `DCG@k = sum_i gain(rel_i) / log2(i + 1)`，`NDCG@k = DCG@k / IDCG@k`。IDCG 将同一组标准相关页面按收益从高到低放在理想位置后计算，不能只把实际召回到的页面重排来构造分母。

例如采用分级相关性与 `gain(rel) = 2^rel - 1`，两个标准页面的相关等级为 2 和 1，理想前两位 DCG 为 `3 + 1/log2(3) ≈ 3.631`；实际顺序反过来时为 `1 + 3/log2(3) ≈ 2.893`，NDCG@2 约为 `0.797`。采用二元标注时，相关页收益为 1、无关页为 0，排序越靠后折损越大。离线对照固定相关性等级、收益函数、截断位置及平均口径，避免配置变化导致指标不可比。

<!-- question-id: q-b9c81b1bb01e -->
###### 视觉检索相比纯文本方案如何评估效果，资源成本怎样衡量？

面试回答：

对照纯文本检索与页面视觉检索时，围绕农机资料中的文本参数、表格、结构图和跨页问题，固定文档版本、问题及标准证据，分别比较证据覆盖和排序。图表题重点检查行列、部件位置和图例是否被完整保留，回答侧核对数值、条件与引用，使评价对应页面视觉检索的主要应用价值。

资源成本按入库和在线查询拆开统计：入库记录页面渲染、OCR、编码耗时与向量存储；在线记录查询编码、检索、证据加载和生成耗时，以及模型调用与上下文开销。项目现有 Recall@10、MRR@10、NDCG@10 给出页面检索的覆盖和排序结果；配置选择结合分题型证据质量与成本，控制页面向量数量、候选页数和生成证据量。

实现细节：

1. 对照固定语料版本、权限范围、问题分组与标准页集合，保持相同截断数量，并分别记录各方案的解析、编码和排序配置。
2. 分题型记录 Recall、MRR、NDCG、证据完整率和引用支持情况；跨页题检查必要证据是否齐全，无答案题检查是否澄清或停止生成。
3. 入库记录页数、页面图体积、OCR 与编码耗时、每页向量数、总存储和失败重试；同一规模的文档才能比较成本。
4. 在线按冷缓存与预热、固定并发分别记录查询编码、Qdrant 查询、OSS 证据读取及生成耗时，观察端到端 P95、输入 token 和图片处理开销。
5. 调整候选数量或压缩表示时，同步核对标准证据页覆盖、回答质量和端到端耗时，选择符合图文问题需求与资源预算的配置。

##### 易混点与回答检查

视觉索引决定页面能否召回，原生文本和 OCR 提供阅读内容；引用绑定当前修订及发布代次，检索命中后继续核对当前权限和已读证据。

- [ ] 能说明完整视觉索引先发布、缺文字再独立补解析的顺序。
- [ ] 能区分内容修订、执行代次、发布指针和 PDF 物理页码。
- [ ] 能解释新摄取代次重建、租约校验及迟到产物清理。
- [ ] 能说明文件替换后旧引用失效和失败后的重新处理。
- [ ] 能计算 Recall、MRR、NDCG，并区分检索排序与回答证据质量。
#### 图像识别服务与 MCP Server

简历表述：接入 FastAPI/PyTorch 图像识别服务，返回 Top-K 候选机型和置信度供人工复核；开发 MCP Server 提供图像识别、知识检索与问答、标准机型查询和故障排查建议。

##### 快速回顾

| 复盘点 | 核心内容 |
| --- | --- |
| 业务目的 | 根据设备照片缩小机型范围，人工确认后用于资产关联和资料查询 |
| 识别模型 | 当前部署配置为 ConvNeXt Tiny；权重、类别映射与输入预处理一起加载 |
| 服务分工 | PyTorch 负责推理，FastAPI 提供内部接口，Java 后端负责认证与业务处理 |
| 返回结果 | Top-K 候选、置信度、模型版本和人工复核状态 |
| 结果使用 | 模型分数辅助候选排序，人工确认标准机型，业务服务校验具体资产关联 |
| 稳定性 | 输入校验、连接与读取超时、有界推理队列，识别不可用时支持手动选择 |
| MCP 能力 | 图片识别、机型目录、知识检索、知识问答、故障排查、调度预览、维保准备、成本分析 |
| 调用边界 | 客户端模型选择工具，MCP Server 校验执行，后端统一控制权限与业务规则 |
| 权限与错误 | 当前用户权限 ∩ 客户端同意能力 ∩ 固定只读工具；区分空结果、证据不足与执行失败 |

##### 职责与实现概述

录入农机或查询资料时，用户可以上传照片取得候选机型，再结合铭牌确认标准型号，继续查询对应说明书和维保资料。图像识别服务通过 PyTorch 推理、FastAPI 提供内部接口，Java 后端处理认证、图片校验、候选映射和人工复核。

识别结果返回 Top-K 候选、置信度和模型版本，用户结合铭牌等信息确认后，再关联标准机型，用于后续资料检索。服务调用设置超时和并发限制，模型不可用时支持手动选择机型，使识别结果能够衔接到平台中的资产与资料查询。

MCP Server 提供八项固定只读工具，组织用户登录并逐项同意后，外部客户端可读取共享知识和当前用户有权访问的组织资料、调度冲突与成本汇总。Backend 派生租户及经营范围并逐次复核权限；图片识别只做临时推理，业务工具返回预览和依据，实际安排、工单及费用变更通过业务入口执行。

##### 业务场景与模型选择

<!-- question-id: q-823bb9891826 -->
###### 图像识别在项目中解决什么问题？

面试回答：

用户录入农机设备或查资料时，不一定知道准确型号。我接入图片识别服务，根据照片返回候选机型和置信度，先缩小范围，再让用户结合铭牌、品牌和设备参数确认标准机型。确认后，就可以继续查对应说明书、保养要求或故障资料。

不同系列和配置外观相近，角度、遮挡和背景也会影响分类，因此保留 Top-K 供用户比较。标准机型用于定位型号及对应资料，组织资产通过资产编号、归属和用户确认进一步关联，识别结果由此衔接到实际业务查询。

实现细节：

图片识别辅助机型定位，再衔接知识问答。候选、模型版本和人工复核结果分别保存，最终确认的标准机型用于资料查询，具体资产关联由业务服务校验。

<!-- question-id: q-7dd8c390892e -->
###### 当前使用什么图像识别模型，接入时要保证什么？

面试回答：

当前部署配置使用 ConvNeXt Tiny，将农机照片分类为模型已知的机型候选。ConvNeXt 是采用现代网络设计的卷积架构，Tiny 是其中较小的规格。服务返回 Top-K 和分数，后端再做标签映射与复核处理。

接入时最关键的是权重、类别顺序和预处理一致。输入尺寸、RGB 转换和归一化影响模型看到的图片，类别映射决定输出索引对应哪个型号；这些配置需要随权重一起管理。模型计算封装在独立 Runtime 中，后端沿用候选和模型版本契约，升级模型时再验证映射、效果与资源开销。

实现细节：

| 接入项 | 当前处理 |
| --- | --- |
| 模型架构 | Compose 指定 ConvNeXt Tiny 权重；加载器显式支持 ConvNeXt Tiny、ResNet18，也可读取包含完整模型对象的 checkpoint |
| 类别映射 | 从 checkpoint 的 `classes` 或按索引排序的 `class_to_idx` 读取 |
| 输入尺寸 | 优先读取 checkpoint 的 `img_size`，缺省使用服务配置 |
| 预处理 | 转为 RGB、缩放、转 Tensor，再按约定均值和标准差归一化 |
| 推理输出 | Softmax 后取 Top-K，返回标签、分数和模型版本 |

机型分类面向照片中的设备，ColQwen 面向资料页面中的证据定位，两项能力各自管理权重、预处理和输出结构。

##### 服务接入与结果处理

<!-- question-id: q-082a1bc6278f -->
###### FastAPI、PyTorch 和 Java 后端分别负责什么？

面试回答：

Java 后端负责用户认证、文件与业务校验，调用内部模型服务后，把候选标签映射为标准机型，再处理人工复核和业务关联。FastAPI 提供内部 HTTP 接口，负责图片解码与预处理，PyTorch 加载分类模型权重并完成推理，返回 Top-K、分数和模型版本。

模型服务主要做计算，不直接读取组织资产或工单，这样模型资源和业务服务可以分别部署、限流和升级。预处理中的尺寸、颜色通道和归一化要与训练配置一致，类别索引与机型标签也随权重管理，否则模型即使正常返回，也可能被映射成错误名称。

实现细节：

组件职责和完整调用顺序见表与流程。Java 后端将分类结果转换为标准机型候选，用户确认后完成业务关联，整个请求由后端统一执行认证和资源校验。

| 组件 | 职责 | 关键约束 |
| --- | --- | --- |
| Java 后端 | 认证、文件校验、机型映射与复核流程 | 统一业务规则及访问范围 |
| FastAPI | 内部接口、图片解码与预处理 | 预处理与模型训练配置一致 |
| PyTorch / ConvNeXt Tiny | 模型加载与分类推理 | 权重、类别映射和模型版本一致 |
| 用户确认 | 结合铭牌等信息确认候选 | 确认后再完成业务关联 |

```text
用户上传图片
    ↓
Java 后端：认证、文件校验、业务处理
    ↓
FastAPI：图片解码和预处理
    ↓
PyTorch / ConvNeXt Tiny：模型推理
    ↓
返回 Top-K、置信度和模型版本
    ↓
Java 后端：关联标准机型、返回候选
    ↓
用户确认后完成业务关联
```

Runtime 在内部按类别索引读取标签，接口返回标签、Top-K 分数和模型版本。Backend 根据标签查找标准机型，映射成功后返回机型信息；未匹配到有效机型的候选保留待确认状态。模型版本与类别映射共同决定标签含义。

人工复核分别记录推荐候选与最终选择：用户可以选另一候选，也可以从标准机型库手动选择。确认后的 `modelId` 用于资料检索；关联组织具体资产时，由业务服务校验资产归属和操作权限。模型候选、人工选择和资产关联分别保存，支持追踪从识别到业务使用的完整过程。

<!-- question-id: q-840926a45d4e -->
###### 为什么返回 Top-K？置信度能不能当成正确率？

面试回答：

农机相近型号的外观可能很接近，Top-K 可以保留多个候选，让用户结合铭牌和其他角度比较。模型输出的 Softmax 分数反映已知类别间的相对倾向，未经校准不能直接理解成这次识别正确的概率；一张不属于任何已知类别的图片也可能得到较高分。

当前后端按可配置的置信度阈值区分 `accepted`、`review_required` 和 `failed`，同时返回决策原因和策略版本。使用结果时还要核对标签与有效机型的映射；照片不清晰或候选接近时，可补照片、查看铭牌或手动选型。组织识别入口保存识别与复核记录，资产关联继续经过业务权限校验。

实现细节：

分数含义及使用方式见表，复核检查项见列表。模型分数辅助排序，人工复核确定标准机型，资产关联进一步核对组织中的具体设备。

| 信息 | 判断依据 | 使用方式 |
| --- | --- | --- |
| Top-K 候选 | 外观相近的模型已知类别 | 结合铭牌、参数和其他角度比较 |
| Softmax 分数 | 已知类别间的相对倾向 | 用于候选排序，未知类别结合输入检查和人工复核处理 |
| Top-1 与 Top-2 差距 | 候选之间的接近程度 | 差距小时重点提示补照片或核对铭牌 |
| 标准机型与具体资产 | 型号及组织内设备记录 | 先确认标准机型，再按资产标识和归属建立关联 |

- Top-1 分数是否足够高。
- Top-1 与 Top-2 的差距是否明显。
- 图片是否清晰，设备主体是否完整。
- 候选类别是否能映射到有效标准机型。

<!-- question-id: q-3c9bb75b03bc -->
###### 模型服务超时或者不可用，怎么处理？

面试回答：

输入问题和服务故障分别返回。格式错误、文件损坏、字节数或像素超限时，提示用户换图；模型未加载、连接失败或超时时返回不可用，让用户稍后重试或手动选择机型。Runtime 将识别放在独立串行计算通道中，限制在途请求数量，过载及时拒绝。

Backend 的内部调用设置连接和读取超时，MCP 还用总 deadline 约束令牌获取、Backend 请求和取消传播。一次失败保留明确错误，是否重新发起由调用方决定；重试前先区分输入错误、模型未就绪和暂时故障，避免重复提交放大压力。

实现细节：

进入推理前验证格式、文件字节和解码结果，进一步限制单帧、总像素和资源占用。识别就绪接口检查权重、预处理和类别映射加载状态，与服务存活、PDF 及 ColQwen 就绪分别观察。

| 情况 | 当前处理 |
| --- | --- |
| 图片无效或超限 | 返回输入错误，修改图片后重新提交 |
| 模型未加载 | 返回不可识别，排查权重、类别与运行依赖 |
| 计算通道满 | 返回繁忙，限制继续进入的计算 |
| 推理完成但分数不足 | 按阈值返回复核或失败状态，结合铭牌及手动选型 |
| 连接／读取超时或 MCP 取消 | 返回相应失败或取消状态，不把故障当成已确认机型 |

验证时分别记录排队、服务调用和推理耗时，核对超时后界面仍可重传或手动选型；识别失败不阻塞正常业务录入。

##### MCP 工具与调用边界

<!-- question-id: q-50f8ceb6923d -->
###### MCP 是什么，为什么已经有 HTTP 接口，还要做 MCP Server？

面试回答：

MCP 的全称是 Model Context Protocol，用于让 AI 应用以统一方式连接外部工具和数据。普通 HTTP 接口已经提供业务能力，MCP Server 再把这些能力描述为可发现的工具，提供工具说明、参数 Schema 和调用方式，方便支持 MCP 的客户端接入。

MCP Server 将识别、知识和三项业务只读能力封装为标准工具，执行时使用用户授权，复用 Java 后端的业务规则和访问范围。比如外部助手可以先识别图片，请用户确认机型，再调用知识问答查询保养要求。这样减少每个客户端分别理解和适配业务 API 的工作，业务实现和权限仍由原后端维护。

实现细节：

工具能力见表。客户端模型与编排层根据工具描述选择调用，MCP Server 提供工具发现和调用适配，HTTP 服务承载实际业务。这一分工让客户端复用统一工具协议，同时由后端集中维护业务实现。

| 工具能力 | 解决的问题 |
| --- | --- |
| 图片识别 | 根据照片获取候选机型 |
| 标准机型查询 | 确认品牌、型号和机型类型 |
| 知识检索 | 查找相关手册与证据 |
| 知识问答 | 根据资料生成带引用的回答 |
| 故障排查 | 结合现象、故障码与资料给出排查建议 |
| 调度预览 | 核对指定设备、可选机手和时间窗口的冲突，不预留资源 |
| 维保准备 | 汇集登记保养基准、分页工单历史和手册候选 |
| 成本分析 | 按明确期间计算已审核 CNY 费用与有效计量的授权汇总 |

<!-- question-id: q-80f7a21f27a4 -->
###### MCP 工具怎么定义，模型怎么选择工具？

面试回答：

每个 MCP 工具都定义清楚名称、适用场景、输入 Schema 和返回结构，同时说明是否写入数据。客户端获取工具描述后，模型根据用户目标提出工具名和参数，客户端与 MCP Server 校验后执行，Java 后端再检查实际业务范围。

例如图片识别工具接收图片和文件信息，返回候选、置信度与复核建议；知识检索返回证据，知识问答基于证据生成回答。清晰的输入输出帮助客户端模型选择合适工具，MCP Server 收到调用后校验参数，Java 后端按当前授权用户核对访问范围并执行。

实现细节：

工具发现返回名称、说明与 `inputSchema`，调用通过 `tools/call` 提交工具名及 `arguments`。下面以图片识别为例展示描述、调用和结果结构；返回内容区分候选、证据和业务回执，各参与方职责见表。

| 参与方 | 负责什么 | 执行依据 |
| --- | --- | --- |
| 客户端模型与编排层 | 根据目标和工具描述提出调用 | 用户目标、工具说明及参数 Schema |
| MCP Server | 工具发现、Schema 校验与调用处理 | 工具定义及已认证调用身份 |
| Java 后端 | 实际业务能力与权限检查 | 授权用户、客户端同意能力、当前访问范围与业务规则 |
| 内部模型服务 | 执行图像等模型计算 | 通过校验的图片与模型配置 |

```json
{
  "name": "farm_machinery_run_image_recognition",
  "description": "对单张农机图片执行一次不落库的型号推理，返回候选机型、置信度和复核建议",
  "inputSchema": {
    "type": "object",
    "properties": {
      "image_base64": {"type": "string", "minLength": 4, "maxLength": 11188908},
      "file_name": {"type": "string", "minLength": 1, "maxLength": 180, "pattern": "^[A-Za-z0-9][A-Za-z0-9._ -]*$"},
      "content_type": {"type": "string", "enum": ["image/jpeg", "image/png", "image/webp"]},
      "response_format": {"type": "string", "enum": ["markdown", "json"], "default": "markdown"}
    },
    "required": ["image_base64", "file_name", "content_type"],
    "additionalProperties": false
  }
}
```

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "farm_machinery_run_image_recognition",
    "arguments": {
      "image_base64": "...",
      "file_name": "tractor.jpg",
      "content_type": "image/jpeg",
      "response_format": "json"
    }
  }
}
```

工具成功结果同时提供 `content` 和 `structuredContent`；选择 `json` 时，文本内容也是结构化结果的 JSON。识别字段包含 `status`、`confidence`、`top_k`、模型版本、复核标记和决策原因，`references` 标明推理结果未持久化。

图片 Schema 拒绝额外字段，`file_name` 必填，支持 JPEG、PNG、WebP；Base64 解码后还限制 8 MiB 字节数，再由后端和 Runtime 校验内容、像素及资源占用。调用中的图片内容须为实际编码，远程图片 URL 不作为输入。

三个业务工具使用 `request.mode=candidates|query`：同名资源先返回候选由用户选择，已有明确 ID 可直接查询。调度输入明确起止毫秒时间戳，成本输入起止日期；经营单元、场站只是当前授权内的筛选条件，组织身份由 Backend 派生。返回结构同时保留范围和分页信息，截短结果标注不完整。

<!-- question-id: q-b93f3dc8ee4f -->
###### MCP 的权限和错误怎么处理？

面试回答：

用户通过浏览器登录 AMMS，对客户端逐项同意只读能力，MCP 使用取得的用户令牌调用 Backend。实际访问取当前业务权限、客户端同意能力和固定工具能力的交集；Backend 每次重新核对有效成员、动作和经营范围。知识包含平台共享及本组织可见资料，调度、维保和成本只返回授权范围内的预览、依据或汇总。

授权可以在个人中心撤销。权限变化在后续调用时重新生效，停用成员等操作还会撤销授权。工具结果区分成功空结果、证据不足、参数或权限错误、超时与服务不可用，客户端据此调整参数、澄清或重试。

实现细节：

| 环节 | 约束 |
| --- | --- |
| 用户授权 | 授权码流程结合 PKCE S256，固定客户端和精确回调地址 |
| 每次调用 | Backend 从令牌派生用户和租户，复核当前有效成员与业务授权 |
| 数据范围 | 用户权限、客户端同意 scope、固定工具能力取交集；平台账号不能取得租户能力 |
| 业务副作用 | 八项工具只读；识别不保存记录，调度不占用资源，维保不建工单，成本不生成单据 |
| 授权生命周期 | 普通浏览器退出保留独立 MCP 连接；修改密码、退出所有设备、成员停用或移除撤销授权 |
| 传输与取消 | 远程使用 Streamable HTTP，本地 stdio 通过同一用户授权桥接；取消传播到 Backend 请求 |

JSON-RPC 报文或方法错误使用协议错误响应；已进入工具执行后的可恢复业务错误，通过 `isError: true` 和可理解的错误内容返回。空结果属于成功观察，证据不足描述缺少的资料或条件；来源故障保留失败状态，不伪装成空列表。工具范围和当前用户权限都不能由模型声明扩大。

##### 接入验证

<!-- question-id: q-a4c5e295e1cb -->
###### 如何验证图像识别接入和 MCP 工具调用正确？

面试回答：

图像识别先验证完整业务链路：图片是否按模型要求预处理，返回的类别索引能否按版本映射到正确标准机型，Top-K 是否包含有用候选，以及用户改选后后续检索和资产关联是否使用最终选择。还要覆盖模糊、遮挡、未知类别和坏图片，保证不会把高分或服务失败直接当作已确认机型。

MCP 从工具发现开始验证，检查描述和 Schema 能否支持正确调用、非法参数是否被拒绝、结果及引用能否被客户端理解。重点测试租户隔离、同意能力与业务权限交集、撤销后的访问拒绝，以及空结果、证据不足与执行失败的区分。同时记录推理和工具调用的耗时、重试及资源占用，检查超时和过载后能否继续手动选型。

实现细节：

| 验证范围 | 用例与核对标准 |
| --- | --- |
| 分类与映射 | 固定图片、模型版本和预期标准机型，核对类别索引、标签与业务映射 |
| Top-K 与人工复核 | 统计正确机型是否进入候选；改选后保留原推荐，最终选择用于后续查询 |
| 异常与未知输入 | 模糊、遮挡、非农机、损坏文件、超大像素；返回候选待复核或明确输入错误 |
| 服务故障与容量 | 模型未加载、连接失败、慢响应、并发过载；总时间与排队有界，支持手动选择 |
| MCP 发现与调用 | 工具可发现，Schema 必填项、字段类型、额外参数限制有效，调用返回结构可解析 |
| 用户授权边界 | 未同意能力、超出经营范围、跨租户资源及平台账号请求被拒绝；撤销、撤权及停用后不再返回受限数据 |
| 只读契约 | MCP 识别不创建记录，调度不预留资源，维保不创建工单，成本只返回授权汇总 |
| 证据与错误分类 | 问答引用关联正确版本与页面；区分空结果、资料不足、协议错误和工具执行失败 |

每次验证关联请求 ID、模型与映射版本、候选、最终人工选择、工具名、错误类别和各阶段耗时。识别侧观察 Top-K 覆盖与人工改选情况，服务侧观察 P95、超时率、并发和重试次数，分别衡量候选实用性与接入稳定性。完整链路核对最终选择、资料引用及实际业务关联。

##### 易混点与回答检查

识别分数用于候选排序，业务关联核对机型和具体资产；MCP 的用户授权独立于浏览器会话，工具能力受当前业务权限约束。

- [ ] 能说明 ConvNeXt Tiny、预处理、类别映射和模型版本的关系。
- [ ] 能区分组织识别的持久记录与 MCP 的临时纯推理。
- [ ] 能列出八项 MCP 工具及三个业务工具的只读结果。
- [ ] 能解释用户权限、同意能力和固定工具能力的交集。
- [ ] 能区分协议错误、工具执行失败、空结果和证据不足。
## Java 八股

#### JavaSE

<!-- question-id: q-27c8396ebb3d -->
###### JDK新特性

1. JDK8：Lambda 表达式、Stream 流、接口默认方法 \+ 静态方法、新日期时间 API java\.time、方法引用 ::

2. JDK11：HTTP Client 正式版、String 增强、可以直接运行单个 java 文件、ZGC 垃圾收集器

3. JDK17：密封类Sealed Class、模式匹配Instanceof、Switch 表达式、移除了 SecurityManager，废弃 Applet、ZGC 正式可用

4. JDK21：虚拟线程、Switch 模式匹配、序列集合、分代 ZGC

5. JDK22\~23：Stream 增强、Foreign Function \& Memory API、更多语法糖简化

6. JDK25：紧凑源文件、Scoped Values、紧凑对象头、基本类型模式匹配Instanceof int

<!-- question-id: q-cfbf0ff4ec86 -->
###### JDK、JRE、JVM之间有什么区别和联系

- JVM：Java虚拟机，是Java程序运行的核心，负责将字节码解释或编译为机器码，提供内存管理、垃圾回收等运行时环境。

- JRE：Java运行时环境，包含JVM和Java核心类库及其他支持文件，用于运行已编译的Java程序，但不能用于开发。

- JDK：Java开发工具包，包含JRE以及编译、调试、文档生成工具等

- 关系：JDK包含JRE，JRE包含JVM。JDK用于开发，JRE用于运行，JVM是运行的核心。

<!-- question-id: q-40829865f2d4 -->
###### Java的8种基本数据类型是什么？ 分别占用多少字节

byte\(1字节\) short\(2字节\) int\(4字节\) long\(8字节\) float\(4字节\) double\(8字节\) char\(2字节\) boolean\(通常视为1字节\)

关于boolean，理论上仅表示 `true` / `false` ，实际内存占用依赖JVM实现。通常作为局部变量在栈上占4字节（类似 `int` ），在堆中作为对象字段可能占1字节， `boolean[]` 数组中每个元素占1字节，因此，通常视为1字节。

<!-- question-id: q-8761629dc9ee -->
###### 什么是自动装箱与拆箱？ 其原理是什么

- 自动装箱：将基本数据类型自动转换为对应的包装类对象。比如说 `Integer i = 10` ，编译器会调用 `Integer.valueOf(10)`。

- 自动拆箱：将包装类对象自动转换为基本数据类型。比如 `int j = i;` 编译器会调用 `i.intValue()`。

- 原理：Java编译器的语法糖，在编译阶段根据上下文自动插入包装类的方法调用，运行时仍通过包装类的方法实现。

<!-- question-id: q-df61bed8810d -->
###### String、StringBuffer、StringBuilder的区别是什么

- String：不可变字符序列，每次修改都会生成新的String对象，线程安全。

- StringBuffer：可变字符序列，线程安全，效率较低。（方法用synchronized修饰）

- StringBuilder：可变字符序列，非线程安全，但效率最高。

- 字符串不经常变化用String，单线程字符串缓冲区用StringBuilder，多线程共享可变字符串用StringBuffer。

<!-- question-id: q-fb8a1f1baa8f -->
###### 面向对象的三大特性？ 

- 封装：将数据和方法结合在一起，并尽可能隐藏内部实现细节，对外提供公共访问方式，提高安全性和模块化。

- 继承：子类可以继承父类的属性和方法，并可以扩展或重写。Java只支持单继承，但可以通过接口实现多继承效果。

- 多态：同一操作作用于不同对象，可以有不同的解释和结果。包括编译时多态（方法重载）和运行时多态（方法重写）。

<!-- question-id: q-0335b77afda9 -->
###### 方法重载和重写有什么区别？

- 重载：在同一个类中，方法名相同，参数列表不同（类型、个数、顺序），与返回值、修饰符无关。

- 重写：子类对父类允许访问的方法重新实现，方法名、参数列表、返回值类型必须相同，访问修饰符不能更严格，不能抛出更宽泛的异常。

<!-- question-id: q-ed317120e9e1 -->
###### 接口和抽象类有什么区别？

- 定义：抽象类用 `abstract class` 定义，接口用 `interface` 定义。

- 继承与实现：类只能单继承抽象类，但可以多实现接口。

- 构造器：抽象类有构造器，接口没有。

- 变量：抽象类可以有实例变量、静态变量。接口中变量默认是 `public static final` 常量。

- 方法：抽象类可以有抽象方法和具体方法。接口中方法默认是 `public abstract`，Java8后可包含 `default` 和 `static` 方法，Java9后可包含私有方法。

<!-- question-id: q-85adc3beb84f -->
###### ==和equals\(\)有什么区别？

- ==：对于基本类型，比较的是数值是否相等；对于引用类型，比较的是内存地址。

- equals\(\)：默认实现也是用==比较地址，但通常子类会重写以实现内容比较，如String、Integer等包装类重写为比较值内容。

<!-- question-id: q-78e181468292 -->
###### 为什么重写 equals\(\) 也必须重写 hashCode\(\) 方法

为了保证对象在基于哈希的集合（HashMap、HashSet等）中能够正常工作。

- 这些集合在存储和查找对象时，首先使用hashCode\(\)确定对象的存储桶，然后在桶内使用equals\(\)进行精确比较。根据Java语言规范，如果两个对象通过equals\(\)比较相等，那么它们的hashCode\(\)必须相等。

- 如果只重写equals\(\)而不重写hashCode\(\)，就会导致两个逻辑相等的对象可能返回不同的哈希码，从而被分配到不同的桶中，造成集合中出现重复元素，或无法正确查找对象。

<!-- question-id: q-e2d4d7219bfa -->
###### 什么是Java反射？ 有什么应用场景

- 反射：动态获取信息以及动态调用对象方法的功能。在运行状态中，对于任意一个类，都能获取其所有属性和方法，对于任意一个对象，都能调用其任意方法和属性。

- 应用场景：框架开发（Spring IOC依赖注入）、动态代理、IDE自动补全、调试器。

<!-- question-id: q-8acd806c050d -->
###### Java的异常体系是如何分类的？ 常见的运行时异常

- 分类：Java异常体系以Throwable为顶层，分为Error和Exception。

    - Error：系统内部错误或资源耗尽，程序无法处理，比如 `StackOverflowError` 、 `OutOfMemoryError` 。

    - Exception：程序可处理的异常，分为受检异常和非受检异常

- 常见运行时异常： `NullPointerException` 、 `ArithmeticException` 、 `IndexOutOfBoundsException` 、 `ClassCastException` 、 `IllegalArgumentException` 等。

<!-- question-id: q-fc42074fbeba -->
###### 什么是深拷贝和浅拷贝？ 有什么区别？

- 浅拷贝：创建一个新对象，然后将原对象的所有字段值复制到新对象中。（对于基本类型是值本身，对于引用类型是内存地址）

- 深拷贝：创建一个新对象，同样复制所有字段，但对于引用类型字段，会递归地创建其对象副本，而不是复制地址。



---



#### Java集合

<!-- question-id: q-e81320a1987e -->
###### java里面，也就是说集合里面它有一个叫快速失败的概念。你了解过吗?

快速失败（Fail\-Fast）是 Java 集合框架的一种机制，当多个线程对集合进行并发修改时，或者单线程在遍历集合过程中修改了集合结构如添加、删除元素，会抛出ConcurrentModificationException。

其实现原理是集合内部维护一个 modCount 计数器，每次修改结构时递增。迭代器在遍历时会检查modCount 是否与预期值一致，不一致则抛出异常。

<!-- question-id: q-be77b5989c3c -->
###### Java集合框架的整体结构。说说Collection和Map两大体系的区别

Java集合框架主要分为两大体系：`Collection`和 `Map`。

- Collection 是存储单元素对象的根接口，其下包含三个主要子接口：

    - List：有序、可重复的集合，如 `ArrayList`、`LinkedList`。

    - Set：无序、不可重复的集合，如 `HashSet`、`TreeSet`。

    - Queue：用于模拟队列或双端队列，如 `LinkedList`、`PriorityQueue`。

- Map 是存储键值对（key\-value）的接口，每个键唯一映射到一个值，如 `HashMap`、`TreeMap`。

两大体系的区别：

- 存储内容不同： `Collection`存储单个元素， `Map`存储键值对。

- 访问方式不同： `Collection`通过元素本身操作， `Map`通过键来访问值。

<!-- question-id: q-5c8df8279c42 -->
###### ArrayList的扩容机制

ArrayList底层基于动态数组实现。当调用add方法且当前数组已满时，会触发扩容：

- 计算新容量：通常为旧容量的1\.5倍。（oldCapacity \+ \(oldCapacity \>\> 1\)）

- 创建新数组，并将原数组所有元素通过`Arrays.copyOf`复制到新数组。

- 将新数组赋值给内部数组引用，后续添加操作在新数组上进行。（默认初始容量为10，扩容操作代价较高，因此在已知元素数量时可预先指定容量）

<!-- question-id: q-e797f033f89a -->
###### ArrayList和LinkedList的区别是什么

- 底层数据结构：`ArrayList` 基于动态数组，`LinkedList` 基于双向链表。

- 随机访问：`ArrayList` 支持高效随机访问（O\(1\)），`LinkedList` 需要遍历（O\(n\)）。

- 插入和删除：`ArrayList` 在中间或头部插入/删除需要移动元素，效率低（O\(n\)），尾部插入（未满时）较快。`LinkedList` 只需修改节点指针，插入删除快（O\(1\)），但需要先定位到位置。

- 内存占用：`ArrayList` 可能预留容量空间，`LinkedList` 每个节点存储数据和前后指针，额外开销大。

- 适用场景：`ArrayList` 适合频繁读取、尾部操作。`LinkedList` 适合频繁插入删除、作为队列或栈使用。

<!-- question-id: q-88e42209c2fc -->
###### HashMap的底层数据结构是什么

`HashMap`底层在JDK 1\.8之前是数组\+链表，每个数组元素是一个链表的头节点。JDK 1\.8及之后引入红黑树优化。

- 当链表长度 ≥ 8 且数组长度 ≥ 64时，链表转为红黑树，以提高查询效率

- 当红黑树节点 ≤ 6时，退化为链表

<!-- question-id: q-8e633a04a785 -->
###### HashMap的扩容机制

当 `HashMap` 中元素个数超过阈值（容量 × 负载因子，默认0\.75）时，触发扩容：

- 新容量为原容量的2倍。创建新数组，并将原数组所有元素重新计算哈希位置后迁移到新数组。

- 迁移时，由于容量变为2倍，元素的新位置要么在原索引，要么在原索引\+旧容量，这一特性由哈希值高位参与运算决定。

<!-- question-id: q-5e69ac51d062 -->
###### ConcurrentHashMap的实现原理是什么？JDK 1\.7和JDK 1\.8的实现有何不同

- JDK 1\.7：实现原理采用分段锁（Segment）机制。将数据分成多个Segment（默认16个），每个Segment继承`ReentrantLock`，独立加锁。不同Segment可并发访问，提高了并发度。每个Segment内部维护一个`HashEntry`数组，类似于`HashMap`的数组\+链表结构。

- JDK 1\.8：实现原理废弃分段锁，改用CAS \+ synchronized。底层数据结构与`HashMap`一致（数组\+链表\+红黑树）。锁粒度细化到每个数组元素（桶），使用`synchronized`对链表头节点或树根节点加锁，同时利用CAS进行无锁操作。并发度更高，且引入红黑树优化长链表查询性能。

<!-- question-id: q-c2f9bb322382 -->
###### ConcurrentHashMap为什么是线程安全的？HashMap为什么是线程不安全的？

**HashMap 线程不安全的原因**

- 多线程 `put` 导致数据覆盖：当多个线程同时执行`put`操作，且计算出的数组索引相同时，后写入的线程可能覆盖前一个线程的结果，造成数据丢失。

- 扩容时形成环形链表（JDK 1\.7）：在 JDK 1\.7 中，扩容采用头插法，多线程同时触发扩容可能导致链表形成环，后续`get`操作陷入死循环。

- `put`与`get`并发可见性问题：一个线程`put`的元素可能对另一个线程不可见，因为没有内存可见性保证。

**ConcurrentHashMap 线程安全的原因**

- JDK 1\.7 实现（分段锁）：内部使用`Segment` 数组，每个`Segment` 继承`ReentrantLock`，将整个哈希表分成多个段。不同线程操作不同段时互不干扰，同一段内才需要竞争锁，从而提高了并发度。

- JDK 1\.8 实现（CAS \+ synchronized）：

    - 读操作无锁：使用 `volatile` 修饰`Node`的`value`和`next`，保证可见性，读操作无需加锁。

    - 写操作采用 CAS 和 synchronized：插入元素时，先通过 CAS 尝试将节点放入空桶,若桶非空，则对桶的首节点使用 `synchronized` 加锁，然后执行插入或更新。锁粒度缩小到单个桶，进一步减少竞争。

<!-- question-id: q-15882f258b6b -->
###### 线程安全的集合有哪些？

- `ConcurrentHashMap`：高效线程安全的哈希表。

- `CopyOnWriteArrayList`和`CopyOnWriteArraySet`：适用于读多写少的场景，写时复制。

- `ConcurrentLinkedQueue`和`ConcurrentLinkedDeque`：基于 CAS 的无锁非阻塞队列。

- `BlockingQueue`接口的实现类`ArrayBlockingQueue`、`LinkedBlockingQueue`、`PriorityBlockingQueue`等，支持阻塞操作。

- `ConcurrentSkipListMap`和`ConcurrentSkipListSet`：基于跳表的并发有序集合。

<!-- question-id: q-d903461766a5 -->
###### 什么是BIO、NIO、AIO？它们之间有什么区别？

1. BIO（Blocking I/O）：同步阻塞I/O模型。服务器通常采用“一个连接一个线程”的方式，即每当有一个客户端连接请求，服务器就会创建一个独立的线程去处理该连接的所有I/O操作。

2. NIO（Non\-blocking I/O）：同步非阻塞I/O模型。基于多路复用器（Selector）实现，服务器可以用一个线程管理多个连接。线程通过Selector不断轮询注册在其上的通道，只有当某个通道的I/O操作真正就绪时，才会启动读写操作，否则可以处理其他就绪通道。

3. AIO（Asynchronous I/O）：异步非阻塞I/O模型。它更进一步，由操作系统在I/O操作完成后主动通知应用程序。应用程序发起读写操作后立即返回，无需等待，当内核完成数据拷贝或操作结束后，会通过回调函数或Future机制通知用户线程进行后续处理。

**简记：**

- BIO是同步阻塞，线程在读写期间被阻塞，一个连接一个线程。

- NIO是同步非阻塞，通过多路复用器selector管理多个连接，线程在轮询时可能短暂阻塞，但读写仍需主动完成，适合高并发场景。

- AIO是异步非阻塞，由操作系统完成I/O后通知应用，线程无需等待，真正解放线程资源。



---



#### JVM

<!-- question-id: q-8b23a803551f -->
###### JVM的内存区域划分。哪些区域是线程私有的，哪些是线程共享

- 程序计数器（线程私有）：记录当前线程执行的字节码指令地址。

- Java 虚拟机栈（线程私有）：存储栈帧，包含局部变量表、操作数栈等。

- 本地方法栈（线程私有）：为Native方法服务，与虚拟机栈类似。

- Java 堆（线程共享）：最大内存区域，存放几乎所有对象实例与数组，是垃圾回收的主要区域。

- 方法区（线程共享）：存储已加载类信息、常量、静态变量等。JDK 8后元空间取代永久代，使用本地内存。

- 运行时常量池（方法区一部分）：存放编译期常量。

<!-- question-id: q-5bdcd1f83195 -->
###### 内存溢出（OOM\)可能发生在哪些区域呢？

- **堆内存溢出**：`OutOfMemoryError: Java heap space`。对象占用超过堆容量，或者没有足够空间完成当前分配。可能是内存泄漏，也可能是大对象、突发流量、一次性加载太多数据。

- **GC 开销过大**：`OutOfMemoryError: GC overhead limit exceeded`。在启用相应开销限制的收集器中，JVM 发现长时间忙于 GC，却只能回收很少的内存，就可能抛出这个错误。关闭检查通常解决不了对象占用过高的问题。

- **元空间溢出**：`OutOfMemoryError: Metaspace`。常见原因是动态生成的类过多、类加载器泄漏，或者元空间上限设置过小。

- **直接内存溢出**：`OutOfMemoryError: Direct buffer memory`。通过 `ByteBuffer.allocateDirect()` 等方式申请直接内存时，超过容量限制或无法完成分配，可能出现这个错误。

- **无法创建本地线程**：`OutOfMemoryError: unable to create new native thread`。线程过多导致本地内存不足，或者达到操作系统、容器的线程数限制。此时即使 Java 堆还有空闲，也可能失败。

<!-- question-id: q-23d653c34ed6 -->
###### Java对象的创建过程。在JVM层面，一个对象是如何从无到有被分配内存的

- 类加载检查：确保类已加载、解析、初始化。

- 分配内存：在堆中划分内存，方式有指针碰撞（堆规整）或空闲列表（堆不规整）。

- 初始化零值：将对象内存不含对象头置零。

- 设置对象头：记录哈希码、GC分代年龄、锁状态、类型指针等。

- 执行 `<init>` 方法：按构造函数初始化。

<!-- question-id: q-0a2dd63f12a8 -->
###### 怎么去识别垃圾呢？具体有哪些垃圾识别算法？

- JVM通过可达性分析算法来识别垃圾。以一组称为GC Roots的对象为起始点，从这些根向下搜索，所经过的路径称为引用链。如果一个对象到GC Roots没有任何引用链相连（即不可达），则该对象被判定为可回收。

- 常见的GC Roots包括：虚拟机栈中引用的对象、方法区中静态属性引用的对象、方法区中常量引用的对象、本地方法栈中JNI引用的对象等。

- 除了可达性分析，还有引用计数法，早期Python等使用，但Java未采用，因为它无法解决循环引用问题。

<!-- question-id: q-1f39def0b6aa -->
###### 哪些对象可以作为GC Roots?

1. 虚拟机栈中引用的对象（局部变量表）。

2. 方法区中类的静态属性引用的对象。

3. 方法区中常量引用的对象（字符串常量池）。

4. 本地方法栈中JNI引用的对象。

5. Java虚拟机内部的引用（系统类加载器、基本数据类型Class对象）。

6. 所有被同步锁持有的对象。

7. 反映JVM内部情况的JMXBean、JVMTI回调等。

<!-- question-id: q-31ff22e1bc95 -->
###### 系统频繁发生Full GC，你会从哪些方面去排查

1. 使用监控工具（jstat、GC日志）分析频率和耗时。

2. 检查堆内存配置：年轻代、老年代比例是否合适，是否过小。

3. 排查内存泄漏：堆转储分析，查看老年代大对象。

4. 检查元空间是否不足。

5. 检查GC收集器参数，比如说CMS的 `CMSInitiatingOccupancyFraction` 是否过低。

<!-- question-id: q-b0f0f13ae1ac -->
###### 什么是Java内存模型（JMM）？它的主要目的是什么？

JMM是一种规范，定义了多线程程序中共享变量的访问规则，屏蔽硬件差异，保证并发场景下的内存一致性。

主要目的：

- 确保可见性：线程对共享变量的修改能及时被其他线程看到。

- 确保原子性：对变量的读写操作不可分割。

- 确保有序性：通过happens\-before规则禁止特定指令重排序，避免并发问题。

<!-- question-id: q-5ebd7be77c98 -->
###### Java的类加载机制？什么是双亲委派模型?怎么打破双亲委派机制？

类加载机制：将Class文件加载到内存，经过验证、准备、解析、初始化等步骤，最终形成可用的Java类型。

双亲委派模型：类加载器收到加载请求时，先委派给父加载器处理，只有父加载器无法完成时才自己加载。

打破双亲委派机制：重写`loadClass()`方法

<!-- question-id: q-0660e065d49f -->
###### 双亲委派机制有什么好处呢？

1. 保证类的唯一性和安全性：让子加载器尽量复用父加载器已经定义的类，减少重复加载，确保核心类（如 JDK 的 `String`、`Integer`）不会被篡改。

2. 实现类的复用：核心类只需要被顶层加载器加载一次，所有子加载器都能共享这个类，减少内存消耗。

<!-- question-id: q-d60f30abc744 -->
###### 常见的垃圾回收算法

- 标记\-清除：标记存活对象，清除未被标记的对象

- 标记\-复制：将内存分为两块，只使用一块，存活对象复制到另一块后清空原块，适用于年轻代。

- 标记\-整理：存活对象向一端移动，然后清理边界外内存，避免碎片，适用于老年代。

- 分代收集：结合上述算法，不同代使用不同算法。根据对象存活周期的不同将内存分为几块。

<!-- question-id: q-bc5bc16c1de0 -->
###### 为什么要分代收集？年轻代和老年代分别采用什么回收算法？

- 为什么：可以根据各个年代的特点选择合适的垃圾收集算法

- 年轻代：采用标记\-复制算法。因为对象存活率低，只需复制少量存活对象，效率高且避免碎片。

- 老年代：采用标记\-清除或标记\-整理算法。对象存活率高，无额外空间担保，使用标记\-清除或标记\-整理来回收，标记\-整理可避免碎片。

<!-- question-id: q-6aa1690fa0df -->
###### 常见的垃圾收集器有哪些？请简要介绍一下CMS和G1收集器的特点及区别

常见收集器：Parallel 更关注吞吐量，G1 追求吞吐量与停顿的平衡，ZGC、Shenandoah 更关注低停顿。

1. CMS：基于标记\-清除，并发低停顿，但产生碎片，并发阶段占用CPU，可能出现并发模式失败。

2. G1：分区管理，整体标记\-整理，局部复制，可预测停顿时间，减少碎片，适合大堆。

3. 区别：CMS追求低停顿但碎片多，G1可预测停顿，分区管理，更适用于大内存服务器。

<!-- question-id: q-b656ae5855ab -->
###### 什么是Minor GC、Major GC 和 Full GC？它们分别发生在什么时候

- Minor GC：年轻代回收，当Eden区满时触发。

- Major GC：老年代回收，常与Full GC混用。

- Full GC：整个堆（包括年轻代、老年代、元空间）回收，触发条件：老年代空间不足、元空间不足、分配大对象失败等。

<!-- question-id: q-898c884484e0 -->
###### JVM 调优的参数都有哪些

1. 堆设置：`-Xms`、`-Xmx`、`-Xmn`、`-XX:NewRatio`、`-XX:SurvivorRatio`。

2. 收集器选择：`-XX:+UseParallelGC`、`-XX:+UseConcMarkSweepGC`、`-XX:+UseG1GC`。

3. GC日志：`-XX:+PrintGCDetails`、`-XX:+PrintGCDateStamps`。

4. 内存溢出处理：`-XX:+HeapDumpOnOutOfMemoryError`、`-XX:HeapDumpPath`。

5. 性能调优：`-XX:MaxGCPauseMillis`、`-XX:ParallelGCThreads`、`-XX:+DisableExplicitGC`。

6. 元空间：`-XX:MetaspaceSize`、`-XX:MaxMetaspaceSize`。



---



#### JUC

<!-- question-id: q-a11e3fbe6e07 -->
###### 什么是JUC？它包含了哪些主要的组件

JUC是 `java.util.concurrent` 的简称，是Java提供的用于并发编程的工具包。包含了大量用于多线程编程的实用组件，主要分为以下几类：

1. 原子类：`AtomicInteger`、`AtomicLong`、`AtomicReference`，提供线程安全的原子操作。

2. 锁框架：`ReentrantLock`、`ReentrantReadWriteLock`、`StampedLock`，提供比 `synchronized` 更灵活的锁机制。

3. 并发集合：`ConcurrentHashMap`、`CopyOnWriteArrayList`、`BlockingQueue`，支持高并发环境下的线程安全操作。

4. 线程池：`ThreadPoolExecutor`、`ScheduledThreadPoolExecutor`，以及 `Executors` 工具类，用于管理和复用线程。

5. 同步工具类：`Semaphore`、`CountDownLatch`、`CyclicBarrier`、`Phaser`、`Exchanger`，用于协调多个线程之间的协作。

6. Fork/Join框架：用于并行计算，将任务拆分成子任务并行执行，最后合并结果。

<!-- question-id: q-aba9e632ffb6 -->
###### 创建线程有哪几种方式？

1. 继承Thread类：重写 `run()` 方法，创建子类对象并调用 `start()`。

2. 实现Runnable接口：实现 `run()` 方法，创建Thread对象时传入Runnable实例。

3. 实现Callable接口：实现 `call()` 方法，通过FutureTask包装后提交给Thread或线程池。

4. 使用线程池：通过 `ExecutorService.submit()` 提交任务，由线程池创建线程。

5. 使用匿名内部类或Lambda，本质是Runnable或Callable。

<!-- question-id: q-29a8bfc151f3 -->
###### volatile关键字有什么用？

volatile是Java提供的轻量级同步机制，具有两个主要特性：

- 保证可见性：当一个线程修改了volatile变量的值，新值会立即被写回主内存，其他线程读取该变量时能看到最新值（通过缓存一致性协议）。

- 禁止指令重排序：volatile变量的读写操作前后会插入内存屏障，防止编译器或处理器对指令进行重排序，从而保证有序性。

但volatile不保证原子性，例如i\+\+操作仍需同步。

<!-- question-id: q-7b48815848a0 -->
###### 乐观锁和悲观锁有什么区别？各自的适用场景是什么

- 悲观锁：假设并发冲突（线程安全问题）严重，每次操作数据前都加锁，阻塞其他线程。例如 `synchronized`、`ReentrantLock`。适用场景：写多读少、并发冲突高的场景，如数据库行锁。

- 乐观锁：假设并发冲突较少，不加锁，但在更新时检查版本是否被修改（CAS、版本号机制）。适用场景：读多写少、冲突概率低的场景，如计数器、库存扣减。

<!-- question-id: q-b35c3cae9dde -->
###### 乐观锁一般怎么实现的？CAS是什么以及CAS的实现原理？

- 乐观锁通常通过CAS（Compare and Swap，比较并交换）实现。CAS是一种原子操作，包含三个操作数：内存位置V、预期原值A和新值B。执行时，只有当V的值等于A时，才将V更新为B，否则不更新。整个过程是原子的。

- CAS的实现依赖于硬件指令，由CPU保证原子性。在Java中，`Unsafe` 类提供了CAS操作，许多并发工具基于它实现。

<!-- question-id: q-5a97d61c41cb -->
###### ReentrantLock和synchronized有什么区别？

`synchronized` 和 `ReentrantLock` 都是可重入的互斥锁，都能用于保护共享数据，区别主要有以下几个：

- **使用方式**：`synchronized` 是关键字，进入同步范围时自动加锁，退出时自动释放；`ReentrantLock` 是类，需要显式加锁，并在 `finally` 中解锁。

- **公平性**：`synchronized` 不保证公平；`ReentrantLock` 默认非公平，也可以配置为公平锁。

- **中断和超时**：等待进入 `synchronized` 不能通过中断直接取消；`ReentrantLock` 的 `lockInterruptibly()` 支持中断，`tryLock(timeout, unit)` 支持超时。注意，普通的 `lock()` 不会因为中断就放弃等待。

- **等待通知**：`synchronized` 配合对象的 `wait()`、`notify()`、`notifyAll()`；`ReentrantLock` 可以创建多个 `Condition`，分别管理不同的等待条件。

- **底层实现**：`synchronized` 由 JVM 实现，涉及对象的锁状态和监视器；`ReentrantLock` 基于 AQS，利用同步状态、CAS 和等待队列协调线程。

<!-- question-id: q-f96e522353a3 -->
###### ReentrantLock和synchronized可重入吗？

都可重入。

可重入锁是指同一个线程在获取了锁之后，可以再次重复获取该锁而不会造成死锁或其他问题。当一个线程持有锁时，如果再次尝试获取该锁，就会成功获取而不会被阻塞。

<!-- question-id: q-6bc258a681d5 -->
###### 什么是AQS？它的核心原理是什么？

AQS（AbstractQueuedSynchronizer）是Java并发包的基础框架，用于构建锁和同步器。（`ReentrantLock`、`Semaphore`）。其核心原理是：

1. 状态管理。通过一个 `volatile int state` 变量表示同步状态，子类通过 `getState`、`setState`、`compareAndSetState` 方法修改状态。

2. CLH队列。AQS内部维护一个FIFO的双向队列，用于存放等待获取锁的线程。当线程获取同步状态失败时，会被封装成Node节点加入队列尾部，并通过自旋和阻塞实现等待。

3. 独占/共享模式。AQS支持独占模式和共享模式，子类通过实现 `tryAcquire`、`tryRelease` 等方法定义资源获取和释放的逻辑。

4. 条件队列。AQS内部还支持 `Condition` 对象，每个Condition对应一个条件队列，用于实现线程的等待/通知机制。

<!-- question-id: q-0969443dbf02 -->
###### ReentrantLock的实现原理是什么？它是如何实现可重入的？

ReentrantLock 基于AQS实现，其原理如下：

- 同步器：内部有一个 `Sync` 类继承AQS，并实现了公平锁 `FairSync` 和非公平锁 `NonfairSync` 两个子类。

- 加锁：调用 `lock()` 时，会委托给 `Sync` 的 `lock()` 方法。非公平锁直接尝试CAS获取锁，若成功则设置当前线程为独占线程；若失败则进入AQS的 `acquire()` 流程，再次尝试获取，失败则加入等待队列。

- 可重入实现： `ReentrantLock` 通过AQS的 `state` 变量记录重入次数。当线程第一次获取锁时， `state` 设为1；如果同一线程再次获取锁， `state` 递增；释放锁时， `state` 递减，直到 `state=0` 才真正释放锁。同时， `ReentrantLock` 内部记录了当前持有锁的线程，用于判断是否当前线程重入。

<!-- question-id: q-d6d948326e57 -->
###### ReentrantLock的公平锁和非公平锁有什么区别？底层怎么实现的

- 区别：

    - 公平锁：多个线程按照请求锁的顺序（FIFO）获取锁，先到先得，不会产生线程饥饿。

    - 非公平锁：允许插队，即新请求的线程可能比等待队列中的线程先获取锁，减少了线程唤醒的开销，但可能导致某些线程长时间获取不到锁（饥饿）。

- 底层实现：

两者都继承AQS，主要区别在于`tryAcquire`方法。

- 非公平锁：在 `lock()` 时直接尝试CAS获取锁，若成功则设置当前线程；若失败则调用`acquire(1)`，在`tryAcquire`中再次尝试CAS获取，不考虑队列等待情况。

- 公平锁：在`tryAcquire`中，首先检查AQS队列中是否有等待的前驱节点，若有则返回false，进入等待队列；若无才会尝试CAS获取锁。

<!-- question-id: q-141a0aede292 -->
###### 线程池的底层实现？线程池的核心参数有哪些？任务的执行流程是怎样的？

线程池的底层实现基于 `ThreadPoolExecutor` 类。

核心参数：

- corePoolSize：核心线程数，即使空闲也保留的线程数。

- maximumPoolSize：最大线程数，线程池允许的最大线程数。

- keepAliveTime：非核心线程空闲存活时间（超过核心线程数的线程）。

- unit：存活时间单位。

- workQueue：任务队列，用于存放等待执行的任务。

- threadFactory：线程工厂，用于创建新线程。

- handler：拒绝策略，当任务无法提交时执行。

提交一个任务时，处理流程如下：

1. 当前线程数小于核心线程数，创建一个工作线程来执行新任务。

2. 当前线程数达到核心线程数，尝试把新任务放进任务队列，等待工作线程领取。

3. 任务无法入队，尝试继续创建工作线程，但线程总数不能超过最大线程数。

4. 任务无法入队，也无法继续创建线程，执行拒绝策略。

5. 当线程空闲时间超过 keepAliveTime，且当前线程数大于核心线程数，多余线程会被终止。

<!-- question-id: q-f39300f8d2a9 -->
###### 线程池有哪些类型？了解哪些线程池？

Java通过 `Executors` 工厂类提供了几种预定义的线程池：

1. `FixedThreadPool`：固定大小线程池，核心线程数 = 最大线程数，使用无界队列 `LinkedBlockingQueue`。

2. `CachedThreadPool`：缓存线程池，核心线程数为0，最大线程数很大，使用同步队列`SynchronousQueue`，线程空闲60秒后回收。

3. `SingleThreadExecutor`：单线程线程池，使用无界队列，保证任务顺序执行。

4. `ScheduledThreadPool`：进程调度线程池，支持定时及周期性任务执行的线程池，使用延迟队列`DelayedWorkQueue`。

5. `WorkStealingPool`：工作窃取线程池，基于ForkJoinPool。

<!-- question-id: q-18ba373e7e21 -->
###### 为什么不建议使用Executors创建线程池？生产中如何正确创建？

`Executors` 提供的工厂方法存在以下问题：

- `FixedThreadPool` 和 `SingleThreadPool`：允许的任务队列长度为 `Integer.MAX_VALUE`，可能导致堆积大量请求，最终内存溢出。

- `CachedThreadPool` 和 `ScheduledThreadPool`：允许的线程数最大为 `Integer.MAX_VALUE`，可能创建大量线程，导致资源耗尽或OOM。

生产中应通过 `ThreadPoolExecutor` 直接创建，明确指定核心线程数、最大线程数、队列容量和拒绝策略。

<!-- question-id: q-6d5dcde71fd1 -->
###### 使用Threadlocal有什么注意事项？在项目里具体是怎么做的防止OOM（内存溢出）？

ThreadLocal使用不当可能导致内存泄漏，主要注意事项：

- 务必在不再使用时调用 `remove()` 方法，尤其在使用了线程池的环境中，因为线程复用会导致ThreadLocal中的值一直存在，无法被回收。

- 避免使用ThreadLocal存储大对象，因为其生命周期与线程绑定，可能长期占用内存。

- ThreadLocal变量应定义为 `static`，避免创建多个实例。

在项目中防止OOM的做法：

- 在使用ThreadLocal的代码块结束后，主动调用`ThreadLocal.remove()`清理。

- 使用try\-finally块确保移除操作一定执行。

- 对于Web应用，在拦截器或过滤器中统一处理，在请求结束后清除当前线程的ThreadLocal。

<!-- question-id: q-653e106924a7 -->
###### Java不是有垃圾回收机制吗，为什么ThreadLocal这里没有回收掉？

- 因为ThreadLocal的内存泄漏主要发生在ThreadLocalMap中的Entry对value的强引用。每个Thread内部维护一个ThreadLocalMap，其中Entry的key是ThreadLocal实例（弱引用），value是用户设置的值（强引用）。

- 当ThreadLocal实例被回收后（线程池中的线程长期存活），其对应的Entry的key变为null，但value仍然被Entry强引用，而Entry又被当前线程强引用，导致value无法被回收，除非线程结束或手动remove。

- 垃圾回收器无法回收这些value，因为它们仍有强引用链可达（线程 \-\> ThreadLocalMap \-\> Entry \-\> value）。

<!-- question-id: q-4cc17556106f -->
###### Java并发容器ConcurrentHashMap和CopyonWriteArrayList了解吗？

1. ConcurrentHashMap：线程安全的哈希表，JDK1\.7采用分段锁，JDK1\.8采用CAS\+synchronized对每个桶加锁，支持高并发。读操作无锁，写操作锁住单个桶，允许多线程同时读和写不同桶。还提供了弱一致性迭代器。

2. CopyOnWriteArrayList：线程安全的ArrayList，采用“写时复制”策略。所有修改操作（add、set）都会复制底层数组，修改后替换原数组，因此读操作无锁且并发读安全。适合读多写少的场景。

<!-- question-id: q-2c8a2859a96c -->
###### CopyOnWriteArrayList是如何保证线程安全的？适用于什么场景？

`CopyOnWriteArrayList` 是线程安全的 `ArrayList` 变体。当执行修改操作时，不直接修改原数组，而是先复制一个新数组，在新数组上进行修改，然后将内部数组引用指向新数组。读操作不加锁，直接读取原数组。

- 线程安全：写操作通过 `ReentrantLock` 加锁，保证同一时刻只有一个线程进行写操作，复制过程对读线程无影响。

- 适用场景：适合读多写少的并发场景，比如说缓存、监听器列表。因为写操作涉及数组复制，开销较大，不适合频繁写。同时，数据最终一致性，读操作是可能读取到旧数据的。



---



#### Spring

<!-- question-id: q-aeab20b1ba58 -->
###### 什么是IoC和AOP？AOP的实现原理是什么

1. IoC（控制反转）：将传统上由程序代码直接操控的对象创建和依赖关系的控制权转移给容器，由容器负责对象的生命周期和依赖关系管理。实现方式是依赖注入DI。

2. AOP（面向切面编程）：将横切关注点（日志、事务、安全等）与业务逻辑分离，提高模块化。允许开发者在不修改源代码的情况下，对业务方法进行增强。

3. AOP的实现原理：Spring AOP基于动态代理实现。

    1. 当目标类实现了至少一个接口时，Spring使用JDK动态代理，生成一个实现相同接口的代理类，通过 `InvocationHandler` 拦截方法调用，并织入增强逻辑。

    2. 当目标类没有实现接口时，Spring使用CGLIB代理，生成目标类的子类作为代理，通过重写方法实现增强。CGLIB在运行时动态生成字节码，效率较高，但无法对 `final` 方法进行代理。

<!-- question-id: q-1c2d4fc0c746 -->
###### @Transactional注解在什么情况下会失效

1. 非public方法：Spring默认只对public方法进行事务增强，如果注解在protected、private或包可见的方法上，事务不会生效。

2. 同类内部调用：如果一个类的内部方法调用另一个带有@Transactional的方法，且调用是通过 `this` 直接调用（而非代理对象），则事务不会生效，因为调用没有经过Spring的代理对象。

3. 异常被捕获后未抛出：事务默认仅在方法抛出未捕获的运行时异常或错误（Error）时回滚。如果方法内捕获了异常并自行处理（未抛出），事务不会回滚。

4. 数据库引擎不支持事务：如MySQL的MyISAM引擎不支持事务，即使注解正确，也无法回滚。

5. 方法被final修饰：若使用CGLIB代理，final方法无法被重写，故无法增强

6. 多线程调用：如果在一个新线程中调用事务方法，由于事务是与线程绑定的（通过ThreadLocal），新线程中的操作不会参与原线程的事务。

<!-- question-id: q-ebad2d70f9c9 -->
###### Spring事务的隔离级别？

Spring事务隔离级别对应数据库的隔离级别，通过`@Transactional`的`isolation`属性设置，包括：

1. `DEFAULT`：使用底层数据库默认隔离级别。

2. `READ_UNCOMMITTED`：读未提交，允许脏读。

3. `READ_COMMITTED`：读已提交，防止脏读。

4. `REPEATABLE_READ`：可重复读，防止脏读和不可重复读。

5. `SERIALIZABLE`：串行化，最高级别，防止脏读、不可重复读和幻读。

<!-- question-id: q-2185e362567e -->
###### Spring事务失效场景

1. Spring事务基于代理，非public方法无法被代理（除非使用AspectJ）。（方法不是public）

2. 同一个类中方法直接调用，不经过代理，事务不生效。（自调用）

3. 事务方法中捕获异常未抛出，导致无法回滚。（异常被捕获）

4. 默认只回滚 `RuntimeException` 和 `Error` ，检查型异常不回滚，需指定 `rollbackFor`。（异常类型不匹配）

5. MySQL的MyISAM引擎不支持事务。

6. 事务管理器配置错误：未正确配置事务管理器或数据源。

<!-- question-id: q-49dfb8709dcb -->
###### Springboot里面各种像bean一样的东西，这个bean是不是单例？单例的话会不会有线程安全问题？怎么解决

Spring Boot 中默认的 Bean 作用域是单例（Singleton），即容器中只创建一个实例。单例 Bean 如果包含可变状态（成员变量），则存在线程安全问题，因为多个线程可能同时访问和修改该状态。解决线程安全问题的方法：

- 将 Bean 设计为无状态，即不包含可变成员变量，只提供服务方法（方法内部变量是线程安全的）。

- 使用 ThreadLocal 保存线程局部变量，避免共享。

- 通过同步机制（synchronized）或使用并发工具类（AtomicInteger）保护共享状态。

- 将作用域改为原型（Prototype），每次请求创建新实例，但会增加开销。

- 使用不可变对象。

<!-- question-id: q-c7cc094da300 -->
###### 实现一个spring boot的那个start该如何做

实现一个 Spring Boot Starter 的步骤：

1. 创建两个模块：一个自动配置模块（auto\-configure）和一个 Starter 模块（通常包含对自动配置的依赖）。实际中常合并为一个。

2. 在自动配置模块中，编写配置类，使用 `@Configuration` 和 `@ConditionalOnClass`、`@ConditionalOnMissingBean` 等条件注解，定义需要创建的 Bean。

3. 在 `META-INF/spring.factories` 文件中配置 `org.springframework.boot.autoconfigure.EnableAutoConfiguration` 指向自动配置类，以便 Spring Boot 启动时加载。

4. 提供自定义属性类，使用 `@ConfigurationProperties` 绑定配置文件中的前缀。

5. 在 Starter 模块中引入自动配置模块，并添加必要的依赖。

6. 最终将 Starter 打包成 jar，其他项目引入依赖即可使用。

<!-- question-id: q-b5465ab476e6 -->
###### Spring Boot的自动配置原理是什么？是如何按需加载的

原理：通过 `@EnableAutoConfiguration` 导入 `AutoConfigurationImportSelector`，读取声明的自动配置类，然后根据条件注解判断是否生效。

按需加载：条件注解确保仅在特定条件满足时才加载自动配置，避免不必要的Bean创建。（特定条件如类路径存在指定类、用户未自定义相关Bean）

<!-- question-id: q-a4681ec775a9 -->
###### Bean的生命周期（这个很重要）

Spring Bean的生命周期是指Bean从创建到销毁的整个过程分为以下以下几个阶段：

1. 实例化：Spring容器通过反射（调用构造器）创建Bean实例。

2. 属性赋值：对Bean的成员变量进行填充，包括依赖注入。

3. Aware接口回调：如果Bean实现了特定的Aware接口，Spring会调用相应方法注入容器相关对象。

4. BeanPostProcessor前置处理：在Bean初始化前，调用所有 `BeanPostProcessor` 的 `postProcessBeforeInitialization` 方法，可以对Bean进行自定义加工。

5. 初始化：

    - 如果Bean实现了 `InitializingBean` 接口，调用其 `afterPropertiesSet()` 方法。

    - 如果配置了自定义的 `init-method` （比如XML中指定或 `@Bean(initMethod = "...")` ），则调用该方法。

6. BeanPostProcessor后置处理：调用所有 `BeanPostProcessor` 的 `postProcessAfterInitialization` 方法，此时Bean已经准备就绪，可以对外提供服务。

7. 使用中：Bean驻留在容器中，被应用程序使用。

8. 销毁：当容器关闭时，如果Bean实现了 `DisposableBean` 接口，调用其 `destroy()` 方法；如果配置了自定义的 `destroy-method` ，则调用该方法。

<!-- question-id: q-ce01ade45836 -->
###### Spring怎么解决循环依赖问题的，什么是三级缓存？

解决方式：通过三级缓存解决单例Bean的setter注入循环依赖

三级缓存：

- 一级缓存：存放完全初始化好的单例Bean。

- 二级缓存：存放早期暴露的Bean（未完成属性填充和初始化）。

- 三级缓存：存放 `ObjectFactory` ，用于生成早期Bean的代理等。

- 过程：A实例化后将工厂放入三级缓存；发现依赖B，创建B；B需要A，从三级缓存获取工厂生成早期A（放入二级缓存），注入给B；B完成初始化后放入一级缓存；A继续完成属性填充和初始化，最终放入一级缓存。

<!-- question-id: q-2639a47e7161 -->
###### @Autowired和@Resource注解有什么区别

- @Autowired：Spring注解，默认按类型注入。

- @Resource：默认按名称注入，找不到名称则按类型。



---



## 后端基础

#### MySQL

<!-- question-id: q-c6295a40005f -->
###### MySQL中如何定位慢查询？如果SQL语句执行很慢，如何分析和优化？

1. 定位慢查询：

    1. 开启慢查询日志。设置 `long_query_time` 阈值（2秒），分析慢查询日志。

    2. 使用 `EXPLAIN` 分析执行计划。观察是否使用索引、扫描行数、Extra信息。

    3. 通过 `SHOW PROFILE` 或 `performance_schema` 查看SQL各阶段耗时。

2. 分析和优化：

    1. 检查是否命中索引， `EXPLAIN` 中 `key` 为NULL表示未用索引，需添加或优化索引。

    2. 避免全表扫描，为WHERE、JOIN、ORDER BY字段创建合适索引。

    3. 优化SQL写法，避免 `SELECT *` 、函数操作索引列、隐式类型转换等。

    4. 分析数据量，若数据量过大，考虑分库分表或归档历史数据。

    5. 检查锁竞争，使用 `SHOW PROCESSLIST` 查看是否有锁等待。



先确认慢在哪里

- 通过慢查询日志、Performance Schema 等找到具体 SQL，记录实际参数、执行频率、耗时和扫描行数，避免只拿一个命中数据很少的参数做判断。

- 看是不是锁等待，结合进程状态、事务和锁等待信息排查。SQL 等锁很久，和执行计划扫描很慢，需要不同的处理方式。

- 检查数据库当时的 CPU、I/O、连接数和 Buffer Pool 等情况，判断是个别 SQL 问题，还是整体资源已经接近瓶颈。

再分析执行计划和 SQL

- 用 EXPLAIN 看扫描方式、实际索引、估算行数、回表、排序和临时表；必要时用 EXPLAIN ANALYZE 对比实际行数与估算，注意它会真正执行查询。

- 根据 WHERE、JOIN、ORDER BY 设计合适的联合索引，尽量使用覆盖索引，避免对普通索引列做不必要的函数和类型转换。

- 只查询需要的列和行，避免无条件 SELECT \*。联表查询要关注过滤后的数据量、连接算法和关联字段索引，不能只根据表的总行数背「小表驱动大表」。

- 深分页可以使用游标分页，或者先通过覆盖索引定位少量主键再回表；大批量更新可以在业务允许时分批处理。

- 如果估算明显失真，可以评估更新统计信息，再对比计划和实际效果。

最后考虑结构和架构

- 高频热点查询可以考虑缓存或汇总表，同时设计缓存一致性、失效和热点保护方案。

- 大字段和低频字段可以结合访问模式拆分，减少常用查询读取的数据量。

- 明确单机资源或写入吞吐已经成为瓶颈后，再评估读写分离、数据归档、分库分表。

<!-- question-id: q-8418da229f68 -->
###### 排查慢SQL用explain分析执行计划，主要关注哪些字段？

使用 `EXPLAIN` 分析执行计划时，主要关注以下字段：

- type：表示连接类型，从好到差依次为 `system`、`const`、`eq_ref`、`ref`、`range`、`index`、`ALL`。至少应达到 `range` 级别，避免 `ALL` 全表扫描。

- key：实际使用的索引。如果为 `NULL`，则没有使用索引。

- key\_len：使用的索引键长度，越短越好，可判断是否使用了联合索引的全部或部分。

- rows：预估需要扫描的行数，越小越好。

- Extra：额外信息，常见的有 `Using index`（覆盖索引）、`Using where`（使用 where 条件过滤）、`Using index condition`（索引下推）

<!-- question-id: q-2b8591ef878d -->
###### MySQL有哪些索引

MySQL可以按照四个角度来分类索引。

- 按「数据结构」分类：B\+tree索引、Hash索引、Full\-text索引。

- 按「物理存储」分类：聚簇索引（主键索引）、二级索引（辅助索引）。

- 按「字段特性」分类：主键索引、唯一索引、普通索引、前缀索引。

- 按「字段个数」分类：单列索引、联合索引。



按数据结构维度分：

- BTree 索引：MySQL 里默认和最常用的索引类型。只有叶子节点存储 value，非叶子节点只有指针和 key。存储引擎 MyISAM 和 InnoDB 实现 BTree 索引都是使用 B\+Tree。

- 哈希索引：类似键值对的形式，一次即可定位。

- RTree 索引：一般不会使用，仅支持 geometry 数据类型，优势在于范围查找，效率较低，通常使用搜索引擎如 ElasticSearch 代替。

- 全文索引：对文本的内容进行分词，进行搜索。目前只有 `CHAR`、`VARCHAR`、`TEXT` 列上可以创建全文索引。一般不会使用，效率较低，通常使用搜索引擎如 ElasticSearch 代替。

按底层存储方式角度分：

- 聚簇索引：索引结构和数据一起存放的索引，InnoDB 中的主键索引就属于聚簇索引。

- 非聚簇索引：索引结构和数据分开存放的索引，二级索引就属于非聚簇索引。MySQL 的 MyISAM 引擎，不管主键还是非主键，使用的都是非聚簇索引。

按应用维度分：

- 主键索引：加速查询 \+ 列值唯一（不可以有 NULL）\+ 表中只有一个。

- 普通索引：仅加速查询。

- 唯一索引：加速查询 \+ 列值唯一（可以有 NULL）。

- 覆盖索引：一个索引包含（或者说覆盖）所有需要查询的字段的值。

- 联合索引：多列值组成一个索引，专门用于组合搜索，其效率大于索引合并。

- 全文索引：对文本的内容进行分词，进行搜索。目前只有 `CHAR`、`VARCHAR`、`TEXT` 列上可以创建全文索引。一般不会使用，效率较低，通常使用搜索引擎如 ElasticSearch 代替。

- 前缀索引：对文本的前几个字符创建索引，相比普通索引建立的数据更小，因为只取前几个字符。

<!-- question-id: q-06b35413397e -->
###### MySQL索引什么时候会失效？

- **左模糊匹配**：`LIKE '%小林'`、`LIKE '%小林%'` 不能按普通 B\+ 树索引的前缀定位，`LIKE '小林%'` 则可能使用范围扫描。

- **对索引列使用函数或计算**：比如 `YEAR(created_at) = 2024`、`price + 1 = 10`，普通索引通常不能直接用于定位。可以改成时间范围，或者改写为 `price = 9`；MySQL 8\.0 的函数索引也可以服务匹配的表达式。

- **隐式类型转换**：比如 phone 是 VARCHAR，却写 `phone = 13800138000`，可能需要把索引列转换成数字再比较。应该保持参数类型和列类型一致。

- **缺少联合索引最左列**：例如只有 \(a, b, c\)，却只按 b 查询，通常不能按最左前缀定位。

- **OR 的某个分支无法利用索引**：比如 a 有索引、b 没有索引，`a = 1 OR b = 2` 往往需要全表扫描。多个分支都有索引时，也可能使用 index\_merge，但是否采用仍取决于成本。

<!-- question-id: q-f3fdea5d8769 -->
###### MySQL索引数据结构？为什么使用B\+树而不是B树、二叉树或哈希表？

- MySQL索引（主要是InnoDB）使用B\+树作为数据结构。

- 为什么选B\+树：

    - 相比B树：B\+树所有数据存储在叶子节点，非叶子节点只存索引，查询更稳定（每次都要到叶子），且叶子节点形成有序链表，范围查询效率高。

    - 相比二叉树：二叉树在数据量大时树高过高，磁盘I/O次数多，B\+树是多路搜索树，矮胖，减少I/O。

    - 相比哈希表：哈希表仅支持等值查询，不支持范围查询和排序，B\+树支持范围查询和排序。

    - 磁盘I/O优化：B\+树节点大小通常设为页大小（16KB），一次I/O能加载更多数据，减少磁盘访问次数。

<!-- question-id: q-89050730fbbe -->
###### 什么是聚簇索引?什么是非聚簇索引？它们有什么区别

- 聚簇索引：将数据行和索引存储在一起，索引的叶子节点直接包含完整行数据。InnoDB中，主键索引即为聚簇索引。

- 非聚簇索引（二级索引）：索引的叶子节点只包含索引列和主键值，不包含完整行数据。

- 区别：

    - 聚簇索引每个表只能有一个，非聚簇索引可以有多个。

    - 聚簇索引的查询速度快（直接获取数据），但插入和更新可能引起页分裂。

    - 非聚簇索引查询时可能需要回表（通过主键查找聚簇索引）。

<!-- question-id: q-2ff093e6b029 -->
###### 什么是回表查询（数据库查询什么情况下会回表）？什么是覆盖索引？

- 回表查询：当使用非聚簇索引查询时，如果查询的列不在索引中，需要先通过索引找到主键，再通过主键到聚簇索引中获取完整行数据，这个过程称为回表。

- 覆盖索引：如果索引包含了查询所需的所有列，则无需回表，直接从索引中获取数据，称为覆盖索引。

<!-- question-id: q-967f55e9ff31 -->
###### 最左前缀原则是什么？联合索引\(a,b,c\) 生效的条件有哪些

- 最左前缀原则：联合索引的查询必须从索引的最左列开始，不能跳过中间的列，否则后面的列无法使用索引。

- 联合索引 \(a,b,c\) 生效条件：

    - 查询条件中包含a时，才能使用该索引。

    - 如果只包含a，则使用a索引。

    - 如果包含a和b，则使用a和b部分。

    - 如果包含a、b、c，则全部使用。

    - 如果条件中跳过b（只包含a和c），则只能使用a列索引，c列无法使用。

    - 范围查询（\>、\<、between）会导致后面的列失效，如 `WHERE a=1 AND b>2 AND c=3` ，则c无法使用索引。

<!-- question-id: q-50eae8f9c73c -->
###### 分库分表了解么

- 分库分表是应对大数据量、高并发场景的数据库拆分策略：

    - 垂直分库：按业务模块拆分到不同数据库（用户库、订单库）。

    - 垂直分表：将大表按列拆分成多个小表（将长文本字段拆分出去）。

    - 水平分库：将同一张表的数据按规则（取模、范围）分布到多个数据库实例。

    - 水平分表：将一张表的数据按规则拆分到多个结构相同的表中（可放在同一库或不同库）。

<!-- question-id: q-2a636b217b82 -->
###### MySQL一张表最多存多大的数据？怎么计算的

MySQL 一张表的数据大小理论上受限于操作系统的文件大小上限以及存储引擎的限制。以 InnoDB 为例：

1. 表空间文件（`.ibd`）最大可达到 64TB（取决于页大小和文件系统）。InnoDB的页大小默认为 16KB，每个表空间最多可容纳 2^32 个页，因此理论最大容量为 16KB \* 2^32 = 64TB。

2. 实际限制还受操作系统文件大小限制（ext4 最大单个文件 16TB）、MySQL 配置等因素影响。

3. 计算方式：数据大小 = 行大小 × 行数。行大小受列类型限制，实际表大小取决于数据量。但 InnoDB 表空间可以自动扩展，只要磁盘空间允许，可以存储海量数据。

<!-- question-id: q-6396314902aa -->
###### MySQL事务隔离级别？默认的隔离级别是什么？

- 事务隔离级别：

    - 读未提交：可能脏读、不可重复读、幻读。

    - 读已提交：避免脏读，但可能不可重复读、幻读。

    - 可重复读：MySQL默认级别，避免脏读、不可重复读，但可能幻读。

    - 可串行化：最高级别，强制事务串行执行，避免所有问题，但并发性能差。

- 默认事务隔离级别是可重复读

<!-- question-id: q-c524566ae502 -->
###### 什么是脏读、不可重复读、幻读？

- 脏读：一个事务读取到另一个事务未提交的数据。

- 不可重复读：同一事务内两次读取同一数据，结果不一致（因其他事务修改并提交）。

- 幻读：同一事务内两次查询得到的记录数不同（因其他事务插入或删除）。

<!-- question-id: q-39abe075425f -->
###### 事务的四大特性（ACID）分别是什么

1. 原子性（Atomicity）：事务中的所有操作要么全部成功，要么全部失败回滚。

2. 一致性（Consistency）：事务执行前后，数据库完整性约束不被破坏。

3. 隔离性（Isolation）：并发事务之间互不干扰，通过隔离级别实现。

4. 持久性（Durability）：事务提交后，修改永久保存到数据库。

<!-- question-id: q-4ea91653419c -->
###### MySQL事务四大特性的实现怎么保证的？

- 原子性是通过 undo log（回滚日志）来保证的；

- 一致性需要这些机制、数据库约束和正确的业务逻辑一起保证。

- 隔离性是通过 MVCC（多版本并发控制）或锁机制来保证的；

- 持久性是通过 redo log（重做日志）来保证的；

<!-- question-id: q-e6cd2b1962ac -->
###### binlog、undolog和redolog的区别？事务中隔离性是如何保证的（MVCC）

1. binlog（二进制日志）：MySQL Server层日志，记录所有修改操作（逻辑日志），用于主从复制和数据恢复。

2. redolog（重做日志）：InnoDB特有，物理日志，记录数据页的修改，用于崩溃恢复。

3. undolog（回滚日志）：InnoDB特有，逻辑日志，记录数据修改前的值，用于事务回滚和多版本并发控制（MVCC）。

4. 隔离性如何保证（MVCC）：

    1. MVCC 的核心是「隐藏字段 \+ undo 版本链 \+ Read View」。

    2. 在可重复读隔离级别下，事务开始时创建Read View，查询时只读取版本早于该视图的已提交数据，避免脏读和不可重复读。

    3. 通过undolog构建历史版本链，实现非锁定读。

<!-- question-id: q-a4cee0ad37fe -->
###### 具体讲一下redolog、undolog的作用

- redo log：用于保证事务的持久性。记录的是物理修改。事务提交时，必须先将 redo log 写入磁盘。当数据库宕机重启时，通过 redo log 重做已提交但未刷盘的数据，恢复数据到最新状态。

- undo log：用于保证事务的原子性和实现 MVCC。记录的是逻辑修改的逆操作。当事务回滚时，通过 undo log 将数据恢复到事务开始前的状态。同时，在 MVCC 中，undo log 用于构建旧版本数据，供其他事务读取快照。

<!-- question-id: q-7461f2cac54d -->
###### 主从复制是如何实现的？什么是读写分离？

- MySQL 集群的主从复制过程梳理成 3 个阶段：

    - **写入 Binlog**：主库执行数据修改，在提交阶段记录并提交相应 binlog 事务。

    - **同步 Binlog**：把 binlog 复制到所有从库上，每个从库把 binlog 写到暂存日志中。

    - **回放 Binlog**：回放 binlog，并更新存储引擎中的数据。

- 读写分离：基于主从复制，将写操作指向主库，读操作（SELECT）指向从库，分摊主库压力，提高并发能力。需注意数据延迟和事务一致性。

<!-- question-id: q-d25a93dc672e -->
###### MySQL和Redis的区别

- 存储介质：MySQL基于磁盘（内存\+磁盘）；Redis基于内存（可持久化）。

- 数据模型：MySQL是关系型数据库，支持SQL、事务、复杂查询；Redis是键值存储，支持多种数据结构，但不支持SQL。

- 性能：Redis读写性能极高（微秒级）；MySQL相对较慢（毫秒级）。

- 持久化：MySQL默认持久化；Redis需配置持久化，可能丢数据。

- 适用场景：MySQL用于结构化数据存储、复杂查询；Redis用于缓存、计数器、实时排行榜等。

<!-- question-id: q-6e1cdfb89014 -->
###### sql语句中union和union all有什么区别？

- UNION：用于合并两个或多个 `SELECT` 语句的结果集，并自动去除重复的行（对结果进行 distinct 操作）。性能相对较低，因为需要排序和去重。

- UNION ALL：也用于合并结果集，但保留所有行，包括重复行。性能更高，因为没有去重开销。



---



#### Redis

<!-- question-id: q-cb84b12597d9 -->
###### Redis宕机时的容灾能力

1. 持久化：通过RDB快照或AOF日志，将数据持久化到磁盘，宕机重启后可恢复数据。

2. 主从复制：采用主从架构，主节点宕机后，从节点可以提升为主节点。

3. 哨兵模式：哨兵节点监控主节点状态，当主节点宕机时，自动进行故障转移，选举新的主节点，并通知客户端更新连接。

4. Redis Cluster：集群模式通过分片和复制，部分节点宕机不影响整体服务，只要每个分片有至少一个从节点可用，集群能自动完成故障转移。

<!-- question-id: q-b8d71688b80a -->
###### Redis支持哪些数据类型？请介绍它们的特点和适用场景

- String（字符串）：可以存储字符串、整数或浮点数。支持原子增减操作。适用场景：缓存对象、计数器、分布式锁等。

- Hash（哈希）：键值对集合，类似Java的 `Map<String, String>`。适合存储对象（如用户信息），可以单独修改对象的某个字段，节省内存和网络开销。

- List（列表）：双向链表，支持从两端插入和弹出。适用场景：消息队列、最新消息列表、时间线等。

- Set（集合）：无序唯一集合，支持交集、并集、差集等操作。适用场景：标签系统、共同好友、抽奖去重等。

- Sorted Set（有序集合）：每个元素关联一个分数score，按分数排序。适用场景：排行榜、延迟队列、带权重的任务调度等。

- Bitmap（位图）：本质是字符串，但可对位进行操作。适用场景：用户签到、在线状态统计、布隆过滤器实现。

- HyperLogLog：基数估算算法，用于统计唯一值数量。适用场景：UV统计、独立IP数统计。

- Geospatial（地理空间）：存储经纬度，支持计算距离、范围查询等。适用场景：附近的人、位置服务。

<!-- question-id: q-2d17c27edfef -->
###### Redis常见5种数据结构的底层实现？

- String：底层使用简单动态字符串（SDS），支持动态扩容，记录长度和空闲空间，保证二进制安全。

- List：底层使用快速列表（quicklist），结合了压缩列表（ziplist）和双向链表。当元素较少且较小时使用压缩列表，否则转换为双向链表。

- Hash：底层使用压缩列表或哈希表（dict）。当元素少且键值对较小时用压缩列表，否则用哈希表。

- Set：底层使用整数集合（intset）或哈希表。当所有元素都是整数且数量较少时用整数集合，否则用哈希表。

- Zset：底层使用压缩列表ziplist或跳表skiplist加哈希表。当元素少时用压缩列表，否则用跳表（有序）和哈希表（存储分值）配合。

<!-- question-id: q-a7986787a641 -->
###### Redis是单线程的，为什么还这么快？

- 所有数据存储在内存中，读写速度快，避免了磁盘I/O延迟。（内存操作）

- IO多路复用技术，单线程可以高效处理大量并发连接。（非阻塞I/O）

- 单线程避免了线程切换和锁竞争的开销。（避免上下文切换）

- 底层数据结构针对性能做了优化（SDS、跳表、压缩列表）。（数据结构优化）

- 命令执行过程简单，无复杂计算，瓶颈通常在网络或内存，而非CPU。（纯命令执行）

<!-- question-id: q-af834bbf48ef -->
###### Redis的IO多路复用原理？

- Redis利用操作系统的IO多路复用机制（比如说epoll、kqueue、select等）实现单线程处理多个客户端连接。

- 原理是：内核同时监听多个文件描述符（socket），当某个描述符就绪（可读/可写）时，通知Redis进程进行处理。这样Redis单线程可以高效处理大量并发连接，避免为每个连接创建线程的开销，结合非阻塞IO和事件驱动模型，实现高吞吐。

<!-- question-id: q-f8d7b06f1e23 -->
###### 你在项目中一般使用Redis来做什么（redis的业务场景，有哪些用途）？为什么选择Redis而不是其他的缓存

常见用途：

- 缓存：缓存热点数据（用户信息、商品详情），降低数据库压力，提高响应速度。

- 分布式锁：基于 `SETNX` 或 Redisson实现分布式锁，控制共享资源访问。

- 计数器：使用 `INCR` 实现点赞数、访问量等原子计数。

- 排行榜：利用Sorted Set实现实时排行榜。

- 消息队列：使用List或Stream实现轻量级消息队列。

选择Redis而非其他缓存的原因：

1. 支持复杂数据类型，满足多样化需求。（丰富的数据结构）

2. RDB和AOF支持数据持久化，防止重启丢失。（持久化）

3. 主从复制、哨兵、集群提供高可用方案。（高可用）

4. 支持原子性操作，实现复杂逻辑。（Lua脚本）

5. 读写性能极佳，适合高并发场景。（性能高）

<!-- question-id: q-92c2948a7872 -->
###### Redis的持久化机制有哪些，RDB和AOF的优缺点

Redis提供两种持久化机制：

- RDB（快照）：将某一时刻的内存数据，以二进制的方式写入磁盘；

    - 优点：文件紧凑，适合备份和灾难恢复；恢复速度快；对性能影响小（主进程fork子进程处理）。

    - 缺点：可能丢失最后一次快照后的数据；fork子进程时可能短暂阻塞主进程。

- AOF（追加文件）：每执行一条写操作命令，就把该命令以追加的方式写入到一个文件里；

    - 优点：数据安全性高，文件可读。

    - 缺点：文件体积大；恢复速度慢；写性能可能略受影响。

- 混合持久化（Redis 4\.0\+）：结合RDB和AOF，AOF 重写生成的基础数据采用 RDB 格式，后续变化采用 AOF 命令格式，兼顾恢复速度和数据安全性。

    

我进一步问一下，恢复时哪个更快？

1. Redis重启恢复数据时，RDB的恢复速度通常比AOF快得多

2. RDB文件是Redis在某个时间点生成的二进制数据快照，它直接记录了内存中的数据形态。重启时，Redis只需将这个文件一次性加载到内存中即可完成恢复，这个过程非常高效。

3. 相比之下，AOF文件记录的是所有写操作的命令日志，是一种文本格式。重启恢复时，Redis需要逐条重新执行（回放）这些命令，才能重建出最终的数据集。这个过程相当于把数据“重演”一遍，自然要慢得多

<!-- question-id: q-6cec4283fb38 -->
###### Redis的过期删除策略？如果内存满了怎么办？

1. 定时删除（不单独使用）：为每个过期键设置定时器，到期立即删除，但消耗CPU。

2. 惰性删除：每次访问键时检查是否过期，若过期则删除。节省CPU，但可能堆积过期键占用内存。

3. 定期删除：每隔一段时间（默认100ms）随机抽取一部分键检查并删除过期键。

当内存达到 `maxmemory` 限制时，Redis根据配置的内存淘汰策略处理（LRU、LFU、随机删除）

<!-- question-id: q-03c8f698f481 -->
###### Redis的内存淘汰策略

1. allkeys\-lru：从所有键中淘汰最近最少使用的。

2. volatile\-lru：从设置了过期时间的键中淘汰最近最少使用的。

3. allkeys\-random：随机淘汰任意键。

4. volatile\-random：从设置了过期时间的键中随机淘汰。

5. volatile\-ttl：从设置了过期时间的键中淘汰剩余时间最短的。

6. allkeys\-lfu（4\.0\+）：从所有键中淘汰最不经常使用的。

7. volatile\-lfu（4\.0\+）：从设置了过期时间的键中淘汰最不经常使用的。

<!-- question-id: q-90fdba8402b2 -->
###### 分布式锁怎么延长过期时间？

分布式锁通常设置过期时间防止死锁，但若业务执行时间过长，锁可能提前释放。延长过期时间的常用方法是使用“看门狗”机制：

1. 客户端在获取锁成功后，启动一个守护线程或定时任务，定期（每过期时间的1/3）检查锁是否仍然持有，若持有则重新设置过期时间（续期）。

2. 在 Redis 中，可以使用 Lua 脚本原子性地检查和更新过期时间，确保续期操作安全。

3. Redisson 等客户端内置了看门狗实现，默认每10秒续期一次，直到锁释放。

4. 需要注意续期操作需与锁持有者绑定，避免其他线程误续期。通常使用唯一标识（UUID）作为锁的value，续期时校验 value 是否一致。

<!-- question-id: q-ee3b55af79fb -->
###### 什么是缓存穿透、缓存击穿和缓存雪崩？它们有什么区别？如何解决？

1. 缓存穿透：查询一个不存在的数据，缓存和数据库中都没有，导致每次请求都落到数据库，可能压垮数据库。

解决：缓存空值；使用布隆过滤器提前拦截不存在的数据。

2. 缓存击穿：某个热点key突然过期，大量并发请求同时查询该key，导致直接访问数据库。

解决：使用互斥锁控制只有一个线程去数据库加载；或者设置热点key永不过期。

3. 缓存雪崩：大量key同时过期或Redis宕机，导致大量请求落到数据库，可能引发数据库崩溃。

解决：随机过期时间；使用高可用集群；降级限流；提前预热。

- 区别：穿透是数据不存在，击穿是单个热点key过期，雪崩是大量key同时过期或服务不可用。

<!-- question-id: q-51d51dc9fe4d -->
###### 如何保证缓存与数据库的双写一致性？你在项目中是如何做的？

- 先更新数据库，再删除缓存（Cache\-Aside（旁路缓存）模式）

    - 读：先读缓存，若不存在则读数据库，然后写缓存。

    - 写：先更新数据库，成功后删除缓存。

先更新数据库再删缓存可能删除缓存失败导致脏数据。使用消息队列每隔一段时间重试直到成功为止或者订阅binlog异步删除。

- 改进使用延迟双删（先删缓存，更新数据库，休眠一小段时间再删一次。为了删除在更新数据库期间可能产生的并发读请求重新写入的脏数据。休眠时间需大于读请求将数据写入缓存的时间，确保第二次删除能清除脏数据。）

- 采用先更新数据库，再删除缓存，并配合消息队列异步重试删除，同时设置缓存过期时间（TTL）兜底。对于并发要求高的场景，使用Canal订阅MySQL binlog，异步更新缓存。

<!-- question-id: q-cf0b97629b48 -->
###### 先更新数据库再删缓存，缓存删除失败了怎么办？比如说因为网络波动等原因，导致缓存删除失败，删不掉

- 重试机制：将删除失败的key放入消息队列，异步重试删除，直到成功。

- 设置缓存过期时间：即使删除失败，缓存最终也会过期，但过期时间内可能不一致。

- binlog监听：通过监听数据库binlog，解析出变更数据，再异步删除缓存（Canal）。

- 双删策略：结合延迟双删，在更新数据库前先删一次缓存，更新后再延迟删一次，降低不一致窗口。

**为什么会缓存删除失败？**

1. Redis 超时、网络抖动

2. Redis 集群主从切换、节点不可用

3. 并发下被其他操作覆盖

4. 程序异常、事务提交后才执行删缓存，中间挂了

<!-- question-id: q-663407ce1dd1 -->
###### Redis\+MySQL以及两级缓存（本地缓存咖啡Caffeine\+Redis\+mysql）的数据一致性详细解读

1. redis\+mysql就一级缓存

2. 两级缓存情况下，数据一致性分为读和写：

    - 读：

        - 优先读本地Caffeine缓存，命中则直接返回。

        - 未命中则查询Redis，若存在则回填本地缓存后返回。

        - Redis也未命中则查询数据库，回填Redis和本地缓存后返回。

    - 写：（先更新数据库再删缓存）

        - 先更新数据库，然后将Redis中的对应缓存删除，广播本地缓存失效消息，通过可靠机制通知所有应用节点删本地缓存。

广播怎么做的？常用方式：

- Redis Pub/Sub：发布一个缓存失效事件，各节点订阅相应频道，收到后删除本地Caffeine缓存。

- 消息队列：发送失效消息，各节点消费后清除本地缓存。优点是可持久化、保证最终送达。

<!-- question-id: q-a8d1306be199 -->
###### 什么是大Key和热key，分别讲一下，有什么危害？怎么处理

- 大Key：某个key对应的value值所占的内存空间比较大，导致Redis的性能下降、内存不足、数据不均衡以及主从同步延迟等问题。

    - 危害：占用内存高；操作耗时可能阻塞Redis；网络传输慢；集群模式下导致数据倾斜。

    - 处理：拆分大key；压缩数据；使用合适的数据结构；设置合理的淘汰策略；监控并报警。

- 热Key：指某个key在短时间内被大量访问，比如热门商品。

    - 危害：单节点压力过大，可能导致Redis实例CPU升高甚至宕机；影响整体性能。

    - 处理：本地缓存；读写分离；将热key分散到多个节点；限流降级。

<!-- question-id: q-7b936a09967f -->
###### Redis集群主从复制原理

主从复制流程（全量同步和增量同步两种方式）：

- 全量同步（首次或从节点落后太多）：

    1. 从节点发送 `PSYNC` 命令请求同步。

    2. 主节点执行 `BGSAVE` 生成RDB快照，同时将新写命令记录到缓冲区。

    3. 主节点将RDB文件发送给从节点，从节点加载RDB恢复数据。

    4. 主节点将缓冲区中的命令发送给从节点，从节点执行，完成同步。

- 增量同步（从节点重启或短暂断开）：

    1. 从节点发送 `PSYNC` 带上主节点runid和复制偏移量。

    2. 主节点检查偏移量是否在复制积压缓冲区中，若在则发送缺失的增量命令；否则触发全量同步。

<!-- question-id: q-52469cb87ea5 -->
###### Redis哨兵机制了解么？它解决了什么问题（监控、选主、通知）

- 哨兵（Sentinel）是Redis的高可用解决方案，主要功能：不断检查主从节点是否正常运行。当主节点故障时，选举一个从节点升级为新主节点，并通知其他从节点复制新主。客户端可通过哨兵获取当前主节点地址，将故障转移结果通知管理员。

- 哨兵解决了主从复制中的单点故障问题，实现了主节点自动切换，保证服务高可用。它通常以集群形式部署，自身也具备高可用。

<!-- question-id: q-f55802af601d -->
###### Redis怎么保证高可用的？

1. 提供了RDB快照和AOF日志两种持久化方案，确保数据不会因为服务器问题而丢失。（持久化）

2. Redis具有主从复制功能，一个主节点可以复制到多个从节点，从而实现数据冗余。这不仅提高了数据的可用性，还能实现读分离，以提高读操作的吞吐量。（主从复制）

3. Redis Sentinel是一个监控和故障恢复系统。它可以监控主节点和从节点的健康状况，并在主节点故障时自动进行故障转移，将某个从节点提升为新的主节点。（哨兵机制）

4. Redis Cluster实现了自动分片，使得数据分布在不同的节点上。在某个节点故障时，其他节点依然能够提供服务，同时集群还支持复制和故障转移机制。（集群）

<!-- question-id: q-ebf5fd9e5ffe -->
###### Redis集群模式是如何实现数据分片的

Redis Cluster采用无中心化架构，数据分片基于哈希槽（hash slot）：

- 整个集群有16384个哈希槽，每个key通过 `CRC16(key) % 16384` 计算所属槽位。

- 集群中的每个主节点负责一部分哈希槽（节点A负责0\-5000，节点B负责5001\-10000等）。

- 客户端直连任意节点，节点会计算槽位，若数据不在本节点，则返回MOVED重定向。

- 集群支持主从复制，每个主节点可以有多个从节点，从节点负责复制和故障转移。

- 扩容时，可以动态调整槽位分配，将部分槽迁移到新节点。

<!-- question-id: q-30004fcf55f6 -->
###### 为什么Redis 6\.0之后引入了多线程？一定比单线程快吗

Redis 6\.0引入多线程主要针对网络I/O处理，而命令执行仍然是单线程的。原因：

- 随着硬件发展，网络I/O可能成为瓶颈，单线程处理大量连接时，CPU忙于读写网络数据，无法充分利用多核。

- 多线程I/O将网络数据的读写分配到多个线程，提高并发处理能力，减少主线程阻塞。

- 命令执行保持单线程，避免了复杂并发控制，保持简单性和稳定性。

多线程I/O不一定比单线程快，取决于场景：

- 优点：在高并发网络请求下，多线程I/O能显著提升吞吐量，尤其当Redis处理简单命令且带宽足够时。

- 缺点：对于CPU密集型命令（慢查询），多线程I/O帮助不大，如果网络不是瓶颈，单线程可能已经足够。

所以Redis 6\.0的多线程是可配置的（默认关闭），用户可根据实际场景选择开启。



---



#### 消息队列

<!-- question-id: q-829c595484ac -->
###### 为什么选择使用RocketMQ/Kafka/RabbitMQ做消息队列？对比一下这三款主流消息队列的优缺点

- RocketMQ

    - 优点：功能全面，原生支持事务消息、延迟消息、死信队列等复杂特性。单机支持万级Topic，适合金融、电商等对数据一致性和功能丰富度要求高的核心业务。

    - 缺点：生态成熟度相比Kafka稍弱，文档和社区支持主要在国内。

    - 适用场景：业务消息、事务消息、延迟消息等。

- Kafka

    - 优点：极致性能，具备百万级TPS的吞吐能力，基于磁盘顺序读写和零拷贝技术。高可靠，通过多副本机制和ISR保证数据不丢。

    - 缺点：功能相对单一，不支持延迟队列、死信队列等高级特性。消息模型主要是拉取模式，实时性略逊于推送模式。

    - 适用场景：日志收集、大数据分析、流式数据处理、用户行为轨迹跟踪。

- RabbitMQ

    - 优点：轻量易用，基于Erlang编写，管理界面友好，路由功能灵活。社区活跃，文档齐全。

    - 缺点：吞吐能力有限，相比Kafka和RocketMQ有数量级差距，消息堆积能力较差。Java开发人员排查底层问题可能有一定难度。

    - 适用场景：企业内部系统集成，对吞吐要求不高但需要灵活路由的中小型项目。

<!-- question-id: q-c207fecf797c -->
###### 消息队列是怎么保证高可用的

1. RabbitMQ：通过镜像队列实现。它将队列内容在集群多个节点间同步。当主节点宕机后，从镜像节点中可以选举出一个新的主节点继续提供服务，对客户端无感知。

2. Kafka：通过多副本机制实现。每个主题的分区数据都会复制到多个Broker节点上，这些副本分为Leader和Follower。生产者和消费者只与Leader副本交互，Follower副本实时同步数据。一旦Leader宕机，控制器会从ISR（同步副本集）中选举一个新的Leader继续服务。

3. RocketMQ：通过主从复制和分布式日志实现。DLedger模式下，RocketMQ支持Raft协议，可以在多副本中自动选举Leader，保证即使某组Broker的主节点宕机，只要同组还有存活节点，Topic的读写可用性就不受影响。

<!-- question-id: q-a168539681a0 -->
###### 消息队列如何保证消息不丢失？从生产者、Broker、消费者三个角度分别说明

- 生产者端：使用确认机制。生产者发送消息后，需等待Broker的确认应答（ACK）。如果未收到ACK，则进行重试。

- Broker端：持久化存储 \+ 多副本。消息成功写入磁盘后才向生产者返回ACK。同时利用副本机制将数据同步到其他节点。

- 消费者端：关闭自动确认，改为手动确认。消费者在处理完业务逻辑后，再手动向Broker发送确认信号。这样即使消费过程中宕机，消息也不会被删除，而是重新投递给其他消费者。

<!-- question-id: q-189237cae8d1 -->
###### Kafka的高性能设计体现在哪些方面？为什么它能达到百万级吞吐量

1. 磁盘顺序读写：Kafka利用磁盘的顺序访问特性，消息追加写入文件末尾，避免了磁盘随机寻址的开销，极大地提升了写入速度。

2. 零拷贝技术：在消息发送给消费者时，Kafka使用 `sendfile` 系统调用，数据直接从文件系统缓存传输到网络socket，无需经过应用程序内存，减少了数据拷贝次数和上下文切换。

3. 批量处理与压缩：生产者将多条消息打包成一个批次（Batch）发送，Broker和消费者也以批次为单位存储和拉取。同时支持端到端的压缩，减少网络I/O和磁盘占用量。

4. 分区的并行能力：一个Topic被划分为多个分区（Partition），每个分区对应一个物理文件。不同的分区可以分布在不同的Broker上，写入和消费都可以在不同分区上并行进行。

<!-- question-id: q-3519bdc2ce35 -->
###### 什么是消息重复消费？如何解决

由于消息队列的“至少一次”投递语义，在网络抖动、客户端超时或Broker故障等情况下，生产者重试可能导致同一条消息被发送多次，或者消费者处理成功后ACK丢失导致消息被重新投递，最终导致重复消费。

解决方案：核心是业务层实现幂等性。即无论同一条消息来多少次，处理结果都与第一次相同。

- 唯一键约束：利用数据库的唯一索引防止重复插入。例如，将订单号作为唯一键，重复的订单记录插入会失败。

- 去重表：维护一张消息去重表，在处理前先根据消息的唯一ID查询是否已处理过。

- 状态机：利用业务逻辑本身的幂等性。例如，将订单状态从“待支付”变为“已支付”的操作，重复执行也不会产生副作用。

- 借助Redis：将处理过的消息ID存入Redis Set中，设置过期时间，消费前检查是否已存在。

<!-- question-id: q-8516c9f9f279 -->
###### 怎么保证消息的顺序消费

打破并行，将需要顺序处理的消息路由到同一个队列（分区）中：

- 队列模型：选择将有序消息发送到同一个队列（分区）。

- 消费模型：一个队列（分区）只对应一个消费者线程进行消费。因为如果多个线程并行消费同一个队列，无法保证顺序。

- 常见限制：顺序消费会牺牲部分吞吐量和可用性。当某个队列的消费者出现故障时，会导致后续消息阻塞，直到故障恢复。

<!-- question-id: q-e31860b6e596 -->
###### 死信队列了解吗？详细讲一下，有什么作用呢死信队列

死信队列Dead\-Letter Queue用于存储无法被正常消费的消息。当一条消息满足以下条件之一时，会被扔进死信队列：

- 消费者消费失败，且重试次数达到上限。

- 消息在队列中存留时间超过过期时间（TTL）。

- 队列长度达到上限，新消息被拒绝。

有啥作用：

- 问题定位与排查：将消费失败的消息隔离保存，方便开发人员后续分析失败原因，而不会干扰正常消息的处理。

- 异常处理与补偿：可以单独创建一个消费者来处理死信队列中的消息，尝试进行人工干预或自动补偿

- 实现优先级队列：在特定场景下，可以配合TTL将暂时无法处理的低优先级消息转入死信队列，腾出空间给高优先级消息。

<!-- question-id: q-862602d90b3e -->
###### Kafka怎么保证消息的幂等性呢

Kafka保证幂等性主要是为了防止生产者在重试时向Broker发送重复的消息。它通过引入Producer ID（PID）和序列号（Sequence Number）来实现：

1. 开启幂等性后，每个生产者实例都会被分配一个唯一的PID。

2. 生产者发送的每条消息都会携带一个单调递增的序列号。

3. Broker端会为每个PID维护一个内存，记录每个分区上最后提交的序列号。如果Broker接收到一条消息的序列号恰好比当前记录的大1，则接受；如果小于等于当前记录，说明是重复消息，直接丢弃。

<!-- question-id: q-9b35c9e0451e -->
###### 消息队列中的零拷贝技术？

零拷贝技术指在数据传输过程中减少或避免CPU拷贝次数，提升性能。在消息队列中，通过操作系统的 `sendfile` 或 `mmap` 实现：

1. 传统文件传输：磁盘文件 → 内核缓冲区 → 用户缓冲区 → Socket缓冲区 → 网络，多次拷贝。

2. 零拷贝：使用 `sendfile`，数据从内核缓冲区直接到Socket缓冲区，减少用户态和内核态切换及拷贝。Kafka利用 `sendfile` 将日志文件直接发送给消费者。

3. mmap：将文件映射到内存，用户态可直接读写，减少一次拷贝，适用于小块数据。

<!-- question-id: q-97c99e9121ca -->
###### 如何实现延迟消息？RabbitMQ和RocketMQ分别是怎么做的

- RocketMQ：原生支持。支持18个预设级别的延迟，也可以自定义。实现原理是消息发送时指定延迟级别，Broker不会直接将消息放入目标队列，而是放入专门的延迟队列。有一个定时任务会在延迟时间到达后将消息转发到真正的Topic中。

- RabbitMQ：通过死信队列 \+ 消息TTL 间接实现。实现步骤如下：

    1. 创建一个普通队列，不设置消费者，并为队列中的消息设置TTL（存活时间）。

    2. 当消息在队列中存留超过TTL后，会变成死信。

    3. 为队列设置死信交换机，死信消息会被自动路由到绑定的死信队列中。

    4. 真正的消费者从死信队列中消费消息，从而实现延迟效果。



---



#### 计算机网络

<!-- question-id: q-86a98c1f45d2 -->
###### OSI七层模型和TCP/IP四层模型的结构

- OSI七层模型：从下到上依次为物理层、数据链路层、网络层、传输层、会话层、表示层、应用层。

- TCP/IP四层模型：从下到上依次为网络接口层、网络层、传输层、应用层。

<!-- question-id: q-5708768c48ca -->
###### 在浏览器中输入URL（如[www\.baidu\.com](https://www.baidu.com/)）到页面呈现，整个过程发生了什么？涉及哪些协议

1. 浏览器解析URL，确定协议、域名、端口。

2. 进行DNS解析，将域名转换为IP地址。

3. 浏览器与服务器建立TCP连接。如果是HTTPS，还会进行TLS握手。

4. 浏览器发送HTTP请求。

5. 服务器处理请求并返回HTTP响应。

6. 浏览器接收响应，解析HTML、CSS、JavaScript等资源。

7. 渲染页面，呈现给用户。

- 涉及协议：DNS、TCP、IP、HTTP/HTTPS、TLS/SSL，以及可能用到的ARP。

<!-- question-id: q-74183b4ccaa7 -->
###### TCP和UDP的主要区别是什么？各自的应用场景有哪些

- TCP是面向连接的、可靠的、基于字节流的传输协议，提供确认、重传、排序、流量控制等功能。

- UDP是无连接的、不可靠的、面向数据报的传输协议，不保证数据到达，不提供重传和排序。

- 应用场景：

    - TCP适用于要求可靠传输的应用，文件传输、网页浏览（HTTP）、电子邮件等。

    - UDP适用于实时性要求高、允许少量丢包的应用，如视频直播、DNS查询、游戏等。

<!-- question-id: q-dd33814ddaa9 -->
###### 详细描述TCP三次握手的过程。为什么需要三次握手，而不是两次或四次

- 过程：

    1. 客户端发送SYN报文（seq=x），进入SYN\_SENT状态。

    2. 服务器收到SYN，回复SYN\+ACK报文（seq=y, ack=x\+1），进入SYN\_RCVD状态。

    3. 客户端收到SYN\+ACK，发送ACK报文（ack=y\+1），进入ESTABLISHED状态；服务器收到ACK后也进入ESTABLISHED状态。

- 为什么需要三次：

    - 确保双方都有发送和接收能力。两次握手可能导致已失效的连接请求突然传到服务器，造成资源浪费。四次没必要

<!-- question-id: q-429e86b593be -->
###### 什么是ARP协议？它的工作原理是什么

- ARP：地址解析协议，用于将IP地址解析为物理地址（MAC地址）。

- 工作原理：

    1. 主机A想给同一局域网内的主机B发送数据，但只知道B的IP地址，不知道MAC地址。

    2. 主机A广播ARP请求：询问谁有IP地址X？请告诉你的MAC地址。

    3. 局域网内所有主机收到请求，只有IP地址匹配的主机B响应，单播回复包含自己MAC地址的ARP响应。

    4. 主机A收到响应，将IP\-MAC映射存入ARP缓存，之后用该MAC地址发送数据。

<!-- question-id: q-37326ec589e0 -->
###### TCP四次挥手的过程？为什么挥手需要四次

1. 主动关闭方（客户端）发送FIN报文（seq=u），进入FIN\_WAIT\_1状态。

2. 被动关闭方（服务器）收到FIN，回复ACK报文（ack=u\+1），进入CLOSE\_WAIT状态；客户端收到ACK进入FIN\_WAIT\_2状态。

3. 服务器发送FIN报文（seq=v），进入LAST\_ACK状态。

4. 客户端收到FIN，回复ACK报文（ack=v\+1），进入TIME\_WAIT状态，等待2MSL后关闭；服务器收到ACK进入CLOSED状态。

- 为什么需要四次：

    - TCP是全双工通信，双方都需要独立关闭自己的发送通道。当一方发送FIN表示自己不再发送数据，但还可以接收数据。另一方可能还有数据要发送，所以先回复ACK确认收到FIN，等数据发完后再发送自己的FIN。因此需要四次交互。

<!-- question-id: q-5572557adf37 -->
###### TCP是如何保证可靠传输的

1. 确认与重传：接收方收到数据后发送ACK，发送方超时未收到ACK则重传。

2. 序列号：对每个字节编号，接收方按序组装，丢弃重复数据。

3. 校验和：检测数据在传输中的错误。

4. 流量控制：通过滑动窗口避免发送方过快导致接收方缓冲区溢出。

5. 拥塞控制：避免网络过载。

<!-- question-id: q-f452e336a022 -->
###### TCP的拥塞控制机制有哪些？慢启动和拥塞避免有什么区别

1. 拥塞控制机制：包括慢启动、拥塞避免、快重传、快恢复。

2. 慢启动：连接建立后，拥塞窗口（cwnd）从1开始指数增长，直到达到慢启动阈值（ssthresh）。

3. 拥塞避免：当cwnd达到ssthresh后，进入拥塞避免阶段，cwnd线性增长（每经过一个RTT增加1 MSS），以减缓增长速度，避免拥塞。

4. 区别：慢启动是快速探测可用带宽，指数增长；拥塞避免是谨慎增长，线性增长。

<!-- question-id: q-b8289e7f2181 -->
###### TCP粘包/拆包问题是如何产生的？如何解决

- 产生原因：TCP是面向字节流的，没有消息边界。发送方多次写入的数据可能被合并成一个包发送（粘包），或者一个完整消息被拆分成多个包发送（拆包）。

- 解决方法：

    - 固定消息长度（每个消息固定字节数）。

    - 在消息头部添加长度字段，接收方先读取长度再读取相应字节。

    - 使用特殊分隔符（换行符）标记消息边界。

    - 应用层协议自行定义消息格式（HTTP的Content\-Length）。

<!-- question-id: q-455b8e7b96cd -->
###### HTTP/1\.0、HTTP/1\.1、HTTP/2\.0、HTTP/3\.0之间有哪些主要区别

- HTTP/1\.0：每个请求/响应都需要建立新的TCP连接，不支持持久连接。

- HTTP/1\.1：默认支持持久连接，允许管道化请求（但仍有队头阻塞），引入Host头、分块传输编码等。

- HTTP/2\.0：二进制分帧、多路复用（解决队头阻塞）、头部压缩、服务器推送。

- HTTP/3\.0：基于QUIC协议（UDP），减少连接建立延迟，解决TCP队头阻塞，支持连接迁移

<!-- question-id: q-70a9ef9d4e66 -->
###### HTTP和HTTPS的区别是什么？HTTPS的加密过程是怎样的

- 区别：

    - HTTP是明文传输，HTTPS通过SSL/TLS加密传输。

    - HTTPS默认端口443，HTTP默认端口80。

    - HTTPS需要CA证书，保证服务器身份真实性。

- HTTPS加密过程：

    1. 客户端发起HTTPS请求，连接到服务器的443端口。

    2. 服务器返回包含公钥的数字证书。

    3. 客户端验证证书合法性，生成随机对称密钥，用服务器公钥加密后发送。

    4. 服务器用私钥解密得到对称密钥。

    5. 之后双方用该对称密钥进行加密通信。

<!-- question-id: q-155893750408 -->
###### 什么是TCP滑动窗口？它的作用是什么

- 滑动窗口：一种流量控制机制，用于控制发送方发送数据的速率，避免接收方缓冲区溢出。

- 作用：

    - 实现可靠传输：通过窗口大小限制未确认的数据量。

    - 提高效率：允许发送方在收到ACK前连续发送多个数据包。

    - 接收方通过通告窗口大小告知发送方自己还能接收多少数据。

<!-- question-id: q-47ac55f2d49e -->
###### DNS的域名解析过程

1. 浏览器检查本地DNS缓存，若有则直接返回IP。

2. 若无，向本地DNS服务器发起查询请求。

3. 本地DNS服务器若缓存中有，则返回；否则向根域名服务器查询。

4. 根服务器返回顶级域名服务器（\.com）的地址。

5. 本地DNS再向顶级域名服务器查询，得到权威域名服务器的地址。

6. 本地DNS向权威域名服务器查询，得到域名对应的IP地址。

7. 本地DNS将结果缓存并返回给客户端。



---



#### 操作系统

<!-- question-id: q-f4aecc873201 -->
###### 什么是进程、线程？它们之间有什么区别

- 进程：程序的一次执行过程，是系统资源分配的基本单位，拥有独立的地址空间。

- 线程：CPU调度和执行的基本单位，是进程内的一个执行流，共享所属进程的资源。

- 区别：进程资源独立、创建切换开销大、通信复杂；线程资源共享、开销小、通信简单。

<!-- question-id: q-0459c3a1a1ab -->
###### 进程有哪些状态？它们之间是如何转换的

1. 基本状态：就绪（已具备运行条件，等待CPU）、运行（占用CPU执行）、阻塞（等待某事件，如I/O）。

2. 转换关系：

    1. 就绪 → 运行：调度程序分配CPU。

    2. 运行 → 就绪：时间片用完或被抢占。

    3. 运行 → 阻塞：等待事件（I/O请求）。

    4. 阻塞 → 就绪：事件完成（I/O结束）。

3. 此外还有创建和终止状态。

<!-- question-id: q-424c7f0a62d5 -->
###### LRU算法怎么实现的？（手撕的LRU用双向链表\+哈希表实现）

LRU（Least Recently Used）是一种缓存淘汰算法，其核心思想是当缓存空间满时，优先淘汰最久未被访问的数据。常见实现方式是基于双向链表和哈希表的组合：

- 使用双向链表维护数据的访问顺序，链表头部存放最近访问的数据，尾部存放最久未访问的数据。

- 同时使用哈希表（如HashMap）来存储每个数据对应的链表节点，实现O\(1\)时间复杂度的查找。

- 当访问某个数据时，通过哈希表找到对应节点，将其移动到链表头部（表示最近使用）。

- 当插入新数据时，若缓存已满，则删除链表尾部的节点（即最久未使用），并从哈希表中移除，然后将新节点插入链表头部并加入哈希表。

<!-- question-id: q-b2e629b8be21 -->
###### 什么是死锁？产生死锁的四个必要条件是什么

- 死锁：多个进程因竞争资源而互相等待，无法继续推进。

- 必要条件：

    1. 互斥：资源一次只能被一个进程占用。

    2. 保持并等待：进程持有资源并等待其他资源。

    3. 不剥夺：已分配的资源不能被强制剥夺。

    4. 循环等待：存在进程资源的循环等待链。

<!-- question-id: q-e66cb386830a -->
###### 如何避免死锁？请介绍几种常见的死锁预防策略

1. 避免死锁：通过算法（如银行家算法）分配资源，确保系统处于安全状态。

2. 预防策略：

    1. 破坏“保持并等待”：进程一次性申请所有所需资源。

    2. 破坏“不剥夺”：允许剥夺资源（如CPU可抢占）。

    3. 破坏“循环等待”：对资源类型进行线性排序，按序申请。

    4. 破坏“互斥”通常难以实现，因为有些资源天然互斥。

<!-- question-id: q-350b0dc0346f -->
###### 什么是虚拟内存？它解决了什么问题

- 虚拟内存：将每个进程的虚拟地址空间映射到物理内存，通过页表等机制管理，可使用磁盘作为后备存储。

- 解决的问题：

    - 内存隔离，保护进程间不干扰。

    - 扩展可用内存，支持大于物理内存的程序。

    - 简化内存管理（连续逻辑地址，物理可离散）

<!-- question-id: q-7fd2fa84242a -->
###### 什么是分页和分段？它们有什么区别

- 分页：将内存和逻辑空间划分为固定大小的页框和页，通过页表映射，对用户透明，主要解决内存碎片。

- 分段：按程序逻辑分段（代码段、数据段），每段大小可变，通过段表映射，便于共享和保护。

- 区别：

    - 页大小固定，段大小可变。

    - 分页无逻辑意义，分段有逻辑意义。

    - 分页减少外部碎片，分段便于共享和保护。

<!-- question-id: q-0b05c10078ab -->
###### 什么是内存对齐？为什么需要内存对齐

- 内存对齐：数据存储在内存中时，其首地址按一定规则（如数据类型大小的倍数）放置。

- 原因：

    - 硬件访问效率：许多CPU一次读取固定宽度数据，对齐可避免多次访问或出错。

    - 可移植性：某些平台强制对齐，否则引发异常。

    - 缓存性能：对齐可减少缓存行分裂。

<!-- question-id: q-ad8b1915151f -->
###### 什么是用户态和内核态？为什么要有这两种状态

- 用户态：普通程序运行的特权级，受限访问硬件和关键数据。

- 内核态：操作系统内核运行的特权级，可执行特权指令、访问所有内存和硬件。

- 作用：实现权限分级，保护系统安全，防止用户程序恶意或意外破坏系统。

<!-- question-id: q-5feaec8bfc46 -->
###### 用户态切换到内核态的触发方式有哪些

1. 系统调用：用户程序主动请求操作系统服务。

2. 异常：如缺页异常、除法错误等。

3. 外围设备中断：硬件设备发出中断请求。

<!-- question-id: q-9f871a991dec -->
###### 软链接和硬链接的区别是什么

- 硬链接：多个目录项指向同一个inode，文件删除需所有链接删除，不能跨文件系统，不能链接目录。

- 软链接（符号链接）：是一个特殊文件，存储指向另一文件或目录的路径，可跨文件系统，可链接目录，原文件删除后链接失效。

<!-- question-id: q-38573d8f8563 -->
###### 什么是零拷贝（Zero\-Copy）技术

一种IO优化技术，避免CPU在用户态和内核态之间多次复制数据，通过DMA直接将数据从磁盘或网络传输到目标缓冲区，或利用页表映射共享内存，减少上下文切换和数据拷贝，提升性能

<!-- question-id: q-56337f8839d1 -->
###### 常见的进程调度算法有哪些？

1. 先来先服务：按照进程到达的先后顺序进行调度，非抢占式，简单但平均等待时间较长。

2. 短作业优先：优先调度估计运行时间最短的进程，可减少平均周转时间，但可能导致长作业饥饿。

3. 优先级调度：为每个进程分配优先级，优先调度高优先级进程，可抢占或非抢占。

4. 时间片轮转：将CPU时间划分为固定时间片，按就绪队列顺序轮流分配，适合分时系统。

5. 多级反馈队列：设置多个不同优先级的队列，进程在不同队列间动态调整。

<!-- question-id: q-ea749217e9ea -->
###### 什么是大端字节序和小端字节序？

- 大端：高字节存放在低地址，低字节在高地址。

- 小端：低字节存放在低地址，高字节在高地址。



---



#### 场景题

<!-- question-id: q-fead30756070 -->
###### 百万级用户抢10个商品，缓存系统是怎么设计？具体你缓存里存的是什么？

- 用Redis集群存储核心数据，以商品ID为key，库存数量为value。

- 同时缓存商品静态信息，减少数据库查询。

- 库存扣减使用Lua脚本，确保原子操作。

- 设置库存售罄标记 `sold_out:商品ID`。

- 秒杀结束后，通过异步任务将最终库存同步到数据库。

<!-- question-id: q-7efa7133aa57 -->
###### 要实现一个支持百万级的用户的一个秒杀系统，你觉得有哪些举措

- 限流：前端限流，比如按键置灰，nginx限流，令牌桶或漏桶算法；

- 消息队列：削峰填谷；

- 流量控制：限流、消息队列削峰填谷；

- 缓存预热：提前存到缓存里面，减少查数据库次数；

- 库存扣减原子化：redis缓存\+lua脚本防超卖，实现库存的原子性扣减；

- 分层架构：静态资源通过CDN加速，页面静态化，减少动态请求。

<!-- question-id: q-7e9434b9363c -->
###### 设计一个秒杀系统需要考虑哪些问题？请详细讲一下你的思路，以及如何防止超卖

- 应用层：业务逻辑处理，使用本地缓存Caffeine缓存热点商品信息，执行用户级别限流。

- 缓存层：Redis集群预存库存，并提供原子扣减操作。

- 消息队列：削峰填谷，将订单创建异步化，保护数据库。

- 数据库层：MySQL主从架构，库存表使用乐观锁或行锁保证最终一致性，订单表设置唯一索引。

核心：

1. 缓存预热：秒杀开始前将商品库存加载到Redis。

2. 库存预扣减（Redis原子操作）：使用Lua脚本判断库存\>0并执行DECR，同时记录用户已抢标记SET NX。若成功则返回“排队中”并发送MQ消息，否则返回“已售罄”。

3. 异步订单处理：消费者从MQ拉取消息，生成订单并执行数据库最终库存扣减。若失败则回滚Redis库存。

如何防止超卖：

- 前端限流：按钮置灰、验证码

- 用户级限流：Redis记录用户请求频率，防止单用户高频刷单。

- Redis预扣减：使用Lua脚本原子性地检查并扣减库存

- 数据库乐观锁：更新库存时使用行锁或带版本号的乐观锁，确保最终扣减不超过实际库存。

- 订单唯一索引：订单表设置用户\+商品的联合唯一索引，防止同一用户重复下单。

- 消息队列异步处理：通过MQ削峰，消费者单线程处理，避免数据库并发冲突。

- 补偿机制：若数据库扣减失败，通过消息或定时任务回滚Redis库存，保证最终一致性。

<!-- question-id: q-7758c0258c2d -->
###### 你项目中的QPS大概是多少？如果QPS提升十倍，你会怎么做来保证系统性能

- 水平扩展：增加服务实例，负载均衡分发流量。

- 缓存优化：引入多级缓存本地Caffeine \+ Redis，减少数据库压力。

- 数据库优化：索引优化、读写分离、分库分表、使用NoSQL替代复杂查询。

- 异步化：将非核心流程比如说日志、统计之类的啊，改为消息队列异步处理。

- 代码优化：减少循环、并行流、池化技术、JVM调优。

- CDN加速：静态资源CDN，减少后端带宽。

<!-- question-id: q-460296279e6a -->
###### 如果你们的订单系统压力过大，导致经常超时，你会如何优化

1. 分析监控：CPU、内存、DB连接数、慢SQL、GC情况。

2. 优化数据库：加索引、SQL重写、分库分表、读写分离。

3. 引入缓存：热点数据（商品信息）缓存到Redis。

4. 异步解耦：订单创建后，后续处理（库存、物流）用MQ异步执行。

5. 限流降级：Sentinel或Hystrix保护系统，超时快速失败。

6. 扩容：增加应用实例和DB从库。

7. 线程池调优：调整核心线程数、队列大小，避免任务堆积。

<!-- question-id: q-652d3685446e -->
###### 有一个千万级数据量的用户表，如何进行深分页查询（比如说吧，猪包随便举个例子，跳过100万条取10条）的优化

- 覆盖索引：只查询索引字段，再根据id回表：`SELECT * FROM user INNER JOIN (SELECT id FROM user ORDER BY id LIMIT 100000,10) AS tmp ON user.id=tmp.id`。

- 子查询优化：先查出起始id：`SELECT * FROM user WHERE id >= (SELECT id FROM user ORDER BY id LIMIT 100000,1) ORDER BY id LIMIT 10`。

- 禁用深分页：业务上限制最多查看前100页，或使用搜索引擎（Elasticsearch）的 `search_after`。

<!-- question-id: q-9c06005f9303 -->
###### 接口 QPS 突增 10 倍怎么优化？

1. 加缓存，减少 DB 访问。

2. 异步化：非核心逻辑丢 MQ 异步处理。

3. 扩容服务器，集群部署。

4. 接口限流、熔断、降级，保护核心链路。

5. DB 读写分离、分库分表，加索引优化 SQL。

6. 静态资源放 CDN，网关层做缓存。

<!-- question-id: q-3084a59b592e -->
###### CPU 100%或者出现OOM 怎么排查？

**CPU 100%**

1. top 找到高 CPU 进程

2. printf %x 转线程 ID

3. jstack 查线程栈，定位死循环、频繁 GC、锁竞争

**OOM**

1. 开启 \-XX:\+HeapDumpOnOutOfMemoryError

2. MAT 分析 dump，看大对象、内存泄漏

3. 检查线程池、缓存、连接池是否无界增长

<!-- question-id: q-8f3ce272440b -->
###### 在分布式系统中，如何保证接口的幂等性？防止用户重复下单

1. 全局唯一ID：客户端生成请求ID（UUID），服务端通过Redis或数据库记录已处理ID，处理前检查SET NX，若存在则拒绝。

2. 数据库唯一约束：订单号设为唯一索引

3. 状态机：订单状态流转，只有待支付状态才能扣款，避免重复处理。

4. 去重表：建立一个去重表，利用主键或唯一索引防重。

5. 分布式锁：使用Redis或ZooKeeper对业务key加锁，保证同一时刻只有一个请求处理。

6. Token机制：下单前先获取token，下单时携带并删除token，保证一次有效。

<!-- question-id: q-0ee4039248b4 -->
###### 如何设计一个分布式锁？基于Redis的实现有哪些需要注意的点

- 原子性：使用 `SET key value NX PX 30000` 同时设置锁和过期时间。

- 唯一标识：value设为请求唯一ID，解锁时校验，防止误删其他线程的锁。

- 锁续期：使用Redisson的看门狗机制，定时续期防止业务未完成锁过期。

- 可重入：记录线程持有次数，可用ThreadLocal\+Redis hash实现。

注意点：

- 过期时间需大于业务执行时间，否则需续期。

- 解锁使用Lua脚本保证原子性。

- 避免死锁：设置过期时间。

- 性能：避免大key，减少网络开销。

<!-- question-id: q-dbff215d61f3 -->
###### 如果要设计一个全局唯一的ID生成器（分布式ID），你会怎么设计

- UUID：简单，但无序、太长，不适合做数据库主键。

- 数据库自增：使用数据库自增ID，但单点性能瓶颈，可设步长实现多实例。

- Redis INCR：基于Redis原子自增，性能高，但需考虑持久化。

- 雪花算法Snowflake：64位长整型，由时间戳（41位）\+机器ID（10位）\+序列号（12位）组成。优点：趋势递增、高性能。需解决时钟回拨问题（等待或记录上次时间戳）。

- 美团Leaf：基于雪花算法和数据库号段模式，提供高可用。

<!-- question-id: q-4a1ffc5e25a9 -->
###### 如何设计一个短链系统（短网址服务）

1. 发号器：生成唯一短码。可用自增ID（数据库）或哈希（MD5截取，需处理冲突）。

2. 存储：使用Redis做缓存（key=短码，value=长链接），持久化到MySQL。

3. 重定向：访问短链接时，查Redis，若不存在则查DB，返回302或301跳转长链接。

4. 防攻击：限流、黑名单、验证码。

5. 统计：记录点击次数、IP、时间等，异步写入消息队列。

6. 过期：设置过期时间，定时清理。

<!-- question-id: q-5e6ca9b4a443 -->
###### 在网络抖动或用户疯狂点击的情况下，支付接口收到了两次完全相同的请求。如何保证你的系统不会扣两次钱？

1. 请求携带唯一流水号（订单号\+请求序列），服务端用Redis的 `SET NX` 记录该流水号，若已存在则拒绝。

2. 数据库订单表增加唯一约束（支付流水号），重复插入会报错，事务回滚。

3. 使用分布式锁：对订单ID加锁，处理完释放。

4. 状态机：订单状态从“待支付”到“支付中”到“已支付”，更新时加乐观锁（`update order set status='PAID' where id=xx and status='PENDING'`）。

<!-- question-id: q-4f84ef7b8abc -->
###### 有一张表，你在where条件中使用了a、b、c三个字段，并建立了联合索引\(a, b, c\)。但有时SQL执行很快，有时全表扫描。哪些情况会出现索引失效？

1. 查询条件未遵循最左前缀（只查b或c）。

2. 使用范围查询（\>、\<、between）后，后续列索引失效（如 `a>10 and b=5`，b不会走索引）。

3. 对索引列使用函数或计算。

4. 隐式类型转换（如字符串字段查数字）。

5. LIKE以通配符开头（`%abc`）。

6. OR条件中有非索引列。

7. 数据分布：优化器认为全表扫描比索引更快（表中大部分数据满足条件）。

<!-- question-id: q-0c5db001c686 -->
###### 你的服务需要调用一个外部供应商的HTTP接口，但这个接口响应很慢（平均2秒），且偶尔会超时失败。如何设计你的调用逻辑，避免因为一个慢接口拖垮整个应用线程池。

1. 异步化：使用 `CompletableFuture.supplyAsync` 将调用放入独立线程池，避免阻塞主线程。

2. 线程池隔离：为外部接口单独创建线程池，设置最大线程数、队列大小，防止耗尽容器线程。

3. 超时设置：HTTP客户端设置连接超时、读取超时（如2秒）。

4. 熔断降级：使用Sentinel或Hystrix，当失败率达到阈值时快速失败，返回默认值。

5. 缓存：对非实时数据缓存结果。

6. 重试机制：设置重试次数，但需配合幂等和退避策略。

7. 限流：限制对第三方接口的访问频率。

<!-- question-id: q-71ea1bdcdcc9 -->
###### 我这边现在是有一个服务，那么在这个服务里面我有两个字，一个比如说名字，一个是学校。我需要对这两个字段也就是说进行建索引，那么我有两种两种鉴定方式。第一种鉴定方式就是name加学校的话，我把它建成唯一索引。第二种方式就只是建成一个普通的联合索引。那么我想知道也就是这两种建索引的方式，它在写也就是在数据写入mysql的这个场景下面，哪个效率会更高呢？

在MySQL中，对字段（name, school）建立唯一联合索引与普通联合索引相比，普通联合索引的写入效率更高。原因在于：

- 唯一索引在每次插入或更新时，需要额外检查唯一性约束，即判断是否存在相同键值的记录。这通常涉及一次索引查找操作，可能还会引入锁（间隙锁）来防止幻读，增加了开销。

- 普通索引则无需进行唯一性检查，只需直接插入或更新索引条目，因此写入速度更快。

- 在并发写入场景下，唯一索引的检查还可能引发更多的锁竞争，进一步降低性能。

因此，从写入性能角度，普通联合索引优于唯一联合索引。但实际选择需结合业务需求如果字段组合必须唯一，则必须使用唯一索引以保证数据完整性，不能为了性能而牺牲正确性。

<!-- question-id: q-8b2ae96eff59 -->
###### 面对突增流量，你需要在网关层或应用层做限流。如何基于令牌桶或漏桶算法实现？如果是单机限流和分布式限流有什么区别？

令牌桶：以固定速率向桶中放令牌，请求需获取令牌才能处理，桶满则丢弃令牌。可应对突发流量（桶内令牌积累）。

漏桶：以固定速率处理请求，请求进入桶中排队，桶满则丢弃。流量整形平滑。

实现：

- 单机：Guava RateLimiter（令牌桶），基于内存。

- 分布式：Redis \+ Lua脚本，存储桶状态（令牌数、最后更新时间），保证原子性。

区别：

- 单机限流：仅针对单个实例，无法控制集群总流量，容易因负载不均导致局部超限。

- 分布式限流：所有实例共享限流状态，精确控制集群总QPS，但依赖Redis等中心存储，有网络延迟和单点风险（可集群化）。实现复杂，需考虑时钟同步和原子性。



## Agent 八股

#### Agent

<!-- question-id: q-9d83e9237371 -->
###### 什么是 Agent？与大模型有什么本质不同？

Agent 本质上是一个能自主完成目标的 AI 系统，跟传统 AI 最核心的区别在于「自主性」和「能行动」。

传统 AI 是你问一个问题它回答一个问题，每次都是独立的，被动响应；而 Agent 有自己的规划能力，你给它一个复杂目标，它会自己把任务拆成多步，通过调工具、访问记忆、感知环境来一步步执行，直到完成。

<!-- question-id: q-f6ae76c30ccd -->
###### Agent 的基本架构由哪些核心组件构成？

Agent 的基本架构有四个核心组件：LLM、工具、记忆、规划模块。

LLM 是整个系统的大脑，负责理解任务和做决策；工具让 Agent 能跟外部世界交互，搜索、执行代码、调 API 都靠它；记忆让 Agent 在任务执行过程中保持状态，不会「失忆」；规划模块负责把复杂目标拆解成可执行的步骤。

<!-- question-id: q-d8b188a88913 -->
###### Workflow、Agent，Tools 这三个的概念和区别介绍一下？

Tools 是最小的能力单元，就是封装好的可调用函数，比如搜索、执行代码、发邮件，它只负责「执行」，本身没有任何决策能力。

Agent 是一个完整的决策系统，内部用 LLM 做大脑，自己判断什么时候调哪个 Tool、要不要继续、什么时候结束，是主动的。

Workflow 是更上层的编排框架，把 Agent、LLM、Tools 组织成一条确定性流程，每个节点做什么、按什么顺序流转都是开发者事先写死的。

三者最核心的区别就一句话：Tools 不做决策只执行，Agent 自己做决策，Workflow 是开发者替所有节点把决策提前写好。

<!-- question-id: q-9bbaf6d9303d -->
###### 了解哪些其他的 Agent 设计范式？Agent 和 Workflow 的区别是什么？

Workflow 是提前把流程写死的，每一步怎么走都是固定的，确定性高、好控制；Agent 是让 LLM 自己决定下一步做什么，灵活但不可控。

常见的设计范式除了纯 Agent 之外，还有 ReAct、Plan\-and\-Execute、Reflection 这几种。

我在实际工程里用得最多的反而是把两者混用，固定流程的部分用 Workflow，需要灵活决策的节点嵌入 Agent 能力，这样既保住了整体可控，又有局部的灵活性。

<!-- question-id: q-3ebf06c1e3fd -->
###### Agent 推理模式有哪些？ReAct 是啥？具体是怎么实现的？

最基础的是直接输出答案，没有中间推理；CoT 是让 LLM 先把推理过程写出来再给答案，准确率更高；ReAct 是在 CoT 基础上加了「行动」，让 LLM 交替输出思考和工具调用，每次行动后再根据结果继续思考，形成一个循环。

<!-- question-id: q-29d347eaf569 -->
###### ReAct、Plan\-and\-Execute、Reflection 三种范式有什么核心区别？实际项目中该如何选型？

Agent 开发里最主流的三种设计范式，核心区别在于「决策和执行的关系」。

ReAct 是边想边干，走一步看一步，单步迭代实时调整，灵活度最高；Plan\-and\-Execute 是先想全再干，先定完整计划再分步执行，适合长流程复杂任务，不容易跑偏；Reflection 不是独立的完整流程，而是给前两者加的「检查修正 buff」，用来提升输出质量。

实际选型就看三个维度：任务复杂度、流程确定性、输出质量要求，新手入门首选 ReAct，复杂任务用 Plan\-and\-Execute，高要求场景再加 Reflection。

<!-- question-id: q-ea00a504dbd3 -->
###### 复杂任务怎么做的任务拆分？为什么要拆分？效果如何提升？

我理解任务拆分的原因是 LLM 一次性处理太复杂的任务很容易出错，把大任务拆成小步骤，每步聚焦一件事，准确率会明显提升。

拆分方式主要有两种：一种是静态拆分，提前把步骤写死；另一种是动态拆分，让 LLM 自己根据目标规划步骤，更灵活但也更难控制。

拆完之后步骤之间可能有依赖关系，我的经验是把能并行的步骤并发跑，端到端延迟可以降很多，有时能降 40% 到 60%。

<!-- question-id: q-700821556600 -->
###### 请你介绍一下 AI Agent 的记忆机制，并说明在实际开发中应该如何设计记忆模块？

Agent 需要记忆才能在多步任务中保持状态、跨任务积累知识。

记忆机制分四层：感知记忆（当前输入的原始内容）、短期记忆（context window 里的对话历史）、长期记忆（存在外部数据库、语义检索召回）、实体记忆（结构化提取的关键事实）。

实际设计时要解决三个核心问题：存什么、怎么存、什么时候取出来用，根据信息类型选合适的存储方式，再搭配主动检索和按需检索两种策略使用。

第一个：存什么？

通常值得存的有三类：用户偏好和习惯（语言风格、技术栈偏好、工作习惯）、任务执行中产生的关键结论和决策（比如「调研发现竞品 A 的定价策略是按用量收费」）、以及外部知识（产品文档、FAQ、历史案例）。

不值得存的：中间推理过程、工具返回的原始数据（日志太啰嗦）、闲聊内容。这些存进去只会稀释有价值的记忆，让检索的信噪比下降。

第二个：怎么存？

需要语义检索的内容，比如文档知识、对话摘要这类非结构化的文本，适合存进向量数据库，用 embedding 编码后通过相似度检索。结构化的用户偏好和状态字段，比如语言偏好、项目配置这些可以精确查询的内容，更适合用关系数据库或 Key\-Value 存储，查询速度快，不需要语义理解。整段文档或知识库则适合存进向量数据库，配合 RAG 流程做召回。

第三个：什么时候取出来用？

第一种叫「主动检索」，在任务开始前，用当前任务的描述去检索相关记忆，把结果注入 system prompt 作为背景知识。第二种叫「被动触发」，Agent 在推理过程中，判断当前步骤需要某类特定知识时，主动发起检索。具体做法是把「查记忆」封装成一个 Tool，让 Agent 自己决定什么时候调。

![image\.png](media/feishu-agent-memory.png)

<!-- question-id: q-12f5f05c3965 -->
###### Agent 的长短期记忆系统怎么做的？记忆是怎么存的？粒度是多少？怎么用的？

我理解记忆系统分两层。

短期记忆就是 context window 里的对话历史，存当前任务的中间状态，任务结束就清掉；长期记忆用向量数据库存，把信息 embedding 后写入，用的时候做语义检索拿回来注入 prompt。

粒度上我通常按「一次完整交互」或「一个关键事件」为单位存，太细碎检索噪音大，太粗糙又丢失细节，这个需要根据业务实际调整。

<!-- question-id: q-d79fefaaa941 -->
###### 什么是 Multi\-Agent？

多智能体系统（Multi\-Agent）就是多个 Agent 协作完成任务，每个 Agent 各有分工，有的负责搜索、有的负责写代码、有的负责做评审。

我理解单个 Agent 主要受两个限制：一是 context 窗口大小，复杂任务信息量一多就撑爆了；二是单点能力，什么都让一个 Agent 做，每件事都是泛才。

Multi\-Agent 通过专业分工和并行执行，能处理更复杂、更长流程的任务，这是我在实际项目里选择多智能体方案的核心原因。

<!-- question-id: q-ac3af4af42a9 -->
###### 说说 Single\-Agent 和 Multi\-Agent 的设计方案？

Single\-Agent 适合任务流程清晰、复杂度适中的场景，实现简单、好维护；Multi\-Agent 适合需要专业分工、任务量大或者需要并行执行的复杂场景。

Multi\-Agent 架构上主要有两种拓扑：中心化的 Orchestrator 模式，由一个主 Agent 统一调度各个 Worker；去中心化的 Peer\-to\-Peer 模式，Agent 之间直接通信。

我在工程里用中心化用得更多，因为好控制、好调试，出问题链路清晰。

<!-- question-id: q-94895bc375a6 -->
###### Agent 记忆压缩通常有哪些方法？

记忆压缩常见有四种方法：摘要压缩、滑动窗口、重要性过滤、结构化抽取。

摘要压缩是把长对话总结成简短摘要；滑动窗口是只保留最近 N 轮对话；重要性过滤是打分筛选，只留重要内容；结构化抽取是把关键信息抽成结构化数据存起来。

我在实际项目里最常用的是摘要压缩和滑动窗口，而且经常组合用，滑动窗口丢弃前先做一次摘要，尽量不丢重要信息。

<!-- question-id: q-112449880b88 -->
###### 在工程实践中，为什么有时候选择「手搓」Agent，而不是直接用成熟框架？

框架有几个缺点：第一是抽象层太多，调试的时候不知道哪步出了问题，得一层层往下扒；第二是版本升级经常有破坏性变更，线上稳定性难保证；第三是框架的通用设计往往和具体业务需求有偏差，定制起来反而更费劲。

手搓的代码完全在自己掌控之内，可观测性好、出问题好排查，也更方便做性能优化。所以我现在的策略是核心逻辑手写，只在边缘功能上用框架的工具。

<!-- question-id: q-c04bf612381f -->
###### 如何赋予 LLM 规划能力？

给 LLM 加规划能力主要靠这几种思路。

- CoT 是让 LLM 把推理步骤写出来，线性地一步步推导到答案；

- ToT 是让它同时探索多条推理路径，选最优的继续深入；

- GoT 是图结构推理，推理节点可以复用和合并，适合更复杂的任务。

工程上我用 CoT 最多，因为实现成本最低，就是改个 prompt；ToT 效果更好但调用次数多，成本大概是 3 到 5 倍；GoT 目前还比较学术，生产环境我没见过有人真正落地用的。

<!-- question-id: q-2f5702954983 -->
###### 讲讲 Agent 的反思机制？为什么要反思？具体怎么实现？

反思机制我的理解是：让 Agent 在完成一个步骤或整个任务后，自我评估输出质量，判断有没有问题，不达标就重试或调整策略。

用反思的原因是 LLM 第一次输出不一定是最优的，加一轮自我检查能显著提升质量，相当于人写完东西自己再看一遍。

代价是多至少一次 LLM 调用，token 消耗和延迟都会增加，所以我在工程里通常只在质量要求高的关键节点启用反思，不是每步都做。

<!-- question-id: q-bd547bdbdcbc -->
###### 如何设计多 Agent 的协作与动态切换机制？

协作靠两件事：消息传递和共享状态。消息传递是 Agent 完成自己的工作后把结果发出去，下一个 Agent 取用；共享状态是所有 Agent 共同读写一个状态对象，记录任务进展和中间结果。

动态切换靠 Orchestrator 来做，有两种方式：一种是静态路由，提前写好规则「任务类型 A 就找 Agent X」；另一种是让 LLM 动态决策，根据当前情况实时判断该把任务交给谁。

我的实践是两种混用，主流程用静态路由保证稳定，边缘情况才交给 LLM 动态判断。

<!-- question-id: q-415ef0a390a7 -->
###### Agent 的上下文工程怎么设计？

我会把 Agent 的上下文工程设计成一个运行时装配流程，而不是把所有信息长期堆在一个 Prompt 里。每次模型调用前，先根据当前子任务，从指令、用户需求、结构化任务状态、短期对话、长期 Memory、工具定义与结果、RAG 证据中挑选本轮需要的内容，再完成优先级排序、来源隔离和 Token 分配。

其中，System、Developer 和 User 指令负责告诉模型「要做什么、不能做什么」，任务状态里的目标、约束、To\-Do、当前步骤和已完成结果负责告诉模型「现在做到哪了」，Memory、RAG 和工具结果则补充「完成这一步需要知道什么」。旧记忆和外部资料都不能覆盖更高优先级指令，网页、文档和工具返回值也必须按数据处理，不能混成新的命令。

工程上我会先预留输出空间，再给各类上下文设预算和不可丢失项。超出预算时，优先去重、裁剪低相关证据和无关工具，最后才压缩旧历史。同时把执行后的状态增量写回外部状态库，让下一轮重新按当前步骤装配，而不是让模型只靠聊天记录记住一切。

<!-- question-id: q-4f1ebef1b81e -->
###### Agent 的多轮对话状态如何管理？如何防止跑偏并支持中断恢复？

我会先把信息分成四类，而不是把所有内容都塞进 `messages`：对话历史保留用户和模型说过的原话，业务状态保存已经确认的实体与约束，任务状态记录目标、当前步骤和工具执行进度，长期记忆只保存跨任务仍然有价值的用户偏好与历史经验。

当前任务里，我会显式维护 `core_intent`、`current_subtask`、`pending_tools`、`completed_steps` 和 `context_snapshot`。每轮先判断用户输入是在补充、纠错、回答澄清问题，还是明确切换任务，再更新结构化状态。`core_intent` 是意图锚点，模型不能自行覆盖，但用户确认换题时可以创建新任务，或者生成一个新版本。

执行层用状态机控制合法流转，例如 `PLANNING -> EXECUTING -> WAITING_USER -> CHECKING -> DONE`。自然语言历史负责保留语气、原因和细节，状态机负责决定现在能做什么，两者配合，不能互相替代。

为了支持中断恢复，我会按 `session_id` 或 `thread_id` 隔离会话，再用 `task_id` 标识具体任务，在关键步骤保存 checkpoint。恢复时加载最近一次已提交状态，并核对未决工具调用。所有写外部系统的动作都要带稳定的幂等键，不能简单地从失败位置再执行一遍，否则可能重复付款、重复发消息。

<!-- question-id: q-3a3c5ac77f77 -->
###### 如何评估一个 Agent 的效果？评测集和指标怎么设计？

我评估 Agent 时不会只看最终答案，而是分四层。

工具层看该不该调用、工具选得对不对、参数和返回处理是否正确；单步与轨迹层看每一步决策是否合理，有没有漏步骤、重复调用、越权或绕过必要流程；端到端层看任务最终是否完成，外部环境状态是否达到目标；线上层再看真实业务里的成功率、用户接管率、延迟、Token、成本和安全事件。

评测集主要来自真实用户请求、历史 Badcase、边界场景和对抗样本。每条样本不只保存问题和参考答案，还要保存目标状态、允许或禁止的动作、关键检查点和评分规则。对于有多条正确路径的任务，不强行要求轨迹逐步完全一致。

评分时我会把确定性检查放在最前面，能用 Schema、数据库状态、单元测试和权限规则判断的，就不用大模型猜。开放式质量再交给人工和 LLM\-as\-a\-Judge，但要用人工样本校准裁判，并防范位置、篇幅和自我偏好等偏差。

最后，把安全和关键业务约束设成发布硬门禁，其余指标按核心任务和场景切片与基线比较。上线后通过 Trace、用户反馈和业务结果发现 Badcase，再回流到离线集，形成持续回归闭环。

<!-- question-id: q-fc1ad63b4299 -->
###### Agent 为什么会出现路径震荡、重复调用和死循环？怎么检测和治理？

Agent 出现路径震荡，常见原因是目标和停止条件模糊，工具失败后只返回空结果，任务状态没有随执行结果更新，或者多 Agent 的职责边界不清，交接时形成 A \-\> B \-\> A 的循环。

我会在调度层记录每一步的 Agent、工具、标准化参数、结果摘要和执行前后的状态。检测时结合动作指纹、输出相似度、状态变化和 Agent 调用图，并用步数、时间、Token、成本和交接次数作为全局预算。单纯动作重复只是预警，「状态长时间没有向完成标准推进」才是更可靠的循环信号。

触发预警后，我会先区分临时性错误和无进展循环。临时性错误走有界重试和退避；参数或权限错误直接修正或询问用户；执行路径没有进展时，禁用当前失败路径，改用其他参数或工具，必要时从检查点重新规划。预算耗尽或风险越界后，系统停止自动执行，将已完成结果、卡点和可选方案交给用户或人工处理。

<!-- question-id: q-77a67bb3c593 -->
###### 线上 Agent 延迟明显升高时，如何通过 Trace 定位和优化？

我会先确认慢的是 TTFT，也就是用户多久看到第一个 Token，还是总时延，也就是任务从接收到完成一共用了多久。然后按任务类型、模型版本、工具、租户和发布时间切分 P50、P95、P99，先判断是整体都变慢，还是只有少量长尾请求出问题。

接着，我会用同一个 Trace ID 串起网关、排队、上下文构建、检索、模型调用、工具调用、编排决策和最终生成。每个环节建独立 Span，记录耗时、状态、重试次数、输入输出规模、Token 数和错误类型，但不直接记录密码、完整提示词等敏感内容。

定位时先用指标圈定异常范围，再抽取慢 Trace 和正常 Trace 做对比，从瀑布图里找关键路径。重点看排队时间是否上涨，模型 TTFT 或生成速度是否变化，检索和工具是否出现长尾，Agent 步数和重试次数是否膨胀，以及原本能并行的步骤是否被串行执行。

优化要对症下药。排队问题做容量和并发治理，模型问题从路由、上下文、输出长度和缓存入手，检索与工具问题考虑连接复用、缓存、批量和安全并行，编排问题则减少无效步骤、重复调用和过度反思。修改后通过历史轨迹回放、灰度和分位数对比验证，同时守住任务成功率、答案质量、安全和成本，不能只把耗时压下来就算成功。

<!-- question-id: q-8a795b32f256 -->
###### Multi\-Agent 系统如何处理子 Agent 超时、失联和并发修改冲突？

我会先把「通信问题」和「一致性问题」分开。心跳中断只能说明协调器暂时看不到子 Agent，不能直接证明它已经停止。任务分配时应该带租约和递增的执行代次，子 Agent 定期续租；租约过期后协调器才能安排接管，旧执行者即使恢复，也不能再用过期代次提交结果。

接管不能简单从头重跑。我会保存任务 checkpoint，记录已经完成的步骤、产物版本和外部副作用。重试使用稳定的任务 ID、步骤 ID 和幂等键，遇到结果未知的写操作先查询外部系统，再决定继续、补偿还是人工确认。连续失败时还要支持换模型、换工具、拆小任务和人工接管等降级路径。

多个 Agent 修改同一个仓库时，先按任务依赖和文件所有权尽量减少重叠写入，再让每个 Agent 在独立 worktree 或 branch 中工作。提交时校验基线版本，对普通文件采用乐观并发，对少数热点文件使用带租约的短锁。最终只有 Integrator 有权合入目标分支，它按依赖顺序合并，并运行静态检查、单元测试和集成测试。出现文本冲突或语义冲突时，把最新基线、冲突原因和失败测试交回对应 Agent 修正，而不是让多个 Agent 直接抢写主分支。

<!-- question-id: q-0465c7015377 -->
###### Agent 的「任务幻觉」是什么？如何避免没有执行工具却声称任务已经完成？

Agent 的「任务幻觉」是指它把计划、尝试或者一段看起来成功的工具输出，当成了真实完成，并向用户作出与外部状态不一致的声明。它和普通文本幻觉的区别在于，普通幻觉主要是事实说错了，任务幻觉还可能让用户误以为退款、发信、改代码这些动作已经发生。

我会把模型定位成决策者，而不是事实裁判。调度层用代码维护任务状态机，只有真正调用工具、保存执行回执，并通过数据库查询、资源读取、单元测试等确定性方式验证目标状态后，任务才能从「执行成功」进入「已验证」。最终回复只能根据这份已验证状态生成。

遇到调用超时，也不能直接当失败重试，因为动作可能已经执行。系统要给有副作用的请求设置幂等键，再通过请求 ID 或业务状态查询结果。暂时查不清时就明确返回「结果待确认」，不能把未知包装成成功。

评测时则要专门构造未调用工具、伪造成功返回、异步未完成、响应丢失、陈旧缓存和部分成功等样本，重点统计错误完成声明率、证据覆盖率、重复副作用率和未知状态处理正确率，并把错误完成声明设成上线硬门禁。

<!-- question-id: q-d01c613c9cba -->
###### 大模型或 Agent 连接数据库时，如何防止越权、敏感数据泄漏和查询幻觉？

我不会把 Prompt 当成安全边界，也不会让模型拿着高权限账号直接执行任意 SQL。用户身份和租户范围来自可信的登录态，由网关传给策略层；模型只负责表达查询意图，真正的授权要在模型之外逐次校验。

数据库侧遵循最小权限。查询 Agent 使用独立的只读账号，只开放必要的库、表、视图和列，再用行级策略强制租户隔离。能封装成「查订单」「统计销售额」这类业务工具的，就不暴露通用 SQL。必须做 Text\-to\-SQL 时，要用 SQL 解析器检查语法树，对语句类型、表、列、函数和查询规模做 Allowlist，再通过参数化查询、只读事务、超时和行数限制执行。

敏感数据要从源头最小化，优先查询脱敏视图和聚合结果，进入模型前后都做字段裁剪与脱敏。数据库中的文本也属于不可信数据，里面即使出现「忽略规则」之类的内容，也只能作为数据展示，不能改变工具权限或执行策略。

查询安全不等于查询正确。系统还要校验字段是否存在、指标口径、租户过滤、时间范围和结果合理性，并保存查询依据。高风险写操作则使用独立工具，先预览变更，再经过权限校验和人工审批，最后依靠事务、幂等、影响行数限制和审计日志兜底。

<!-- question-id: q-dd0b2c1ecb0c -->
###### Agent Harness 是什么？

Agent Harness 可以理解为围绕大模型的一套运行支撑，核心是组织模型调用和工具执行的循环，让模型能根据实际结果连续推进任务。

模型负责理解目标、判断下一步，输出回复或工具请求。Harness 接住这些输出，检查并安排实际执行，再把工具结果放进下一轮输入，继续调用模型。工具请求本身只是模型提出的动作，真正的文件读取、命令执行或接口调用，需要外部程序完成。

任务变长以后，Harness 还需要组织每轮上下文，并配合任务记录保存进度，让中断后的运行能够接上已有结果。它也会落实动作权限、运行预算和结束判断，避免只凭模型说完成就结束任务。

所以，模型提供理解与决策能力，工具提供具体操作，Harness 把它们组织成可持续运行的任务过程。框架可以提供这些组件，也可能直接封装好运行机制，具体要看它实际包含什么能力。

<!-- question-id: q-364d782094f5 -->
###### 如何设计一个完整的 Agent Harness？

我会把 Harness 的核心做成一个执行循环：程序准备上下文，调用模型，接住它的工具请求，执行后把结果交回去，再让模型决定下一步。比如修复 Bug，模型负责判断要读哪些代码、怎么改，程序负责读文件、应用修改和运行测试。

每轮调用前，我会保留任务目标、约束、当前进度和相关材料。完整日志放在外部，需要时再读，避免把所有历史都塞给模型。工具执行要在允许的工作区和权限范围内，还要限制耗时，并把成功、失败或结果未知的情况传回来。

长任务的进度需要单独持久化，包括已经做过的操作、产物和未解决的问题。中断以后先核对实际文件和未决操作，再恢复执行。任务结束则以事先确定的验收条件为准，比如修改符合需求、相关测试通过；模型说完成时，程序还要检查这些证据。

另外，我会给整个任务设步数、时间和费用预算，并记录每轮输入、工具结果和状态变化。这样既能控制循环，也能在失败时查清问题出在模型决策、工具执行还是运行程序。最初这些模块可以放在一个服务里，接口分清楚以后，再按需要拆分。

<!-- question-id: q-c6558e0d6736 -->
###### Agent 的自进化机制如何实现？

我会在 Agent 的任务执行之外，加一条持续改进流程。任务完成后，把用户纠正、测试结果和实际执行记录放在一起，找出问题出在哪一步，再提炼成有适用范围、有证据的经验。后续遇到同类任务时，把相关经验放进上下文，让它在决策之前就能避开以前的错误。

比如 Agent 统计有效订单时漏掉了状态条件，不能只记住「上次答案是 4」。应该记住这类指标要先查业务定义，再按定义生成查询。一个场景的经验可以按需召回；如果很多任务都有相同问题，就可以把这套步骤整理进 Prompt 或 Skill，改进整个工作流程。这些变化都可以在不更新模型参数的情况下实现。

新经验和新流程需要先用没参与优化的任务验证，同时跑原来的成功场景，确认它能推广，也没有引入退化。通过后再逐步启用，保留来源和版本，出问题能撤回。如果要改的是模型本身，再考虑用经过校验的数据做训练。单次反思或修好一道旧题，还不能证明 Agent 持续变好了。

<!-- question-id: q-29451baf31b7 -->
###### Agent 应该在什么情况下请求人工确认？

我会先看这一步是不是在用户已经授权的范围内。目标和参数明确、操作也符合执行规则时，Agent 可以继续完成任务，不需要每次调用工具都重复确认。需要停下来问的，是关键对象或要求有歧义、准备执行的动作超出了原来的授权，或者业务规则要求人工审批的情况。

操作影响也要考虑进去。对外发送、删除唯一数据、扩大权限这类后果较大的动作，要把具体对象、内容和影响讲清楚，确认它们确实被授权。用户已经明确批准过同一项操作，而且方案和条件没有变化，就可以沿用这份批准，不能只因为又调用一次工具就重新问。

实现上，我会在真正执行前保存待确认方案，让用户批准、修改或者拒绝。批准要和具体任务、参数版本绑定，恢复时再核对方案与当前权限。用户说同意不等于有后端操作权限，也不能证明一次超时的操作没有发生。结果未知时先查实际状态，确实需要人的判断再升级处理，不能让一句「继续」代替事实核查。

<!-- question-id: q-9178c36072b7 -->
###### Agent 的上下文压缩阈值应该如何确定？

压缩阈值应该根据剩余空间和接下来要做的任务来确定，没有一个通用的 80%。当前输入除了聊天记录，还有指令、工具定义和工具结果，先把这些内容的实际 Token 占用算清楚，再给模型输出和下一步可能增加的内容留出空间。

比如一个 Agent 接下来要读取大量测试日志，即使当前窗口还没用到 80%，剩余空间也可能不够；如果只是做一次短查询，后续增长很小，就可以保留更多原始信息。所以阈值更适合跟着任务动态调整。

另外，压缩本身也有代价，太早会损失细节，太晚可能超限。具体的触发比例和压缩后的目标大小，要在实际任务上比较完成效果、关键信息保留、延迟和成本。压缩完还得检查目标、约束和未完成状态是否保留下来，不能只看 Token 降了多少。

<!-- question-id: q-b6a30db31db5 -->
###### 相同输入为什么会得到不同的 Agent 执行结果？

我会先确认这里的相同输入，指的是同一句用户问题，还是完整运行条件都相同。Agent 还会用到系统指令、历史、记忆、工具定义和任务状态，这些内容变化，模型实际收到的请求就已经不同了。后续工具读到的数据也可能变化，所以相同用户文本不一定应该得到相同结果。

即使模型请求相同，生成策略也可能从候选中采样，导致输出不同。降低 temperature 或固定支持的 seed，可以控制一部分变化，但模型版本、推理实现和数值计算也会影响结果。另外，并发工具的返回顺序、超时重试和共享状态更新，都可能改变后续决策。这些差异进入多步循环以后，还会继续影响下一轮输入。

排查时，我会保存实际请求、模型配置、工具参数与返回、状态变化，对齐两次执行记录，先找最早出现差异的位置，再通过固定观察或回放事件检查对应环节。稳定性则要按业务要求判断：合理路径和措辞可以不同，事实、计算结果、权限约束和写操作的去重必须符合规定，不能只用逐字一致衡量。



---



#### RAG

<!-- question-id: q-c7594f8d5381 -->
###### 什么是 RAG？详细描述一个完整 RAG 系统的详细工作流程？

RAG 全称是 Retrieval\-Augmented Generation，就是检索增强生成。我理解它解决的核心问题是，LLM 的知识在训练完之后就固定了，遇到私有数据或者最新的信息它就答不上来。RAG 的做法是在生成答案之前，先去外部知识库里检索相关内容，然后把检索结果和用户的问题一起交给 LLM，让它基于这些上下文来回答。本质上就是给 LLM 开了一个开卷考试的口子，不用再靠死记硬背了。

<!-- question-id: q-c7cdd36bc91d -->
###### 大模型的 RAG 主要用来解决什么问题？

RAG 主要解决三个问题。

第一是知识时效性，LLM 训练完知识就固定了，训练截止日期之后发生的事它一无所知；第二是私有知识覆盖，公司内部文档、行业专有数据根本没有机会进训练集，LLM 对这些内容是空白的；第三是幻觉问题，没有知识依据时 LLM 容易「自己发挥」编出一个听起来合理但实际错误的答案，给了它参考资料之后幻觉就少很多。

这三个问题的根源都是同一件事，知识被固化在了模型参数里。RAG 的解法是把知识存到外部，用的时候实时检索注入，彻底绕开了参数里的知识限制。

<!-- question-id: q-1850651f52ab -->
###### 相比直接微调 LLM，RAG 解决了什么问题？微调和 RAG 各自的优劣势是什么？

我的理解是这两个东西解决的不是同一层面的问题，不是谁替代谁的关系。

微调是把新知识直接烧进模型参数里，适合改变模型的行为风格或者培养深度的专业能力；RAG 是在推理的时候实时检索注入知识，适合知识需要频繁更新、或者需要有溯源的场景。

如果非要让我选一个，知识库类的问答系统我会首选 RAG，成本低而且可以随时更新。如果是要让模型学会特定的输出格式或者行业语气，那微调更合适。

实际上这两个方案也可以组合用，先微调再套 RAG。

<!-- question-id: q-7f73d9786753 -->
###### RAG 中的文档是怎么存的？粒度是多大？详细说说文档切割（Chunking）策略？

文档不能直接存进向量库，必须先切成小块也就是 chunk，每个 chunk 分别向量化之后存成一条记录。

每条记录我理解有三个核心部分：向量用于相似度检索，原始文本是检索命中之后塞给 LLM 读的内容，metadata 是来源文件、页码这些附加信息，用于过滤和溯源。这两个东西缺一不可，向量负责找到，原文负责阅读。

切割粒度没有固定答案，通常 500 到 1000 个 token 是一个合理的起点，但更重要的是根据文档类型来选策略，普通文本用固定大小加重叠，有标题结构的文档按语义边界切，代码按函数切，如果既要检索精度又要上下文完整的话，我会用父子切割，也就是小块检索、大块返回。

<!-- question-id: q-dfc16ccd604c -->
###### 怎么规避语义被切割掉的问题？

我的思路是从两个方向来规避这个问题。第一个方向是切的时候就不要在语义中间截断，用重叠切割和语义边界切割来保证每个 chunk 内容是完整的，也就是按句子、段落这些自然的边界来切。

第二个方向是切完之后用检索策略把上下文补回来，核心方案是句子窗口检索，命中一个句子就把周围几句一起返回给 LLM；另外还有父子切割，小块检索命中、大块内容输出。

还有一个我觉得比较有价值的方案，是 Anthropic 提出的 Contextual Retrieval，在做 Embedding 之前先让大模型看着整篇文档为每个 chunk 生成一段背景说明，把这段背景和 chunk 拼在一起再向量化，从根本上解决孤立 chunk 没头没尾的问题。

<!-- question-id: q-3d92803018c1 -->
###### 在 RAG 中 Embedding 究竟是什么？如何选择和评估一个 Embedding 模型？

Embedding 我理解就是把一段文本转成一串数字向量的过程。它有一个很关键的特性，就是语义相近的文本，转出来的向量在数学空间里的距离也近。RAG 里的语义检索就是靠这个实现的，不是关键词匹配，而是看两段内容的意思相不相近。

选模型的话，我主要看三个维度：第一是中文支持，中文场景我会优先选 BGE 系列，效果其实比 OpenAI 的模型还要好；第二是向量维度，维度越高精度越好，但存储成本也越大；第三是最大输入长度，这个决定了能处理多长的 chunk。

评估这块我的建议是不要只看通用排行榜，一定要在自己的业务数据上跑召回测试，那个才是真正有参考价值的。

<!-- question-id: q-a28e6b21c046 -->
###### Embedding 有哪几种算法你了解过吗？

Embedding 算法大致经历了三代演进。

第一代是静态词向量，以 Word2Vec 和 GloVe 为代表，把每个词映射成固定向量，但同一个词不管上下文是什么，向量永远不变，处理不了多义词。

第二代是以 BERT 为代表的上下文相关向量，同一个词在不同语境下有不同的向量，表达能力大幅提升，但 BERT 本身输出的是 token 级别的向量，两个句子要比较相似度就必须拼在一起跑，百万条文档就要跑百万次，检索速度完全不可接受。

第三代是以 SBERT、SimCSE、BGE 为代表的句子级对比学习 Embedding，专门为「两段文本有多相似」这个任务优化，能提前把所有文档向量算好存起来，查询时只需算一次，是 RAG 场景的标配。

<!-- question-id: q-add5377102f2 -->
###### 什么是向量数据库？有没有做过向量数据库的对比选型？

向量数据库是专门用来存储和检索高维向量的数据库，核心能力是近似最近邻搜索，也叫 ANN，能在百万甚至亿级的向量里快速找出最相似的几条。

普通关系型数据库的索引结构对高维向量基本上是失效的，所以需要专门的数据库来处理这个场景。

我自己做过一些选型，本地开发阶段我用 Chroma，零配置上手极快；生产环境的中小规模我推荐 Qdrant，性能不错、API 也比较简洁；如果到了超大规模就要考虑 Milvus 了，字节和小米都在用；不想自己运维的话 Pinecone 是一个云托管的选项；如果项目里已经有 PostgreSQL，也可以直接用 pgvector 插件，不用引入新组件。



Chroma 上手最简单，一行 pip 装好就能用，数据存本地文件，非常适合做实验和跑 Demo，但它没有分布式能力，不适合生产。

Qdrant 用 Rust 写的，单机性能很好，部署也简单（Docker 一条命令），适合中小规模、团队运维资源有限的场景。

Weaviate 功能较全，支持多种搜索模式，适合需要向量搜索与结构化查询结合的场景。

Milvus 是功能最全、扩展性最强的开源选项，支持分布式部署，读写节点分离，能横向扩容，适合数据量在百万到十亿级别、并发查询量大的生产场景。

<!-- question-id: q-754b60cf2e69 -->
###### 讲讲你用的向量数据库？数据量级是多大？性能如何？遇到过性能瓶颈吗？

我们生产环境用的是 Milvus，数据量级在百万条向量左右，每条是 1024 维，用 HNSW 索引，单次查询的延迟在 20 到 50 毫秒。选 Milvus 主要是因为它支持分布式部署和读写分离，适合数据量大、并发高的场景。

我遇到过两个比较典型的瓶颈。

第一个是内存压力，百万级的 1024 维向量光原始数据就要好几个 GB，后来我们开启了标量量化 SQ8，把 float32 压成 int8，内存直接降到原来的四分之一。

第二个是大批量写入的时候会触发后台 Segment 合并，影响查询延迟，我们的解法是把批量写入改到业务低峰期，分批小批次写入。

<!-- question-id: q-4940e21d51f7 -->
###### 你使用 RAG 给大模型一个输入，系统是怎样的工作流程？

当你把一个问题输入给 RAG 系统，它不会直接丢给大模型，而是先经历一套「检索 \-\> 整理 \-\> 生成」的流水线。

具体来说：系统先对问题做预处理（改写成更适合检索的形式），然后把问题向量化，去向量库里找最相关的文档片段，再经过精排筛掉噪音，最后把筛选出来的片段和问题一起拼成 Prompt 交给大模型，大模型基于这些「参考资料」生成最终答案。

整个流程的核心目标只有一个：让大模型在回答时有真实的知识作为依据，而不是凭空发挥。

<!-- question-id: q-4c4e84ce7caa -->
###### 请你介绍一下向量检索和关键词检索的区别？

关键词检索（BM25 这类）靠的是词频统计，看查询词在文档里出现了多少次，擅长精确命中；向量检索靠的是语义空间里的距离，能理解「换了种表达方式的同一个意思」，擅长模糊语义匹配。两者各有盲区：BM25 遇到同义词就没辙，向量检索遇到专有名词、产品型号这类精确词就容易漏。所以 RAG 系统里通常两路都跑，向量检索捕获语义相关的内容，BM25 精准命中关键词，再用 RRF 算法把两路结果合并，这样覆盖面比单路宽很多。

<!-- question-id: q-73d82201dd4c -->
###### 如何润色用户的 Query（Query Rewrite）？目的是什么？

我用 Query Rewrite 主要是为了弥补用户提问方式和知识库文档表述之间的语义鸿沟。用户的问题往往口语化、模糊、带缩写，而文档写的是正式书面语，向量相似度天然偏低，导致该召回的内容没被召回。

我接触过的方法主要有四种：第一是直接改写，让 LLM 把口语化的问题转成更精准的表述；第二是 Query 扩展，补充相关关键词；第三是 HyDE，让 LLM 先生成一个假设答案，然后用答案的向量去检索；第四是 Step\-back Prompting，把具体问题往上抽象一层，检索更通用的背景知识。

<!-- question-id: q-28eb5fccd6b7 -->
###### 什么是多路召回？具体怎么做？

多路召回就是同时用多种不同的检索方式去捞候选内容，然后合并排序，而不是只靠单一的向量检索。我理解核心出发点是向量检索和关键词检索各有盲区，向量检索擅长语义相似，但对精确词语比如产品型号、缩写、数字效果比较差；BM25 关键词检索正好相反，精确匹配强，但不理解语义。我在项目里常用的组合是向量检索加 BM25 混合检索，再加上多 Query 扩展，也就是把用户问题改写成多个版本分别检索。多路的结果用 RRF 算法融合，最后送进 Rerank 精排。

<!-- question-id: q-6ca2ddb75f2d -->
###### RAG 检索优化策略有哪些？

我理解 RAG 的检索优化可以从四个层次来看：索引层决定知识怎么存，查询层决定问题怎么转换，召回层决定从哪些路径去找，重排序层决定最终哪些内容进入 prompt。

每一层都有对应的优化手段，我的经验是单独优化一个层次往往效果有限，线上系统我会组合来用，先靠索引优化和多路召回来保证覆盖率，再用 Rerank 保证精度，如果用户提问质量比较差，再额外加上查询优化。

<!-- question-id: q-d0deaaa57ae4 -->
###### 了解哪些更复杂的 RAG 范式？

在我的了解里，RAG 的发展经历了三代演进：Naive RAG 是基础的检索加生成；Advanced RAG 在检索前后都加了优化，比如 Query 改写、Rerank、混合检索这些；Modular RAG 是把各个环节做成模块可以任意组合。

在这之上还有几个我觉得值得关注的高级范式。

Self\-RAG 是让 LLM 自己来决定要不要检索，以及评估检索质量；CRAG 是检索质量差的时候自动降级到网络搜索；GraphRAG 是微软推的方案，用知识图谱的社区发现和层次摘要来增强全局理解能力；Agentic RAG 是把 RAG 做成 Agent，支持多轮的动态检索。

<!-- question-id: q-c812bf40170a -->
###### 在什么场景下，你会选择使用图数据库来增强传统的向量检索？

我的判断是，当业务问题涉及多个实体之间的关联推理的时候，就需要考虑引入图数据库来增强。

向量检索有一个根本的局限，它只能做单跳检索，找和问题直接相关的文档，没办法沿着实体之间的关系链做推理。比如你问公司 A 的投资方和公司 B 有什么交集，单纯向量检索就很难处理了，因为答案不在某一段文档里，而是藏在多个节点之间的关系上。

这时候图数据库就能发挥作用，沿着关系边一跳一跳地把关联信息收集回来。我接触过的典型场景有企业关系分析、医疗知识图谱、代码依赖关系查询、供应链溯源这些。

<!-- question-id: q-301e28748ae9 -->
###### 如何规避 RAG 系统中大模型的幻觉？

我遇到过的 RAG 幻觉主要有两类。第一类是检索没有召回到相关内容，LLM 没有可用的上下文，靠自身知识在编造答案。第二类是检索内容召回了但 LLM 没有严格遵循，在文档内容的基础上加了自己的推断。我用来规避幻觉的策略主要有四个方向：第一是 Prompt 强约束，明确告知 LLM 只能根据提供的资料回答，资料里没有的就说不知道；第二是检索质量门控，Rerank 分数低于阈值就直接拒答，不让 LLM 在低质量上下文上硬撑；第三是生成后引用核查，每个关键的声明都要在 chunk 里找到来源依据；第四是结构化输出强制溯源，让 LLM 输出 JSON，每条结论必须附上来源编号。其中 Prompt 强约束加检索质量门控是我觉得成本最低、收效最快的组合，生产系统上线前这两个必须做。

<!-- question-id: q-b6fa4dcd3c22 -->
###### 怎么量化你的 RAG 效果？

我评估 RAG 效果是分两层来看的。

检索层看该召回的有没有召回到，我用 Hit@K 和 MRR 来衡量。生成层看答案对不对、有没有幻觉、和问题相不相关，我主要用 RAGAs 框架，里面的 Faithfulness、Answer Relevancy 和 Context Recall 这三个指标是最核心的。

我的建议是一定要在自己的业务数据上跑，不能只看通用排行榜，那个不能代表你的场景。

另外线上指标，就是用户的点踩率、追问率、转人工率这些，才是最终的衡量标准，离线指标只是辅助。

<!-- question-id: q-100d3c6247b2 -->
###### RAG 知识库如何实现动态与持续更新？

我理解知识库更新的核心挑战是，文档变了，对应的 chunk 和向量都要跟着变，而且要做到增量处理，不能每次全量重建。我们的通用方案是给每个文档算一个内容 hash，通过轮询或者监听数据源变更，检测到文档新增、修改、删除的时候，先清掉旧的向量，再重新切割入库。对于实时性要求比较高的场景，我会用消息队列比如 Kafka 做变更事件驱动，实现秒级的入库。

<!-- question-id: q-0d187096cd43 -->
###### 在实际落地中，你觉得 RAG 最难的地方是哪里？

我觉得 RAG 最难的不是把它跑起来，一个基础的 Demo 一两天就能搭起来，难的是把它调好。工程上最让我头疼的有三块。

第一是文档预处理，原始数据的格式五花八门，PDF 里面的表格、图片、嵌套的格式，处理不好就是一堆乱码进了知识库，进去的是垃圾出来的也是垃圾。

第二是检索质量的调优，向量召回不准是整个系统效果的天花板，但问题来源很多，Chunking、Embedding、Query 改写，任何一个环节出问题都会影响结果，排查起来很费劲。

第三是效果评估，答案对不对很难系统性地衡量，不知道是哪个环节出了问题，优化就变成了瞎猜。

<!-- question-id: q-25f58daac90b -->
###### 不同来源的文档发生知识冲突时，RAG 应该信谁？

遇到知识冲突时，我不会直接选择向量相似度最高的文档，因为相似度只能说明内容和问题相关，不能证明它更权威、更及时，也不能证明它适用于当前用户。

我的处理顺序是先看适用范围，再看来源权威度、版本状态和生效时间。入库时要保存来源、负责人、发布时间、生效区间、版本、地区、产品和状态等元数据；检索时先按用户、地区、产品和时间做过滤，再在适用的文档中召回和排序。

如果两份同等权威且同时有效的材料仍然矛盾，系统不应该偷偷二选一，而要明确告诉用户存在冲突，分别引用两边的依据，必要时转人工审核。工程上还要有冲突检测、灰度发布、版本回滚和专项评测，保证错误知识不会悄悄进入生产答案。

<!-- question-id: q-3ebd02ebd4a8 -->
###### 上下文窗口很大时为什么还需要 RAG？

上下文窗口决定模型一次能读多少资料，RAG 则负责从外部资料中找出当前问题需要的证据。即使整个知识库都装得下，也不代表每份资料都相关、都有效，或者模型一定能把分散的条件全部用对。

RAG 可以在生成之前检索并整理材料，把相关内容和适用版本交给模型，减少无关信息，也避免每次处理整个资料库。外部资料更新以后，通过更新内容和索引就能让后续回答使用新证据，不需要先重新训练模型。不过版本、权限和索引刷新都要实际实现，不能只靠向量相似度判断。

它也不是每个任务都必须用。资料少、需要整体理解时，直接读全文可能更合适；检索可能漏掉例外或跨段关系。大窗口反而能帮助 RAG 读得更完整，比如先定位相关文档，再读取完整章节。两者可以配合，取舍要看证据是否充分，以及整条链路的效果和成本。

<!-- question-id: q-cac62c5c464e -->
###### RAG 与 Agent 自主文件检索应该如何选型？

这里比较的是常见的预建索引 RAG 和 Agent 在运行时自主查找文件，主要看任务是否需要根据中间结果继续探索。广义上，Agent 搜索外部资料再回答，也属于检索增强，二者并不是完全对立的技术。

资料量大、同类问题多，且答案通常能从明确的知识范围里找到，预建索引更容易复用资料处理成本，也便于控制查询链路。需要沿引用、配置或代码关系逐步追查时，自主检索更灵活，读到什么就能决定下一步查什么，但探索轮数和成本也更容易波动。

关键词还是语义匹配，是另一项选择。RAG 可以用关键词索引，Agent 也可以调用语义检索。实际可以让索引先定位候选文件，再由 Agent 读取原文、核对版本并补查关联材料。最终要比较任务完成情况、证据完整性和总开销；少量资料需要通读时，直接读取全文也可能最简单。



---



#### 工具调用

<!-- question-id: q-12344d9e85b0 -->
###### 什么是 Function Calling？原理是什么？

Function Calling 我的理解是这样一套机制：开发者用 JSON schema 把工具描述好传给模型，模型判断需要调工具的时候不输出自然语言，而是直接输出一段结构化的 tool\_calls JSON，告诉你「我要调哪个函数、参数是什么」，你的代码拿到这段 JSON 去真正执行，把结果塞回对话，模型再生成最终答案。

整个流程本质上是两轮对话：第一轮模型说「我需要调这个工具」，你去执行，第二轮模型拿到执行结果说「答案是这个」。

我觉得最核心的设计是，模型全程只做决策，执行的事情一律由宿主代码完成，职责分得很清楚。

<!-- question-id: q-1ff09bc495a6 -->
###### LLM 是如何学会调用外部工具的？

这道题我分两块来讲：模型怎么被训练出工具调用能力，以及训练好之后运行时是怎么工作的。

训练层面靠两个阶段：

- SFT（监督微调，Supervised Fine\-Tuning）：给模型喂大量「工具调用示范对话」，让它通过模仿学会「看到工具描述 \-\> 判断要不要调 \-\> 输出结构化 JSON 请求」这整套流程；

- RLHF（基于人类反馈的强化学习，Reinforcement Learning from Human Feedback）：收集人类对「哪种回答更好」的判断，训练一个打分器，再用这个分数反复调整模型，让它学会什么时候不应该调工具。

运行层面，每次请求时，你的应用代码把工具描述（叫 schema，可以理解为工具的说明书）传给模型，模型如果判断需要工具，就输出一段结构化的 `tool_calls` JSON；你的代码拿到这段 JSON 去真正执行，把结果塞回对话，模型再给出最终答案。

有一点非常关键：模型全程只是在「下指令」，真正执行工具的是你的代码，不是模型本身。这套「模型决策、代码执行」的运行时机制，就是我们常说的 Function Calling。

<!-- question-id: q-71e53aac125f -->
###### 大模型的 Function Call 能力是怎么训练出来的？

Function Call 的能力主要靠两个训练阶段来培养，这两个阶段解决的是不同的问题。

第一个是 SFT，就是给模型喂大量「包含工具调用的完整对话样本」，每条样本覆盖工具定义、用户问题、模型应该输出的结构化 JSON 调用、工具执行结果、最终答案，让模型通过模仿学会整套流程。但光有 SFT 不够，模型可能学得过激，遇到什么问题都想调工具。

第二个阶段是 RLHF，通过人类标注「哪种回答更好」来训练奖励模型，再用强化学习调整主模型，让它学会「能直接回答的就直接回答，需要实时数据才去调工具」这个边界感。

一句话总结：SFT 教会怎么调，RLHF 教会什么时候调。

<!-- question-id: q-8f6e21713e83 -->
###### 什么是 MCP（模型上下文协议）？讲讲它的核心内容？

我理解 MCP 是一套连接 AI 应用与外部工具、数据的开放协议。它统一了能力发现和调用方式，让兼容的 AI 应用复用同一个 MCP Server，减少重复对接。

架构里，Host 是 AI 应用，负责模型交互、上下文和权限；Client 是 Host 内部的通信组件，每个 Client 对接一个 Server；Server 提供外部能力。所以一个 Host 可以通过多个 Client 接入多个 Server。

服务端的三类主要能力是 Tools、Resources 和 Prompts，分别提供可调用的功能、上下文数据和提示模板。Tools 既可以只读，也可以写入，不能单纯按有没有副作用来区分。

一次工具调用中，模型通常通过 Function Calling 提出工具名和参数，Host 检查授权，通过 Client 请求 Server 执行，再把结果交给模型生成回答。这样就能看出 Function Calling 和 MCP 怎样配合。

底层消息使用 JSON\-RPC 2\.0，标准传输方式有适合本地进程通信的 stdio，以及适合独立服务部署的 Streamable HTTP。

<!-- question-id: q-70893fa24e2e -->
###### MCP 由哪几部分组成？

MCP 由三层组成，可以从角色、能力、协议三个维度来理解。

角色层有三个：Host 是 AI 应用本身（比如 Claude Desktop），Client 是 Host 里负责和 Server 通信的模块，Server 是工具提供方实现的独立进程，一个 Host 可以同时连多个 Server。

能力层定义了 Server 能暴露三类东西：Tools 是有副作用的操作（比如创建文件、调 API），Resources 是只读数据（比如读取文档内容），Prompts 是预定义的提示词模板。

协议层是底层通信：消息格式统一用 JSON\-RPC 2\.0，传输方式支持 stdio（本地子进程通信）和 Streamable HTTP（远程 HTTP 连接）两种，早期的 HTTP\+SSE 双端点方案在 2025 年 3 月的规范更新里被标记为 deprecated。

这三层合在一起，就是 MCP 的完整组成。

<!-- question-id: q-2295a20a1248 -->
###### MCP 和 Function Calling 有什么区别？有没有实际跑过 MCP？

我理解这两者不是竞争关系，解决的不是同一层面的问题。

Function Calling 是「调用语言」，定义的是模型怎么表达「我要调哪个函数、参数是什么」；MCP 是「工具生态协议」，定义的是工具怎么标准化打包、注册和被 AI 客户端发现。

MCP 底层其实还是用 Function Calling 来触发工具调用，只是在它之上加了一套工具管理框架，让工具实现一次、到处复用。

打个比方：Function Calling 像 HTTP 请求格式，MCP 像 REST API 的设计规范加服务注册发现机制，两者是不同层次的东西。

关于实际跑过的经验，我用 Claude Desktop 配过文件系统和 GitHub 的 MCP Server，在配置文件里加几行就能用，Claude 会自动发现工具，完全不用写对接代码。

<!-- question-id: q-4f1875c0a045 -->
###### Function Calling 也属于工具调用，请问什么场景下使用 Function Calling，什么场景下使用 MCP？

如果只是给单个应用接一两个工具、场景临时、不需要复用，Function Calling 就够了，简单直接，不需要引入额外的进程和配置。

但只要工具需要跨项目或跨团队复用、或者数量多了管理麻烦、或者社区已经有现成的 MCP Server 可以直接配置，MCP 就值得上了。

判断的核心问题只有一个：这个工具会不会在这个应用之外被用到？会的话，把它封装成 MCP Server 是更长远的选择。

此外，做 Agent 系统的话更应该选 MCP，工具来源多、数量大，手写 Function Calling 的维护成本会让代码变得难以管理。

<!-- question-id: q-e3c418bae114 -->
###### 为什么有些特定的推理模型不支持 MCP 协议？

我理解根本原因是两者的生成范式有冲突。

推理模型在给出答案之前，会先跑一段完整的「思维链」，这个 thinking 过程是一次性连续生成的，不能中途打断。但工具调用天然是多轮交互：模型输出调用请求、暂停等工具执行、拿到结果再继续生成，这两种模式没法兼容。你没法在思考链跑到一半的时候暂停去等工具结果，否则之前的推理上下文全断了。

而 MCP 底层就是靠 Function Calling 驱动的，推理模型连 Function Calling 都支持不好，MCP 自然也用不了。

当然这个问题不是无解的，后来 o3 和 Claude Extended Thinking 都找到了折中方案，比如让工具调用发生在思考阶段结束之后，保证思考过程还是一次性完整生成的。

<!-- question-id: q-cd99aec4a125 -->
###### Skill 是什么？

Agent Skill 是把「指令、脚本、模板」一体化打包成可复用能力包的机制，关键在于三件事：Agent 能自动发现它、按需加载它、在需要时调用里面的脚本和资源。它不只是「存 prompt」，而是一份 Agent 能自己翻阅的「操作手册 \+ 工具箱」。每个 Skill 是一个文件夹，里面有一份 `SKILL.md` 指令文件，还可以带上脚本、模板、参考文档这些资源。

它和普通 prompt 最大的区别是：Skill 能被 Agent 自动发现和按需加载，不用你每次手动输入；和 MCP 工具的区别是：MCP 给 Agent 提供外部工具和数据的访问能力，而 Skill 教 Agent 拿到这些工具和数据之后该怎么用。

<!-- question-id: q-943467054c89 -->
###### MCP 和 Agent Skill 的区别是什么？

MCP 和 Agent Skill 不是同类概念，不是竞争关系，而是互补的。

MCP 解决的是「Agent 怎么获得外部能力」，它把数据库、API、文件系统这些外部工具标准化封装成服务，Agent 通过 MCP 就能查数据、调接口、读写文件。

Skill 解决的是「Agent 拿到这些能力之后，该按什么步骤、什么标准来完成任务」，它把完成某类工作的知识和流程打包成可复用的模块。

简单记：MCP 是给 Agent 配的电脑和软件，Skill 是给 Agent 发的操作手册和 SOP。在实际系统里，两者经常同时工作，Skill 定义流程，流程中调用 MCP 提供的工具。

<!-- question-id: q-6f7343839e7b -->
###### Function Calling、Skill、MCP 这三个有什么区别？

这三个概念在不同层次工作，不是竞争关系。

Function Calling 是最底层的调用协议，解决的是「模型怎么调函数」，模型输出结构化 JSON 告诉程序该调哪个函数、传什么参数。

MCP 在 Function Calling 之上做工具标准化，解决的是「工具怎么暴露给模型」，把数据库、API 这些外部能力封装成标准化服务，一次实现到处复用。

Agent Skill 在最上层做知识和流程的封装，解决的是「拿到工具之后按什么流程完成任务」，把执行步骤、标准、脚本、模板打包成可复用模块。

简单记就是：Function Calling 是语言，MCP 是工具箱，Skill 是操作手册。

<!-- question-id: q-ed3253120158 -->
###### 什么是 A2A 协议？它和 MCP 协议的区别是什么？

A2A 是 Google 发布的开放协议，专门解决多个 AI Agent 之间怎么互相通信协作的问题。

我理解它和 MCP 的区别是这样的：MCP 解决的是「单个 Agent 怎么连工具和数据」，A2A 解决的是「多个 Agent 之间怎么分工协作」。

一个 Agent 通过 A2A 可以把子任务委托给另一个专业 Agent，接收方按自己的 Skill 声明承接，支持异步长任务和流式推送结果。

两者是互补的，不冲突：MCP 向下连工具，A2A 向上连 Agent，在复杂的多 Agent 系统里这两个通常都要用到。

<!-- question-id: q-3eb2ba685033 -->
###### MCP 协议通常采用什么通信方式？

MCP 支持两种主要的传输方式，分别适用于不同场景。

本地场景用 stdio，Client 把 Server 作为子进程启动，通过标准输入输出通信，延迟极低，不用开端口，也没有网络安全问题，我用 Claude Desktop 接本地工具走的就是这种方式。

远程场景现在推荐用 Streamable HTTP，Server 作为独立的 HTTP 服务部署，多个 Client 可以共享同一个 Server，适合团队统一管理工具服务。

底层消息格式都统一用 JSON\-RPC 2\.0，传输方式只影响「怎么传」，消息协议本身不变。

<!-- question-id: q-8ad663516e6c -->
###### 说说 WebSocket 和 SSE 通信的区别及局限性？

我觉得最核心的区别是通信方向：SSE 是服务端单向推，客户端只能接收，想发消息只能另起一个 HTTP 请求；WebSocket 是全双工，双方都可以随时主动发消息。

对于 LLM 流式输出这种「模型一直在推 token、用户只是看」的场景，SSE 完全够用，而且轻量、HTTP 原生支持、运维简单，OpenAI 和 Anthropic 的 API 用的都是 SSE。

WebSocket 的复杂性只有在真正需要双向实时交互的时候才值得引入，比如用户要在模型说话过程中随时打断。

两者各有局限：SSE 在 HTTP/1\.1 下有连接数上限，只支持文本传输；WebSocket 有状态、横向扩展麻烦，还容易被企业代理或防火墙拦掉。大多数 LLM 文字对话产品用 SSE 就够了。

<!-- question-id: q-99d351a92a3e -->
###### 为什么要用 WebRTC 协议？它和 WebSocket（WS）在 AI 对话流中的核心差异是什么？

我理解核心原因是 WebSocket 基于 TCP，而 TCP 的可靠性设计在实时语音场景里反而是负担。

语音可以容忍丢包，但绝对不容忍延迟；一旦网络抖动丢了包，TCP 强制等重传，后续所有音频都得跟着等，延迟一堆积通话就卡。

WebRTC 走的是 UDP，丢包了不等重传，直接用插值算法填补，用一点点音质损失换来稳定的低延迟，延迟能控制在 50 到 150 毫秒。

另外 WebRTC 还内置了回声消除、噪声抑制、自适应码率这些语音处理能力，这些用 WebSocket 都得自己实现。

所以 OpenAI Realtime API 这类实时语音产品选 WebRTC，就是因为 TCP 根本撑不住语音场景的延迟要求。

<!-- question-id: q-ab4280d9bf7d -->
###### 有没有用过大型模型的网关框架？网关层解决了什么问题？

我用过 LiteLLM，它是目前最活跃的开源 LLM 网关。我理解网关本质上是架在应用和模型 API 之间的中间层，主要解决几个实际问题。

第一是多模型统一接口，业务代码只调一个地方，想换模型只改网关配置，不用动应用代码；第二是 API Key 集中管理，不用每个服务都存一份，降低泄漏风险。

第三是限流和配额，可以给不同团队分别设 token 预算，防止某个团队把整个公司的额度用光；第四是成本追踪，所有请求的 token 用量都在网关记录，方便统计哪个服务最烧钱。

还有一个我觉得挺实用的能力是语义缓存，两个用户问了语义相近的问题，直接命中缓存返回上次的结果，根本不打底层模型，省钱还降延迟。

<!-- question-id: q-f85522a13694 -->
###### 工具很多时，Agent 如何做 Tool Routing，减少 Token 并避免选错工具？

工具很多时，我不会把全部 Schema 都塞给模型，而是做分层 Tool Routing。

首先维护统一的工具注册表，给工具补齐命名空间、标签、适用场景、参数 Schema、权限、风险等级和可用状态。每次请求先用产品范围、租户、用户角色、环境和当前任务状态做硬过滤，把无权调用或当前不可用的工具直接隐藏。

接着做两级召回。一级用规则或轻量分类模型判断工具类别，比如检索类、订单类、支付类；二级在相关类别内，用关键词、BM25、Embedding 或混合检索召回少量候选工具。最后只把候选工具的完整描述和 Schema 动态绑定给 LLM，让它判断是否调用、选哪个工具以及怎样填参数。

Tool Routing 路由的是「工具候选集」，Multi\-Agent Routing 路由的是「任务由哪个 Agent 接手」，这两个层次可以配合，但不能混为一谈。

上线后我会同时看候选工具的 Recall@K、最终工具选择准确率、无工具场景的拒选准确率、参数合法率、任务成功率、工具 Schema Token、端到端延迟和越权暴露率。低置信度时优先澄清或扩大召回，不能让模型猜一个高风险工具直接执行。

<!-- question-id: q-7c67dc6a721d -->
###### 工具调用格式非法、参数错误、超时或失败时，Agent 如何容错？

我会把工具调用拆成「决策 \-\> 校验 \-\> 执行 \-\> 确认 \-\> 恢复」五个阶段，每个阶段使用不同的处理方式。

模型选错工具、JSON 不合法或缺少参数时，先用结构化输出和 Schema 拦截，再把明确的校验错误交给模型重生成。参数满足 Schema 后，服务端还要检查业务约束、用户身份、工具权限和风险级别，不能信任模型自己判断权限。

进入执行阶段后，我只对限流、连接失败和部分 5xx 这类瞬时故障做有界重试，并同时满足三个条件：调用可以安全重放、总时间预算还有余量、重试次数没有超限。退避要加抖动，遇到 `Retry-After` 就尊重服务端建议。参数错误、权限不足和明确的业务失败应该修参数、重新规划或询问用户，不能原样重试。

付款、发邮件、创建订单这类工具还要处理「结果未知」。我会在第一次调用前生成幂等键并写入 Checkpoint，重试和恢复时复用同一个键；超时后先按幂等键查询状态，确认没有执行再决定是否重试。查不清时暂停任务并转人工，避免重复副作用。

系统还需要熔断、降级、故障转移和统一的结构化错误。Trace 里记录每次调用的工具版本、参数摘要、耗时、重试决策、幂等键摘要和最终状态，敏感参数要脱敏，方便告警、复盘和审计。

<!-- question-id: q-55d7e6f331ac -->
###### 为什么要把 Agent 的工具执行流程封装成 CLI？

封装成 CLI，主要是为了让工具流程能够独立运行，并被不同调用方复用。业务逻辑与聊天状态分开以后，同一套能力既能给 Agent 调用，也能给开发者调试、脚本和定时任务使用，不需要每次都启动整个 Agent 应用。

另一个好处是便于调试和自动化。CLI 有明确的参数、结果和退出状态，工具出错时，可以拿对应输入和环境单独运行，检查是工具本身的问题，还是 Agent 选错了工具、传错了参数。机器调用时，还可以把结构化结果与诊断日志分开，避免靠终端里一句「成功」判断业务是否完成。

流程里已经确定的步骤，也可以由工具代码统一组织。模型负责选择工具和填写参数，宿主负责启动 CLI、接收结果，再交回模型，内部步骤就不用每次重新编排。

不过，CLI 会增加进程启动、数据传递和部署成本，也不会自动提供权限隔离。它更适合需要独立运行、多入口复用的工具流程；只在当前程序里使用的小函数，直接调用通常更合适。

<!-- question-id: q-c186351e07fa -->
###### Agent 接入工具时应该如何选择 CLI 或 MCP？

主要看调用方的接入需求和维护成本。CLI 提供命令行执行入口，MCP 约定客户端与服务端怎样发现和调用能力，两者可以组合，不一定要互相替换。

如果只有一个可控的 Agent 宿主，已经有稳定的 CLI，直接适配通常更简单：宿主维护工具说明，把模型生成的参数转换成命令参数，再解析执行结果。如果一项能力要被多个兼容 MCP 的宿主复用，MCP 就更有价值，工具描述、参数结构和调用方式可以通过统一协议提供，减少重复接入。

已有 CLI 可以由 MCP Server 包装，业务逻辑继续复用。部署位置则要单独考虑：MCP 能通过 stdio 连接本地进程，也能通过 Streamable HTTP 提供网络服务；CLI 本身也可以访问远程 API。最终还要比较依赖安装、版本维护、调用开销和权限管理，不能只按「本地用 CLI、远程用 MCP」来选。

<!-- question-id: q-42f21edd1e3c -->
###### Agent 的代码执行沙箱应该如何设计？

核心是让代码只拿到当前任务需要的权限，并把资源消耗限制在预算里。模型生成的代码要按不可信代码处理，不能只靠 Prompt 约束，也不应该直接继承宿主的全部权限。

执行环境可以只提供本次任务的输入，把输入设为只读，给临时目录和输出目录写权限，用低权限身份运行。网络按需开放，宿主凭据和管理接口不交给代码。资源限制则要覆盖 CPU、内存、进程数量和运行时间，并作用于整个任务的进程集合，而不只是启动的那个进程。

容器可以作为实现，但需要检查挂载、权限和网络配置，而且普通 Linux 容器共享宿主内核。面对任意用户代码或更高的隔离要求，可以评估虚拟机等更强边界，同时考虑启动成本和兼容性。

任务由沙箱外的运行器管理：准备输入，启动受限执行，超时或取消时终止整个执行单元，核对并导出允许的产物，最后清理环境。沙箱负责限制代码的影响范围，结果是否符合业务要求，还要另外验证。

<!-- question-id: q-95168edbe3f7 -->
###### Agent 的 Skill 加载机制是如何实现的？

Skill 通常采用渐进式加载。宿主先发现可用的能力包，读取 [SKILL\.md](http://skill.md/) 里的名称和描述，形成一份轻量目录。模型根据任务和描述判断需要哪个 Skill，或者由用户明确指定，再把对应正文读进上下文。

正文提供操作步骤，详细参考、模板和脚本留在包里，执行到需要它们的步骤时再取用。这样模型先知道有哪些能力，用到时才读具体方法，不需要启动就加载所有手册和资源。

这里的加载主要是在补充模型当前的工作信息，不会更新模型参数，也不等于执行脚本。脚本仍然要通过工具调用，由宿主检查参数和权限后运行。文件发现、正文读取和上下文维护由宿主完成，所以安装了 Skill，不代表模型已经读到了它，更不代表相关操作已经发生。



---



## 通用面试题

| 问题 | 回答要点 | 状态 |
| --- | --- | --- |
| 请介绍你最熟悉的项目 | 待补充 | 待整理 |
| 你最有挑战的一项工作是什么 | 待补充 | 待整理 |
| 如何证明效果提升来自你的改动 | 待补充 | 待整理 |
| 如果重新设计，你会调整什么 | 待补充 | 待整理 |

#### 请介绍你最熟悉的项目

##### 快速回顾

待补充。

##### 面试主回答

待补充。

#### 你最有挑战的一项工作是什么

##### 快速回顾

待补充。

##### 面试主回答

待补充。

#### 如何证明效果提升来自你的改动

##### 快速回顾

待补充。

##### 面试主回答

待补充。

#### 如果重新设计，你会调整什么

##### 快速回顾

待补充。

##### 面试主回答

待补充。

#### Agent 项目综合面试

围绕养老知识服务平台和农机设备智能运维平台，集中复习个人职责、查询链路、任务澄清、Agent Loop、工具调用、上下文管理和 RAG 评测。养老项目重点讲可靠检索与证据溯源，农机项目重点讲专业知识、实时业务数据与任务执行。

##### 快速回顾

| 问题 | 回答主线 | 项目例子 |
| --- | --- | --- |
| 个人职责 | 业务问题、负责模块、关键机制和结果 | 养老检索评测；农机业务工具与视觉检索 |
| Query 到结果 | 请求、上下文、模型决策、工具执行和结果生成 | 政策检索；设备故障排查与调度 |
| 需求模糊 | 找出关键缺口，逐步澄清并保存约束 | 补贴申请地区；作业对象和时间 |
| Agent Loop | 消息与结构化状态共同推进，按进展和预算停止 | 政策对比；业务执行回执 |
| 多工具选择 | 清晰边界、按场景筛选、参数与业务校验 | 检索与原文读取；草案与执行 |
| 长上下文 | 对话背景、任务状态和证据分别管理 | 滑动窗口、摘要和历史记忆 |
| 历史压缩 | 完整记录外置，保留约束、进展和来源 | 政策必要条件；草案版本与确认 |
| RAG 评测 | 检索、回答和成本分层评估，沿错误位置优化 | 混合检索；页面视觉检索 |

##### 职责与完整链路

<!-- question-id: q-3eff7598a5ea -->
###### Agent 项目你主要负责哪些部分？

面试回答：

我在两个项目中的工作，主要围绕知识检索和 Agent 工具调用展开。

养老知识服务平台里，我负责文档入库、检索链路和离线评测，并参与 Agent 查询流程设计。核心问题是让系统找到适用政策，并给出可核对的依据。我采用 Parent-Child Chunk 保留完整条款，通过 BM25、BGE-M3、RRF 和重排改善证据召回与排序，同时结合政策版本、有效期和权限筛选资料。基于 200 余道离线题，Recall@10 从 0.71 提升到 0.89，MRR@10 从 0.62 提升到 0.78。

农机设备智能运维平台里，我参与后端业务和大模型应用开发，重点是让 Agent 结合专业资料与实时业务数据完成任务。我负责文档处理与视觉检索，参与业务工具、工作流和记忆实现，并接入图像识别及 MCP。比如准备调度方案时，Agent 查询设备和任务，后端检查资源、权限及时间冲突，方案冻结并取得审批或明确委托后再执行，记录真实业务回执与审计。

实现细节：

项目细节入口：

- [养老项目：背景、职责与评测结果](https://fupan.270102.xyz/internship/overview.html)。
- [农机项目：背景、职责与评测结果](https://fupan.270102.xyz/platform/overview.html)。

<!-- question-id: q-7618b0b1cd08 -->
###### 从用户输入 Query 到最终返回结果，经过哪些核心模块？哪些部分是自己实现的？

面试回答：

整个链路包括请求处理、上下文装配、任务决策、工具执行和结果生成。

后端首先建立用户身份和访问范围，加载当前问题、近期对话及任务状态，明确用户目标和必要条件。模型根据这些信息，选择补问、调用工具或者生成答案。工具执行器接收结构化调用，完成参数、权限、超时和预算检查，再调用检索服务或业务 Service。执行结果返回后，模型继续判断信息是否充分，直到完成任务。

养老项目的核心路径是：问题进入检索工具，BM25 和 BGE-M3 分别召回子块，经过 RRF 融合与重排，再回溯父块补齐上下文，核对政策版本和适用时间，生成带 Evidence ID、文档和页码的回答。

农机项目首轮同时理解请求并选择路径，简单查询直接取证，复杂调查由主助手或领域专家补查。例如故障排查先定位设备、查询维保记录，再检索并阅读同修订的手册页面；调度进入草案、冲突校验、冻结审批或明确委托及事务内执行复核，最终按真实回执发布结果。

我负责的实现主要是文档处理、检索链路、业务接口和相关校验，并参与 Agent 工具执行与上下文管理。模型侧接入 BGE-M3、Reranker、ColQwen 等能力，业务规则由后端统一实现。

实现细节：

项目细节入口：

- [养老项目：混合检索、融合、重排与版本过滤](https://fupan.270102.xyz/internship/hybrid-retrieval.html#q-51aee20be27b)。
- [养老项目：政策变化分析与证据溯源](https://fupan.270102.xyz/internship/policy-evidence.html)。
- [农机项目：从用户目标到工具查询、草案和业务执行](https://fupan.270102.xyz/platform/agent-workflow.html#q-aafac67a0c91)。

##### 任务理解与执行控制

<!-- question-id: q-2e83d61799fb -->
###### 如果用户需求比较模糊，Agent 怎么处理？

面试回答：

我会先判断缺少的信息会影响什么，再决定先查还是先问。优先澄清会改变检索范围、业务对象或者执行结果的关键条件。

例如养老项目中，用户问“老人能领什么补贴”，Agent 先明确地区和用户想了解的内容。定位到相关政策后，再根据申请条件补问年龄、照护等级等信息。这样每次提问都有明确用途，用户也容易回答。

农机项目中，用户说“帮我安排明天的作业”，需要补齐经营单元、作业类型、时间和资源要求；成本分析缺少期间时先澄清。用户说“上次那台机器”，先用近期背景，必要时通过 `memory.search` 找回历史线索，再查询当前设备，多个候选让用户确认。

确认后的信息进入结构化任务约束，后续查询和执行统一使用。能够提前完成的只读查询先做，影响业务写入的关键条件补齐后再推进。

实现细节：

项目细节入口：

- [养老项目：ReAct 中的条件澄清与证据补查](https://fupan.270102.xyz/internship/agent-planning.html#q-78fd410028ea)。
- [农机项目：短期、长期及实体记忆](https://fupan.270102.xyz/platform/memory.html#q-b5ecc749f281)。
- [农机项目：业务工作流中的必要条件](https://fupan.270102.xyz/platform/agent-workflow.html#q-aafac67a0c91)。

<!-- question-id: q-7475daecf7c4 -->
###### Agent Loop 怎么实现？每轮模型调用和工具调用如何传递状态？连续多轮没有有效进展时怎么检测并终止？

面试回答：

Agent Loop 的核心是模型决策与工具执行交替推进：模型提出工具调用，执行器校验并执行，将结果交回模型，再决定下一步。

状态通过两条路径传递。消息上下文保存当前问题、必要历史、工具调用及对应结果，供模型理解；结构化任务状态保存目标、约束、计划步骤、已有证据、缺失项和累计预算，供执行器推进流程。每轮工具完成后，先更新结果与步骤状态，再装配下一轮上下文。

养老项目中，普通查询通过 ReAct 动态补查，政策变化分析则用 Plan-and-Execute 管理版本定位、条款提取和差异比较，每个步骤内部按需使用 ReAct。

农机项目由 AgentScope 承载 ReAct，固定动作在函数内部使用 Graph Workflow，严格 P&E 由 Backend 冻结步骤依赖并交给 Graph 调度。主助手可委派作业、维保、成本和知识专家，专家共享工具能力边界、期限和取消，结果回到父级统一核验与冻结。

检测无进展时，我会重点看相同范围内是否反复调用相同工具和参数、返回的文档版本和原文位置是否持续重复，以及未完成步骤和证据缺口是否减少。例如补贴标准已取得，缺的是材料清单，下一步就转向附件或材料要求。

持续无进展时，改换检索方向、请求补充，或关闭工具并用已有证据收尾。养老项目以任务调用、时间和 token 预算控制循环；农机项目区分片段调用容量、输入窗口和持久目标根有效期，累计配额默认只统计，显式开启后才约束持久目标。普通继续沿用检查点和已有约束，模型或业务效果未知时先核对，不自动重放。

实现细节：

项目细节入口：

- [养老项目：结构化计划与步骤状态](https://fupan.270102.xyz/internship/agent-planning.html#q-88d4c07776c3)。
- [养老项目：重复检索与证据增量判断](https://fupan.270102.xyz/internship/agent-planning.html#q-51a63214b157)。
- [养老项目：完成判断与执行预算](https://fupan.270102.xyz/internship/agent-planning.html#q-98d082aca9dc)。
- [农机项目：执行失败、重复请求与回执核对](https://fupan.270102.xyz/platform/agent-workflow.html#q-b39525d28ba3)。

<!-- question-id: q-79c6155faf64 -->
###### Agent 需要调用十几个工具时，如何提高选择准确率？功能重叠和错误参数怎么处理？

面试回答：

我会从工具边界、候选范围和执行反馈三个方面处理。

工具边界要让模型容易区分。养老项目中，知识检索负责找证据，原文读取负责取得完整条款，版本查询负责定位适用文件。农机项目中，设备查询、冲突检查、动作函数内准备草案及 Backend 授权提交分别承担明确的职责。

扩展到十几个工具时，我会按任务场景和用户权限筛选当前可用集合。知识问答提供检索和原文读取，调度再提供设备、人员、任务及冲突检查。农机项目首轮冻结必要工具集合，专家还受领域清单、委派工具和当前启停限制；每次调用仍复核当前权限。模型在当前相关的工具中选择，描述和 Schema 也更容易保持清晰。

功能重叠时，优先合并重复能力；需要保留的工具明确输入、输出和调用时机。例如检索负责返回候选，原文读取负责取得可用证据；独立知识问答综合答案，Agent 内部则由当前执行器统一综合。外部 MCP 提供八项用户授权只读工具，其能力取当前业务权限、客户端同意及固定工具的交集。

参数校验分两层：Schema 检查必填项、字段类型和枚举，业务层检查资源、时间、状态及权限。错误反馈包含具体字段、原因和修正要求，让模型在剩余预算内重新提交。写操作进一步核对冻结指纹、审批或委托和幂等标识，保证执行内容与授权一致。范围委托仅限新建作业，其他业务动作绑定精确冻结方案。

实现细节：

项目细节入口：

- [养老项目：工具定义与模型选择](https://fupan.270102.xyz/internship/agent-planning.html#q-f4d373bc2112)。
- [农机项目：业务工具、参数和执行约束](https://fupan.270102.xyz/platform/agent-workflow.html#q-d15122b6b650)。
- [农机项目：MCP 工具定义与客户端选择](https://fupan.270102.xyz/platform/image-recognition-mcp.html#q-80f7a21f27a4)。

##### 上下文、历史压缩与评测

<!-- question-id: q-3a6b2c561386 -->
###### Agent 项目中，你如何管理长上下文？

面试回答：

我把上下文分成对话背景、任务状态和证据，分别管理，再按当前任务装配。

对话背景使用滑动窗口保留近期消息，较早内容压缩为历史摘要；任务目标、地区、时间、设备 ID 和计划步骤结构化保存；证据保留文档版本、页码和 Evidence ID，按问题加载相关片段。

上下文优先放入当前问题、最新约束、当前步骤和必要证据，再补充近期对话与相关历史。预算覆盖系统协议、工具 Schema、消息结构和工具返回，并预留输出空间；没有可用 Tokenizer 元数据时使用保守输入估算，实际供应商用量另行记录。

养老项目主要通过滑动窗口和历史摘要控制对话长度，计划与证据单独跟踪。农机项目用 MySQL 保存消息、摘要、情景和显式画像，Redis 缓存带版本的近期消息，Qdrant 保存可重建记忆投影。首轮只装配有界摘要、近期规范消息和显式偏好，历史不足时按层调用 `memory.search`；召回后检查来源权限、版本和时间。

例如用户问“上次那台收割机修好了吗”，记忆负责找回设备和讨论背景，业务工具负责查询当前维修进展，两类信息共同支持回答。

实现细节：

项目细节入口：

- [养老项目：上下文裁剪与预算装配](https://fupan.270102.xyz/internship/agent-planning.html#q-f72a64172e9a)。
- [农机项目：MySQL、Redis 和 Qdrant 的分工](https://fupan.270102.xyz/platform/memory.html#q-5ef829c6a819)。
- [农机项目：长期记忆召回与权限检查](https://fupan.270102.xyz/platform/memory.html#q-75a4c1b9012c)。

<!-- question-id: q-6e080e80ff99 -->
###### 一个任务调用几十次工具、历史信息超出上下文窗口时，如何压缩并保留关键信息？

面试回答：

我的处理方式是把完整记录外置，把当前任务必需的信息留在上下文。

长工具结果保存为可回查记录，上下文保留相关片段、结果标识和关键结论。例如查询返回几十台设备，模型当前需要的是候选设备、淘汰原因和关键字段，其余内容按需读取。

较早的执行过程压缩成结构化进展，保留用户目标、约束条件、已完成步骤、确认事实及来源、未解决问题和下一步。农机运行内移除完整旧工具交换，不额外调用模型压缩；跨轮语义摘要在后台生成，冻结方案、授权、checkpoint 和真实回执独立持久化。

关键约束独立保存。养老项目中的地区、政策时间和申请对象，农机项目中的资产 ID、作业时间和资源要求，每轮都按当前值加载。用户修改条件后，同步检查已有证据是否适用。农机恢复还会刷新过期读取，证据指纹变化只失效相关结论、草案及后继步骤，保留无关成果。

证据压缩重点保留影响结论的数值、单位、适用条件、例外和引用位置。例如“通过失能等级评估后可以申请”，压缩后仍要保留评估条件。表格和操作图保留页面关联，需要时读取原页。

压缩完成后，检查约束、缺失项和证据来源是否齐全，同时保持工具调用与返回对应。原轮上下文按用户消息上界冻结，再生成或恢复沿用原快照并过滤失权来源；断线恢复持久状态和已发布正文，继续持久目标才按检查点推进。

实现细节：

项目细节入口：

- [养老项目：摘要中的关键条件与来源](https://fupan.270102.xyz/internship/agent-planning.html#q-b571d44affb4)。
- [养老项目：父块超过上下文预算时的处理](https://fupan.270102.xyz/internship/parent-child-chunk.html)。
- [农机项目：短期记忆与结构化执行状态](https://fupan.270102.xyz/platform/memory.html#q-c8e2cc3d0ac2)。
- [农机项目：草案版本、用户确认与执行](https://fupan.270102.xyz/platform/agent-workflow.html#q-c8eba6350dab)。

<!-- question-id: q-a2bc84b24f79 -->
###### RAG 的效果如何评估和优化？

面试回答：

我按检索质量、回答质量和运行成本三层评估，再根据错误所在环节优化。

检索评测先建立标准证据。养老项目整理了 200 余道题，覆盖精确条款、口语表达、多条件和政策版本问题，标注支持答案的文档版本及原文范围。农机项目按证据页标注，覆盖文字参数、表格、结构图和跨页内容。

指标上，Recall@10 衡量前十条结果的证据覆盖，MRR@10 衡量第一条正确结果的位置，NDCG@10 衡量高相关证据的整体排序。回答侧检查事实、条件、完整性和引用支持；运行侧记录检索、证据加载与生成耗时，以及 token 和模型调用成本。

优化时，我会沿链路定位问题。证据没有进入候选集，检查文档解析、分块、查询表达和召回通道；证据进入候选集但排名靠后，调整融合、候选数量和重排；证据排在前面但回答缺条件，检查父块回溯、跨页内容和上下文裁剪；证据充分但答案有误，检查模型对数值、适用条件和引用的理解。

养老项目通过父子分块、混合召回、RRF 和重排改善检索，Recall@10 从 0.71 提升到 0.89，MRR@10 从 0.62 提升到 0.78，体现了证据覆盖和首条正确证据排序的改善。

农机项目重点处理手册中的图表和版面信息，通过页面渲染、MinerU 补充 OCR 和 ColQwen 视觉检索保留图文关系，Recall@10、MRR@10、NDCG@10 分别达到 0.945、0.798 和 0.839。

进一步分析组件贡献时，我会固定语料、题集和其他配置，分别对比单路召回、混合召回、重排与分块方案，让每次调整对应一个明确的效果判断。

实现细节：

项目细节入口：

- [养老项目：测评集构建与标准证据](https://fupan.270102.xyz/internship/hybrid-retrieval.html#q-d1418839f3a8)。
- [养老项目：整体改进与组件对照](https://fupan.270102.xyz/internship/hybrid-retrieval.html#q-4ad77f37e66d)。
- [农机项目：证据页标注与题型覆盖](https://fupan.270102.xyz/platform/visual-retrieval.html#q-5b7dfea9cbcc)。
- [农机项目：Recall、MRR 与 NDCG 的计算](https://fupan.270102.xyz/platform/visual-retrieval.html#q-67f0502a4555)。

##### 易混点与回答检查

复习时按问题目标选择重点：长上下文管理讲整体组织与装配，历史压缩讲一次长任务如何保留约束、进展和来源；Loop 讲状态推进与停止条件，工具选择讲能力边界与执行校验。

- [ ] 能分别说明养老项目与农机项目的职责、关键机制和结果。
- [ ] 能从 Query 讲到检索、业务工具、模型判断和最终输出。
- [ ] 能用补贴申请与作业调度举例，说明澄清的条件及保存方式。
- [ ] 能说明 Loop 的消息、任务状态、进展判断和累计预算。
- [ ] 能区分工具适用场景，并解释参数、权限与写入校验。
- [ ] 能说明长上下文的组织方式，以及历史压缩保留的信息。
- [ ] 能解释三项检索指标，并按错误位置提出优化方案。
## 待核实事项

- 两段经历中本人独立负责、协作完成和仅了解的具体边界。
- 简历所列检索指标的评测集、基线、参数和实验记录。
- 项目中各技术组件与简历描述的实际对应关系。
- 业务规模、数据规模、耗时或成本等尚未在简历中给出依据的数字。
