diff --git a/go/internal/api/routes/core.go b/go/internal/api/routes/core.go index c92e6d9..6146769 100644 --- a/go/internal/api/routes/core.go +++ b/go/internal/api/routes/core.go @@ -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()}) diff --git a/go/internal/storage/embedder.go b/go/internal/storage/embedder.go index 9ba1f7d..64efa87 100644 --- a/go/internal/storage/embedder.go +++ b/go/internal/storage/embedder.go @@ -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{ diff --git a/go/internal/storage/recall.go b/go/internal/storage/recall.go index f9dd02e..68807f3 100644 --- a/go/internal/storage/recall.go +++ b/go/internal/storage/recall.go @@ -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)) diff --git a/go/internal/storage/reranker.go b/go/internal/storage/reranker.go index 2f640af..1003479 100644 --- a/go/internal/storage/reranker.go +++ b/go/internal/storage/reranker.go @@ -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) }