perf(recall): 向量重排 + 查询截断 —— 修掉 Hermes 记忆预取 8s 超时

根因(/api/v1/recall/debug 分阶段实测,2026-09-28):
  query=60 字  → total 2268ms(encode 39 / ann 188 / rerank 2039 / mmr 0)
  query=1200字 → total 9980ms(encode 1441 / ann 189 / rerank 8001 / mmr 347)
  query=4000字 → encode 一步就 8000ms
rerank 占 90%+:旧实现(localCosineRerank)把 query + 50~100 条候选文档重新送进
int8 ONNX CPU 嵌入服务,而这些向量调用方本来就有(queryVec 来自 Step1,
LanceDB 返回的 MemoryRecord 自带 Vector)。

修复:
1. Reranker.RerankWithVectors —— 用已有向量直接算 cosine(向量不齐则回退文本路径);
   recall 管线与 /recall/debug 同步改用。
2. Embedder.EncodeQuery —— query 侧向量化前按 512 字符截断(RECALL_QUERY_MAX_RUNES 可覆盖),
   保护超长 query 的时延;关键词/BM25 路径仍用完整 query。
3. apiRerank 失败不再静默(log 出降级原因)。

实测(同机复验):60字 2268→235ms;1200字 9980→567ms;2000字 16571→547ms;4000字 8000+→502ms。
真实插件路径 prefetch:短 query 1.00s、3000 字长 query 1.25s(预算 8s,余量 6.4×)。
This commit is contained in:
hermes
2026-09-27 00:57:39 +08:00
parent 7904a238ed
commit 9d9b92df27
4 changed files with 139 additions and 7 deletions
+12 -4
View File
@@ -395,7 +395,7 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
// E4.2: 跨 agent 知识共享 — recall 结果在 (0, top_k) 时,补充搜索 "shared" namespace
if len(results) > 0 && len(results) < 3 && req.Namespace != "shared" && req.Namespace != "" {
vec, encErr := a.Embedder.EncodeSingle(req.Query)
vec, encErr := a.Embedder.EncodeQuery(req.Query)
if encErr == nil {
shared, _ := a.LanceDB.Search("memories", vec, 5, "shared")
for _, m := range shared {
@@ -424,7 +424,7 @@ func (a *API) Recall(w http.ResponseWriter, r *http.Request) {
// req.Namespace/shared ⇒ 33+ 条笔记知识长期在盲区(召回永远看不到)。
// 这里补搜:主结果不足 top_k 时,从额外命名空间补齐(去重 + 降权 0.45)。
if req.Namespace != "wiki-curator-main" && req.Namespace != "" {
if vec, encErr := a.Embedder.EncodeSingle(req.Query); encErr == nil {
if vec, encErr := a.Embedder.EncodeQuery(req.Query); encErr == nil {
for _, extra := range []string{"wiki-curator-main"} {
extraHits, _ := a.LanceDB.Search("memories", vec, 5, extra)
for _, m := range extraHits {
@@ -560,7 +560,7 @@ func (a *API) RecallDebug(w http.ResponseWriter, r *http.Request) {
// Step 1: 编码
t1 := time.Now()
queryVec, err := a.Embedder.EncodeSingle(req.Query)
queryVec, err := a.Embedder.EncodeQuery(req.Query)
encodeTime := time.Since(t1).Milliseconds()
if err != nil {
steps = append(steps, stepInfo{"encode", "error", encodeTime, err.Error()})
@@ -599,12 +599,20 @@ func (a *API) RecallDebug(w http.ResponseWriter, r *http.Request) {
steps = append(steps, stepInfo{"ann_search", "ok", annTime, fmt.Sprintf("%d candidates from %d namespaces", len(candidates), len(nsList))})
// Step 3: Rerank
// 2026-09-28:与 RecallPipeline 一致 —— 用已有向量(queryVec + 候选自带 Vector)
// 做 cosine,不再把候选文档重新送进嵌入服务。这是 recall 总耗时 90%+ 的那一段,
// 也是预取 8s 预算被打爆的根因;诊断端点必须如实反映生产行为,故同步改。
t3 := time.Now()
docs := make([]string, len(candidates))
docVecs := make([][]float32, len(candidates))
for i, c := range candidates {
docs[i] = c.Content
docVecs[i] = c.Vector
}
reranked, rErr := a.Reranker.RerankWithVectors(queryVec, docs, docVecs, req.Limit*2)
if rErr != nil {
reranked, rErr = a.Reranker.Rerank(req.Query, docs, req.Limit*2)
}
reranked, rErr := a.Reranker.Rerank(req.Query, docs, req.Limit*2)
rerankTime := time.Since(t3).Milliseconds()
if rErr != nil {
steps = append(steps, stepInfo{"rerank", "fallback", rerankTime, rErr.Error()})
+22
View File
@@ -8,6 +8,7 @@ import (
"math"
"net/http"
"os"
"strconv"
"sync"
"time"
)
@@ -97,6 +98,27 @@ func (e *Embedder) EncodeSingle(text string) ([]float32, error) {
return vecs[0], nil
}
// recallQueryMaxRunes 查询向量化长度上限(默认 512 字符;RECALL_QUERY_MAX_RUNES 覆盖)。
//
// 实测(2026-09-28):嵌入服务是 int8 ONNX CPU,耗时随文本长度**超线性**增长
// (500 字 0.33s / 2000 字 3.9s / 6000 字 31.8s)。而 Hermes 的记忆预取只有 8s 预算,
// 4000 字的长查询光"向量化"一步就要 8.0s → 预取必然超时(每轮会话丢一次记忆注入)。
// 查询侧截断对语义检索无损(长查询的长尾多是噪声/日志粘贴),关键词与 BM25 路径
// 仍使用完整 query,不受影响。
const recallQueryMaxRunes = 512
// EncodeQuery 向量化"查询"文本:先按字符截断再编码,保护 recall 时延。
// 仅用于 query 侧;文档/记忆内容编码请继续用 Encode / EncodeSingle。
func (e *Embedder) EncodeQuery(text string) ([]float32, error) {
limit := recallQueryMaxRunes
if v := os.Getenv("RECALL_QUERY_MAX_RUNES"); v != "" {
if n, err := strconv.Atoi(v); err == nil {
limit = n
}
}
return e.EncodeSingle(truncateRunes(text, limit))
}
// encodeRemote 调用远端 OpenAI 兼容 embeddings API。
func (e *Embedder) encodeRemote(endpoint string, texts []string) ([][]float32, error) {
reqBody := map[string]any{
+12 -2
View File
@@ -100,7 +100,7 @@ func (p *RecallPipeline) recallUncached(query, namespace string, topK int, diver
}
// Step 1: Encode query
queryVec, err := p.embedder.EncodeSingle(query)
queryVec, err := p.embedder.EncodeQuery(query)
if err != nil {
return nil, RecallMeta{}, fmt.Errorf("recall encode: %w", err)
}
@@ -201,11 +201,21 @@ func (p *RecallPipeline) recallUncached(query, namespace string, topK int, diver
}
// Step 3: Rerank to top_k (graceful fallback)
// 2026-09-28:优先用「已有向量」重排 —— queryVec 来自 Step 1,候选记录自带 LanceDB
// 存储的 Vector,直接算 cosine 即可。旧实现把 query + 50~100 条候选文档重新送进
// 嵌入服务(int8 ONNX CPU),占 recall 总耗时 90%+,是 Hermes 记忆预取 8s 预算
// 被打爆的直接原因。向量不齐/维度不符时自动回退文本重排(行为与旧版一致)。
docs := make([]string, len(candidates))
docVecs := make([][]float32, len(candidates))
for i, c := range candidates {
docs[i] = c.Content
docVecs[i] = c.Vector
}
reranked, err := p.reranker.RerankWithVectors(queryVec, docs, docVecs, topK*2)
if err != nil {
log.Printf("[recall] 向量重排跳过(%v),回退文本重排", err)
reranked, err = p.reranker.Rerank(query, docs, topK*2)
}
reranked, err := p.reranker.Rerank(query, docs, topK*2)
if err != nil {
// 重排不可用时降级:直接使用向量搜索的原始排序
reranked = make([]models.RerankResult, len(candidates))
+93 -1
View File
@@ -5,10 +5,12 @@ import (
"encoding/json"
"fmt"
"io"
"log"
"math"
"net/http"
"os"
"sort"
"strconv"
"strings"
"time"
@@ -48,6 +50,33 @@ func (r *Reranker) SetEmbedder(emb *Embedder) {
r.embedder = emb
}
// rerankQueryMaxRunes 限制送入重排的 query 长度(默认 256 字符)。
//
// 实测依据(2026-09-28,/api/v1/recall/debug 分阶段耗时):
//
// query=60 字 → total 2268ms(encode 39 / ann 188 / rerank 2039 / mmr 0)
// query=1200 字 → total 9980ms(encode 1441 / ann 189 / rerank 8001 / mmr 347)
//
// rerank 占 90%+ 且随 query 长度放大 —— 本轮链路里 RERANK_ENDPOINT(127.0.0.1:8001)
// 没有 /rerank 路由,apiRerank 必然 404,实际走 localCosineRerank(对 query 与
// 全部候选文档逐个编码)。超长 query 既让编码变慢、纯向量 top_score 也退化到 0.5
// (重排实际失效)。截断后语义不损失(cross-encoder/向量检索对超长 query 无增益),
// 且这一档正是 Hermes 记忆预取 8s 预算被打爆的那一档。
// 覆盖:RERANK_QUERY_MAX_RUNES 环境变量(正整数,<=0 表示不截断)。
const rerankQueryMaxRunes = 256
// truncateRunes 按字符(rune)截断,避免把 UTF-8 汉字切坏。
func truncateRunes(s string, limit int) string {
if limit <= 0 {
return s
}
r := []rune(s)
if len(r) <= limit {
return s
}
return string(r[:limit])
}
// Rerank 对候选文档重排,返回 top_n 条最相关结果。
// 优先级:1. 模力方舟 API(cross-encoder,高精度)2. 本地 cosine(零延迟)3. 降级 score=0.5
func (r *Reranker) Rerank(query string, documents []string, topN int) ([]models.RerankResult, error) {
@@ -55,12 +84,22 @@ func (r *Reranker) Rerank(query string, documents []string, topN int) ([]models.
return nil, nil
}
// query 长度上限(见 rerankQueryMaxRunes 注释)
limit := rerankQueryMaxRunes
if v := os.Getenv("RERANK_QUERY_MAX_RUNES"); v != "" {
if n, err := strconv.Atoi(v); err == nil {
limit = n
}
}
query = truncateRunes(query, limit)
// 1. 优先:模力方舟 API rerank
if r.apiKey != "" {
results, err := r.apiRerank(query, documents, topN)
if err == nil {
return results, nil
}
log.Printf("[rerank] API 重排不可用(%v),降级本地 cosine", err)
}
// 2. 后备:本地 cosine rerank
@@ -79,9 +118,62 @@ func (r *Reranker) Rerank(query string, documents []string, topN int) ([]models.
return results, nil
}
// RerankWithVectors 用调用方**已经持有**的向量做 cosine 重排,不碰嵌入服务。
//
// 为什么需要它(2026-09-28 分阶段实测 /api/v1/recall/debug):
//
// query=60 字 → total 2268ms(encode 39 / ann 188 / rerank 2039 / mmr 0)
// query=1200 字 → total 9980ms(encode 1441 / ann 189 / rerank 8001 / mmr 347)
//
// rerank 占了总耗时 90%+,而它做的事只是「query 与候选文档逐个算 cosine」——
// 却要为此把 query + 50~100 条候选文档**重新送进嵌入服务**(int8 ONNX CPU:
// 500 字 0.33s / 2000 字 3.9s / 6000 字 31.8s,随长度超线性)。而 callers 手里
// 本来就有向量:recall 第 1 步已为 ANN 算了 queryVec,LanceDB 返回的
// MemoryRecord 自带 Vector(bge-m3 1024 维、L2 归一化)。
//
// 因此:向量齐全时直接算 cosine(亚毫秒),任一候选缺向量则返回错误,
// 由调用方回退到 Rerank() 的文本路径(行为与旧版一致,不会静默丢结果)。
func (r *Reranker) RerankWithVectors(queryVec []float32, documents []string, docVecs [][]float32, topN int) ([]models.RerankResult, error) {
if len(documents) == 0 {
return nil, nil
}
if len(queryVec) == 0 {
return nil, fmt.Errorf("rerank: empty query vector")
}
if len(docVecs) != len(documents) {
return nil, fmt.Errorf("rerank: doc vector count %d != documents %d", len(docVecs), len(documents))
}
if topN <= 0 || topN > len(documents) {
topN = len(documents)
}
type scored struct {
idx int
score float64
}
scores := make([]scored, len(documents))
for i, dv := range docVecs {
if len(dv) != len(queryVec) {
return nil, fmt.Errorf("rerank: doc %d vector dim %d != query dim %d", i, len(dv), len(queryVec))
}
scores[i] = scored{idx: i, score: cosineScore(queryVec, dv)}
}
sort.SliceStable(scores, func(i, j int) bool { return scores[i].score > scores[j].score })
results := make([]models.RerankResult, 0, topN)
for i := 0; i < topN; i++ {
results = append(results, models.RerankResult{
Index: scores[i].idx,
Score: scores[i].score,
Text: documents[scores[i].idx],
})
}
return results, nil
}
// localCosineRerank 使用 Embedder 编码 query → 对每个 doc 的向量做 cosine
func (r *Reranker) localCosineRerank(query string, documents []string, topN int) ([]models.RerankResult, error) {
qVec, err := r.embedder.EncodeSingle(query)
qVec, err := r.embedder.EncodeQuery(query)
if err != nil {
return nil, fmt.Errorf("local rerank encode query: %w", err)
}