Files
memoryweave/go/internal/storage/embedder.go
T
hermes 9d9b92df27 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×)。
2026-09-27 00:57:39 +08:00

182 lines
4.9 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package storage
import (
"bytes"
"encoding/json"
"fmt"
"io"
"math"
"net/http"
"os"
"strconv"
"sync"
"time"
)
// Embedder bge-m3 编码客户端。优先使用本地 vLLM(端口 8000),fallback 到模力方舟 API。
type Embedder struct {
endpoint string // 本地 vLLM: http://localhost:8000/v1/embeddings
modelName string // 模型名,默认 bge-m3,可通过 MODEL_NAME 覆盖
apiKey string // 模力方舟 API key(fallback 用)
httpClient *http.Client
cache sync.Map // string → []float32
dim int
}
// NewEmbedder 创建编码客户端。endpoint 默认为本地 vLLM。
func NewEmbedder(endpoint string) *Embedder {
if endpoint == "" {
endpoint = os.Getenv("VLLM_ENDPOINT")
if endpoint == "" {
endpoint = "http://localhost:8000/v1/embeddings"
}
}
return &Embedder{
endpoint: endpoint,
modelName: getModelName(),
apiKey: os.Getenv("MOLIFANG_API_KEY"),
httpClient: &http.Client{Timeout: 8 * time.Second},
dim: 1024,
}
}
// getModelName 获取模型名,优先 MODEL_NAME 环境变量,默认为 bge-m3
func getModelName() string {
if m := os.Getenv("MODEL_NAME"); m != "" {
return m
}
return "bge-m3"
}
func (e *Embedder) Encode(texts []string) ([][]float32, error) {
// 检查缓存
result := make([][]float32, len(texts))
uncached := make([]int, 0)
for i, t := range texts {
if v, ok := e.cache.Load(t); ok {
result[i] = v.([]float32)
} else {
uncached = append(uncached, i)
}
}
if len(uncached) == 0 {
return result, nil
}
// 收集未缓存的文本
uncachedTexts := make([]string, len(uncached))
for idx, i := range uncached {
uncachedTexts[idx] = texts[i]
}
// 优先本地 vLLM
vectors, err := e.encodeRemote(e.endpoint, uncachedTexts)
if err != nil {
// fallback:模力方舟
if e.apiKey != "" {
vectors, err = e.encodeRemote("https://ai.gitee.com/v1/embeddings", uncachedTexts)
}
if err != nil {
return nil, fmt.Errorf("encode: all endpoints failed: %w", err)
}
}
// L2 归一化 + 缓存
for idx, i := range uncached {
normalized := l2Normalize(vectors[idx])
result[i] = normalized
e.cache.Store(texts[i], normalized)
}
return result, nil
}
// EncodeSingle 编码单条文本。
func (e *Embedder) EncodeSingle(text string) ([]float32, error) {
vecs, err := e.Encode([]string{text})
if err != nil {
return nil, err
}
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{
"model": e.modelName,
"input": texts,
}
body, _ := json.Marshal(reqBody)
req, _ := http.NewRequest("POST", endpoint, bytes.NewReader(body))
req.Header.Set("Content-Type", "application/json")
if e.apiKey != "" {
req.Header.Set("Authorization", "Bearer "+e.apiKey)
}
resp, err := e.httpClient.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
rbody, _ := io.ReadAll(resp.Body)
return nil, fmt.Errorf("embedding API: status %d: %s", resp.StatusCode, string(rbody))
}
var result struct {
Data []struct {
Embedding []float64 `json:"embedding"`
} `json:"data"`
}
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
return nil, fmt.Errorf("decode embedding response: %w", err)
}
vectors := make([][]float32, len(result.Data))
for i, d := range result.Data {
vectors[i] = make([]float32, len(d.Embedding))
for j, v := range d.Embedding {
vectors[i][j] = float32(v)
}
}
return vectors, nil
}
// l2Normalize L2 归一化。
func l2Normalize(v []float32) []float32 {
var sum float64
for _, x := range v {
sum += float64(x) * float64(x)
}
norm := float32(math.Sqrt(sum))
if norm == 0 {
return v
}
result := make([]float32, len(v))
for i, x := range v {
result[i] = x / norm
}
return result
}