From 7ae7f7be67bd55dde25f65dc19ff4bb750804a85 Mon Sep 17 00:00:00 2001 From: Blizzard Date: Sat, 18 Jul 2026 12:47:55 +0800 Subject: [PATCH] =?UTF-8?q?feat(memory):=20=E8=AE=B0=E5=BF=86=E5=8F=AC?= =?UTF-8?q?=E5=9B=9E=E5=8A=A0=20Relevance=20=E2=80=94=E2=80=94=20Generativ?= =?UTF-8?q?e=20Agents=20=E6=89=93=E5=88=86=E8=A1=A5=E9=BD=90=E7=AC=AC?= =?UTF-8?q?=E4=B8=89=E9=A1=B9=20(P1)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 审计三真桩之一。记忆召回此前打分只有 Recency+Importance,缺 Relevance(对当前 任务的语义相关性)——注释写"待接 Milvus",但召回时甚至不知道当前问什么。 关键发现:dispatcher 注入点 fetchMemory(ctx,uid,_) 手上已有当前任务文本(b.query), 只是被 `_` 丢弃了。所以不是"接 Milvus"那么重,把 query 一路传下去 + 缓存嵌入即可。 设计(偏离注释的"接 Milvus"——用户偏好量小,不值当上向量库): - Profile 加 embedding 列(float32 小端打包存 bytea);Upsert 时对 value 向量化缓存 (value 没变不重算,失败留空不阻断)。 - memory 包定义 Embedder 小接口,gateway 注入 rag.Engine(复用同一控制面下发的 embedding 模型),不硬依赖 rag 内部;rag.Engine 加导出 Embed 方法。 - memory_get 工具加可选 query 入参;fetchMemory 停止丢弃 b.query 传下去。 - Get(ctx,uid,query):query 非空且 embedder 就绪 → embed(query) 对每条缓存向量 内存算余弦 → 三项打分 0.25R+0.35I+0.4Rel;否则回落两项(升级前行为)。 - 优雅降级贯穿:无 query/无 embedder/query 嵌入失败/行无向量 → 静默回落,绝不报错。 零 Milvus 依赖、零向量库同步问题、保住"没 embedding 也能跑"。 验证:单测(编解码往返/cosine 截0/三项模式相关性翻转顺序/降级返 nil)+ 端到端 (真 PG:写入即向量化、query=咖啡把低重要度的咖啡记忆翻到运动前面)。migration 加列已 live;embedding 复用 RAG 已验证基建。三模块 build/vet/test 全绿。 Co-Authored-By: Claude Opus 4.8 --- .../internal/eino/orchestrator.go | 5 +- sundynix-mcp-go/internal/mcp/gateway.go | 13 +- sundynix-mcp-go/internal/memory/rank_test.go | 6 +- .../internal/memory/relevance_e2e_test.go | 89 ++++++++++++ .../internal/memory/relevance_test.go | 84 +++++++++++ sundynix-mcp-go/internal/memory/store.go | 131 ++++++++++++++++-- sundynix-mcp-go/internal/memory/store_test.go | 2 +- sundynix-mcp-go/internal/rag/rag.go | 6 + 8 files changed, 314 insertions(+), 22 deletions(-) create mode 100644 sundynix-mcp-go/internal/memory/relevance_e2e_test.go create mode 100644 sundynix-mcp-go/internal/memory/relevance_test.go diff --git a/sundynix-dispatcher/internal/eino/orchestrator.go b/sundynix-dispatcher/internal/eino/orchestrator.go index 8700507..3537050 100644 --- a/sundynix-dispatcher/internal/eino/orchestrator.go +++ b/sundynix-dispatcher/internal/eino/orchestrator.go @@ -446,8 +446,9 @@ func evalLevel(r harness.Result) string { } // fetchMemory 经 MCP memory_get 工具召回用户常驻画像。 +// query = 当前任务/问题文本：传给 memory_get 按语义相关性（Relevance）优先召回；空则退回最近性+重要度。 // 工具不可用/超时/无 user_id 时返回空串，降级为无记忆推理（不阻断主流程）。 -func (o *Orchestrator) fetchMemory(ctx context.Context, userID, _ string) string { +func (o *Orchestrator) fetchMemory(ctx context.Context, userID, query string) string { if o.tools == nil || userID == "" { return "" } @@ -455,7 +456,7 @@ func (o *Orchestrator) fetchMemory(ctx context.Context, userID, _ string) string defer cancel() res, err := o.tools.CallTool(cctx, contract.ToolSubjectGo("memory_get"), &contract.ToolCall{ Tool: "memory_get", - Args: map[string]any{"user_id": userID}, + Args: map[string]any{"user_id": userID, "query": query}, }) if err != nil { log.Printf("[eino] memory_get unavailable for %s, degrade: %v", userID, err) diff --git a/sundynix-mcp-go/internal/mcp/gateway.go b/sundynix-mcp-go/internal/mcp/gateway.go index adbf0da..c597208 100644 --- a/sundynix-mcp-go/internal/mcp/gateway.go +++ b/sundynix-mcp-go/internal/mcp/gateway.go @@ -60,6 +60,11 @@ type toolDef struct { func NewGateway(b *sharedbus.Bus, m *memory.Store, h *history.Store, r *rag.Engine, pgDSN string) *Gateway { g := &Gateway{bus: b, memory: m, history: h, rag: r, pgDSN: pgDSN} + // 记忆 Relevance 复用 RAG 的 embedding（同一控制面下发的模型）：召回时对 query 算语义相关性。 + // rag.Engine 满足 memory.Embedder；未配置 embedding 时 memory 优雅回落两项打分。 + if m != nil && r != nil { + m.SetEmbedder(r) + } g.tools = g.buildRegistry() return g } @@ -98,7 +103,10 @@ func (g *Gateway) buildRegistry() map[string]toolDef { }, "memory_get": { cn: "记忆召回", desc: "召回当前用户的长期画像与偏好（称呼/职业/回答偏好等）。需要个性化、了解“我是谁”时调用。", - agent: true, agentName: "recall_user_memory", inject: []string{"user_id"}, handler: g.memoryGet, + agent: true, agentName: "recall_user_memory", + // query 可选：给了则按对当前任务的语义相关性优先召回（Relevance），不给则按最近性+重要度。 + params: []paramSpec{{Name: "query", Type: "string", Desc: "当前任务/问题文本，用于按相关性优先召回（可选）", Required: false}}, + inject: []string{"user_id"}, handler: g.memoryGet, }, "memory_upsert": { cn: "记忆写入", desc: "把关于用户的一条事实/偏好长期记住（如称呼、职业、回答偏好）。", @@ -223,7 +231,8 @@ func (g *Gateway) listTools() *contract.ToolResult { // memoryGet 召回某用户的常驻画像（已渲染为可注入 prompt 的多行文本）。 func (g *Gateway) memoryGet(ctx context.Context, call *contract.ToolCall) *contract.ToolResult { uid, _ := call.Args["user_id"].(string) - profile, err := g.memory.Get(ctx, uid) + query, _ := call.Args["query"].(string) // 可选：按对当前任务的语义相关性优先召回 + profile, err := g.memory.Get(ctx, uid, query) if err != nil { return &contract.ToolResult{OK: false, Error: "memory_get: " + err.Error()} } diff --git a/sundynix-mcp-go/internal/memory/rank_test.go b/sundynix-mcp-go/internal/memory/rank_test.go index a0ebdf8..9dbf842 100644 --- a/sundynix-mcp-go/internal/memory/rank_test.go +++ b/sundynix-mcp-go/internal/memory/rank_test.go @@ -12,12 +12,12 @@ func TestRankProfiles(t *testing.T) { {Key: "低重要久远", Value: "b", Importance: 2, LastSeenAt: now.AddDate(0, 0, -60)}, {Key: "中等", Value: "c", Importance: 5, LastSeenAt: now.AddDate(0, 0, -10)}, } - ranked := rankProfiles(rows, now, 0) + ranked := rankProfiles(rows, now, 0, nil) if ranked[0].Key != "高重要近期" || ranked[2].Key != "低重要久远" { t.Errorf("应按 Score 降序：高重要近期 > 中等 > 低重要久远，得 %s/%s/%s", ranked[0].Key, ranked[1].Key, ranked[2].Key) } // 截断 top-N - if got := rankProfiles(rows, now, 2); len(got) != 2 || got[0].Key != "高重要近期" { + if got := rankProfiles(rows, now, 2, nil); len(got) != 2 || got[0].Key != "高重要近期" { t.Errorf("top-2 截断错: %d 条 首=%s", len(got), got[0].Key) } // 原切片不被改动（rankProfiles 应 copy） @@ -42,7 +42,7 @@ func TestProfileScore_DefaultImportance(t *testing.T) { now := time.Now() // importance=0（旧/未评分）应按兜底 5 计，而不是 0（否则被不公平遗忘）。 p := Profile{Importance: 0, LastSeenAt: now} - got := profileScore(p, now) + got := profileScore(p, now, nil) want := wRecency*1.0 + wImportance*(defaultImportance/10) if got != want { t.Errorf("未评分行应用兜底 importance: got %v want %v", got, want) diff --git a/sundynix-mcp-go/internal/memory/relevance_e2e_test.go b/sundynix-mcp-go/internal/memory/relevance_e2e_test.go new file mode 100644 index 0000000..cf25a98 --- /dev/null +++ b/sundynix-mcp-go/internal/memory/relevance_e2e_test.go @@ -0,0 +1,89 @@ +package memory + +import ( + "context" + "hash/fnv" + "math" + "os" + "strings" + "testing" +) + +// detEmbedder：确定性伪嵌入(同文本同向量;含指定关键词的文本在对应维度更高)。 +// 只为端到端验证「本包代码路径」——Upsert 存向量 → Get 算余弦重排 —— 对真 PG， +// 不打真 embedding 网络(那是 rag 包已验证的复用基建)。 +type detEmbedder struct{} + +func (detEmbedder) Embed(_ context.Context, texts []string) ([][]float32, error) { + const dim = 16 + kw := []string{"咖啡", "coffee", "运动", "健身", "音乐"} + out := make([][]float32, len(texts)) + for i, t := range texts { + v := make([]float32, dim) + for _, w := range kw { + if strings.Contains(t, w) { + h := fnv.New32a() + _, _ = h.Write([]byte(w)) + v[h.Sum32()%dim] += 1 + } + } + var n float64 + for _, x := range v { + n += float64(x) * float64(x) + } + if n > 0 { + for j := range v { + v[j] = float32(float64(v[j]) / math.Sqrt(n)) + } + } + out[i] = v + } + return out, nil +} + +// 端到端(真 PG)：写两条记忆(咖啡 importance=3 / 运动 importance=8)→ +// 无 query 时运动(重要度高)在前；query="咖啡"时咖啡(语义相关)翻到前面。 +func TestRelevance_EndToEnd(t *testing.T) { + dsn := os.Getenv("MEMORY_TEST_DSN") + if dsn == "" { + t.Skip("设 MEMORY_TEST_DSN 启用 Postgres 端到端测试") + } + s := Open(dsn) + if s.db == nil { + t.Fatal("Store 不应降级") + } + s.SetEmbedder(detEmbedder{}) + ctx := context.Background() + uid := "memtest-relevance-e2e" + defer func() { + _ = s.Delete(ctx, uid, "饮品偏好") + _ = s.Delete(ctx, uid, "运动习惯") + }() + + if err := s.Upsert(ctx, uid, "饮品偏好", "喜欢手冲咖啡 coffee 不加糖", 3); err != nil { + t.Fatalf("upsert 咖啡: %v", err) + } + if err := s.Upsert(ctx, uid, "运动习惯", "每天健身运动一小时", 8); err != nil { + t.Fatalf("upsert 运动: %v", err) + } + + // 确认写入即向量化：embedding 列非空。 + var rows []Profile + s.db.WithContext(ctx).Where("user_id = ?", uid).Find(&rows) + for _, r := range rows { + if len(r.Embedding) == 0 { + t.Errorf("%s 应已向量化(embedding 非空)", r.Key) + } + } + + // 无 query：两项打分，运动(importance 8)在前。 + noQ, _ := s.Get(ctx, uid, "") + if !strings.HasPrefix(noQ, "- 运动习惯") { + t.Errorf("无 query 应重要度优先(运动在前)，得:\n%s", noQ) + } + // query 咖啡：三项打分，咖啡语义相关翻到前面(尽管重要度更低)。 + withQ, _ := s.Get(ctx, uid, "推荐一款好喝的咖啡 coffee") + if !strings.HasPrefix(withQ, "- 饮品偏好") { + t.Errorf("query=咖啡 应相关性优先(咖啡在前)，得:\n%s", withQ) + } +} diff --git a/sundynix-mcp-go/internal/memory/relevance_test.go b/sundynix-mcp-go/internal/memory/relevance_test.go new file mode 100644 index 0000000..82327ef --- /dev/null +++ b/sundynix-mcp-go/internal/memory/relevance_test.go @@ -0,0 +1,84 @@ +package memory + +import ( + "context" + "math" + "testing" + "time" +) + +// 向量编解码往返：float32 打包进 bytea 再取回不失真。 +func TestVecRoundTrip(t *testing.T) { + v := []float32{0.1, -0.5, 1.0, 0, 0.333} + got := decodeVec(encodeVec(v)) + if len(got) != len(v) { + t.Fatalf("长度不符: %d vs %d", len(got), len(v)) + } + for i := range v { + if got[i] != v[i] { + t.Errorf("第%d个失真: %v vs %v", i, got[i], v[i]) + } + } + // 脏数据（长度非 4 倍数）返回 nil，不 panic。 + if decodeVec([]byte{1, 2, 3}) != nil { + t.Error("非法字节应返回 nil") + } + if decodeVec(nil) != nil { + t.Error("空返回 nil") + } +} + +// cosine01：同向=1，正交=0.5→截到实际（正交余弦0→0），反向截到 0。 +func TestCosine01(t *testing.T) { + a := []float32{1, 0, 0} + if c := cosine01(a, a); math.Abs(c-1) > 1e-6 { + t.Errorf("同向应为 1，得 %v", c) + } + if c := cosine01(a, []float32{0, 1, 0}); c != 0 { + t.Errorf("正交余弦 0，得 %v", c) + } + if c := cosine01(a, []float32{-1, 0, 0}); c != 0 { + t.Errorf("反向应截到 0（不奖励相反语义），得 %v", c) + } + if c := cosine01(a, []float32{0, 0, 0}); c != 0 { + t.Errorf("零向量应为 0，得 %v", c) + } +} + +// 三项打分模式（rel 非 nil）：相关性高的排到前面，即使重要度/最近性略低。 +func TestRankProfiles_RelevanceMode(t *testing.T) { + now := time.Now() + rows := []Profile{ + {BaseModel: BaseModel{ID: "a"}, Key: "无关但重要", Importance: 10, LastSeenAt: now}, + {BaseModel: BaseModel{ID: "b"}, Key: "高度相关", Importance: 3, LastSeenAt: now}, + } + rel := map[string]float64{"a": 0.05, "b": 0.95} // b 语义强相关 + + // 两项模式（rel=nil）：a（重要度10）应在前。 + if got := rankProfiles(rows, now, 0, nil); got[0].ID != "a" { + t.Errorf("两项模式重要度高者应在前，得 %s", got[0].ID) + } + // 三项模式：b 相关性 0.95 主导，应翻到前面。 + if got := rankProfiles(rows, now, 0, rel); got[0].ID != "b" { + t.Errorf("三项模式相关性高者应在前，得 %s", got[0].ID) + } +} + +// relevance 优雅降级：无 embedder / query 空 → 返回 nil（不报错、不影响召回）。 +func TestRelevance_GracefulFallback(t *testing.T) { + s := &Store{} // 无 embedder + if s.relevance(context.Background(), []Profile{{Key: "k"}}, "问题") != nil { + t.Error("无 embedder 应返回 nil") + } + s.emb = stubEmbedder{} + if s.relevance(context.Background(), []Profile{{Key: "k"}}, " ") != nil { + t.Error("query 空白应返回 nil（不白算嵌入）") + } +} + +// stubEmbedder 返回固定维度向量，供降级测试（不打真网络）。 +type stubEmbedder struct{} + +func (stubEmbedder) Embed(_ context.Context, _ []string) ([][]float32, error) { + return [][]float32{{1, 0}}, nil +} diff --git a/sundynix-mcp-go/internal/memory/store.go b/sundynix-mcp-go/internal/memory/store.go index 05d8ceb..0701a2e 100644 --- a/sundynix-mcp-go/internal/memory/store.go +++ b/sundynix-mcp-go/internal/memory/store.go @@ -4,6 +4,7 @@ package memory import ( "context" + "encoding/binary" "fmt" "log" "math" @@ -54,13 +55,27 @@ type Profile struct { Value string `gorm:"type:text"` Importance float64 `gorm:"column:importance"` // 1~10，consolidate 时 LLM 打分（poignancy）→ 读路径权重 LastSeenAt time.Time `gorm:"column:last_seen_at"` // 最近被印证时间 → Recency 衰减依据 + Embedding []byte `gorm:"column:embedding"` // value 的嵌入向量（float32 小端打包）；召回时对 query 算余弦 → Relevance } // TableName 固定表名，遵守 sundynix_ 前缀约定。 func (Profile) TableName() string { return "sundynix_user_profile" } +// Embedder 是把文本转向量的最小接口（memory 包不硬依赖 rag 内部；由 gateway 注入 rag.Engine）。 +// 返回每条文本一个向量；未配置/失败时 memory 优雅降级为 Recency+Importance 两项打分。 +type Embedder interface { + Embed(ctx context.Context, texts []string) ([][]float32, error) +} + // Store 封装画像读写。db 为 nil 表示降级（无 Postgres 时记忆功能空转，不阻断工具服务）。 -type Store struct{ db *gorm.DB } +// emb 为 nil 或未配置时，Relevance 打分静默跳过（回落两项打分，行为与升级前一致）。 +type Store struct { + db *gorm.DB + emb Embedder +} + +// SetEmbedder 注入嵌入能力（gateway 装配时传 rag.Engine）。nil 安全。 +func (s *Store) SetEmbedder(e Embedder) { s.emb = e } // Open 连接 Postgres 并自动迁移 sundynix_user_profile。连接失败不 fatal：返回降级实例。 func Open(dsn string) *Store { @@ -123,18 +138,26 @@ func migrateLegacyProfile(db *gorm.DB) { log.Printf("[memory] 已回灌 %d 条偏好（新雪花 id）", len(saved)) } -// 读路径打分参数（Generative Agents 公式的 Recency + Importance 两项；Relevance 待接 Milvus）。 +// 读路径打分参数（Generative Agents 公式：Recency + Importance + Relevance）。 const ( memTopN = 30 // 注入上限（截断，控 context） - wRecency = 0.4 // 最近性权重 - wImportance = 0.6 // 重要度权重 recencyDecayPerDay = 0.98 // 每天衰减因子（指数） defaultImportance = 5.0 // 旧/未评分行的兜底重要度（避免被不公平遗忘） + + // 无 query / 无 embedder（回落两项）—— 保持升级前的行为与权重。 + wRecency = 0.4 + wImportance = 0.6 + + // relevance 模式（召回带 query 且 embedder 就绪）：三项加权，语义相关性主导但不淹没另两项。 + wRecencyR = 0.25 + wImportanceR = 0.35 + wRelevance = 0.4 ) // Get 返回某用户画像，渲染为可注入 prompt 的多行文本。 -// 按 Score = wRecency·Recency + wImportance·Importance 降序，截断 top-N（控 context + 自然遗忘）。 -func (s *Store) Get(ctx context.Context, userID string) (string, error) { +// query 非空且 embedder 就绪时，融入 Relevance（对当前任务的语义相关性）三项打分； +// 否则回落 Recency+Importance 两项（升级前行为）。截断 top-N（控 context + 自然遗忘 + 相关性优先）。 +func (s *Store) Get(ctx context.Context, userID, query string) (string, error) { if s.db == nil || userID == "" { return "", nil } @@ -142,7 +165,8 @@ func (s *Store) Get(ctx context.Context, userID string) (string, error) { if err := s.db.WithContext(ctx).Where("user_id = ?", userID).Find(&rows).Error; err != nil { return "", err } - ranked := rankProfiles(rows, time.Now(), memTopN) + rel := s.relevance(ctx, rows, query) + ranked := rankProfiles(rows, time.Now(), memTopN, rel) var b strings.Builder for _, r := range ranked { fmt.Fprintf(&b, "- %s：%s\n", r.Key, r.Value) @@ -150,6 +174,28 @@ func (s *Store) Get(ctx context.Context, userID string) (string, error) { return strings.TrimRight(b.String(), "\n"), nil } +// relevance 计算每条偏好对 query 的语义相关性（profile.ID → 余弦[0,1]）。 +// 无 embedder / query 空 / query 嵌入失败 → 返回 nil（打分回落两项，绝不因此报错）。 +// 行无缓存向量（存量未回填 / 嵌入曾失败）→ 该行不进 map，等同 relevance 0（不加分不减分）。 +func (s *Store) relevance(ctx context.Context, rows []Profile, query string) map[string]float64 { + if s.emb == nil || strings.TrimSpace(query) == "" { + return nil + } + qv, err := s.emb.Embed(ctx, []string{query}) + if err != nil || len(qv) == 0 || len(qv[0]) == 0 { + return nil // 嵌入不可用：优雅回落，不影响召回 + } + q := qv[0] + rel := make(map[string]float64, len(rows)) + for _, r := range rows { + v := decodeVec(r.Embedding) + if len(v) == len(q) && len(v) > 0 { + rel[r.ID] = cosine01(q, v) + } + } + return rel +} + // List 返回某用户全部 active 偏好（结构化，供管理面板查看/编辑），按 Score 降序、不截断。 func (s *Store) List(ctx context.Context, userID string) ([]Profile, error) { if s.db == nil || userID == "" { @@ -159,15 +205,16 @@ func (s *Store) List(ctx context.Context, userID string) ([]Profile, error) { if err := s.db.WithContext(ctx).Where("user_id = ?", userID).Find(&rows).Error; err != nil { return nil, err } - return rankProfiles(rows, time.Now(), 0), nil + return rankProfiles(rows, time.Now(), 0, nil), nil // 管理面板：无 query，两项打分 } // rankProfiles 纯函数：按 Score 降序排序（同分 key 升序稳定），截断 top-N（topN<=0 不截断）。 -func rankProfiles(rows []Profile, now time.Time, topN int) []Profile { +// rel 非 nil = relevance 模式（三项打分，缺失 ID 视为 relevance 0）；nil = 两项打分（升级前行为）。 +func rankProfiles(rows []Profile, now time.Time, topN int, rel map[string]float64) []Profile { out := make([]Profile, len(rows)) copy(out, rows) sort.SliceStable(out, func(i, j int) bool { - si, sj := profileScore(out[i], now), profileScore(out[j], now) + si, sj := profileScore(out[i], now, rel), profileScore(out[j], now, rel) if si != sj { return si > sj } @@ -179,13 +226,60 @@ func rankProfiles(rows []Profile, now time.Time, topN int) []Profile { return out } -// profileScore 计算一条偏好的 Recency+Importance 综合分（各归一到 [0,1]）。 -func profileScore(p Profile, now time.Time) float64 { +// profileScore 综合分（各项归一到 [0,1]）。rel==nil → 两项（Recency+Importance）；否则三项加入 Relevance。 +func profileScore(p Profile, now time.Time, rel map[string]float64) float64 { imp := p.Importance if imp <= 0 { imp = defaultImportance } - return wRecency*recencyScore(now, p.LastSeenAt) + wImportance*(imp/10) + recency := recencyScore(now, p.LastSeenAt) + impN := imp / 10 + if rel == nil { + return wRecency*recency + wImportance*impN + } + return wRecencyR*recency + wImportanceR*impN + wRelevance*rel[p.ID] // 缺失 ID → 0 +} + +// ---- 向量编解码 + 余弦（float32 小端打包存 PG bytea；召回时内存算相似度）---- + +func encodeVec(v []float32) []byte { + b := make([]byte, 4*len(v)) + for i, f := range v { + binary.LittleEndian.PutUint32(b[i*4:], math.Float32bits(f)) + } + return b +} + +func decodeVec(b []byte) []float32 { + if len(b) == 0 || len(b)%4 != 0 { + return nil + } + v := make([]float32, len(b)/4) + for i := range v { + v[i] = math.Float32frombits(binary.LittleEndian.Uint32(b[i*4:])) + } + return v +} + +// cosine01 余弦相似度截到 [0,1]（负相关记 0，不奖励相反语义）。 +func cosine01(a, b []float32) float64 { + var dot, na, nb float64 + for i := range a { + dot += float64(a[i]) * float64(b[i]) + na += float64(a[i]) * float64(a[i]) + nb += float64(b[i]) * float64(b[i]) + } + if na == 0 || nb == 0 { + return 0 + } + c := dot / (math.Sqrt(na) * math.Sqrt(nb)) + if c < 0 { + return 0 + } + if c > 1 { + return 1 + } + return c } // recencyScore 指数衰减的最近性分：last_seen 越久越低；未记时间视为新鲜(1)。 @@ -211,10 +305,19 @@ func (s *Store) Upsert(ctx context.Context, userID, key, value string, importanc if importance > 0 { updates["importance"] = importance } + p := &Profile{UserID: userID, Key: key, Value: value, Importance: importance, LastSeenAt: now} + // 写入即向量化 value（供召回算 Relevance）。embedder 未配置/失败 → 留空向量，召回自动回落，不阻断写入。 + if s.emb != nil && strings.TrimSpace(value) != "" { + if vecs, err := s.emb.Embed(ctx, []string{value}); err == nil && len(vecs) > 0 && len(vecs[0]) > 0 { + enc := encodeVec(vecs[0]) + p.Embedding = enc + updates["embedding"] = enc + } + } return s.db.WithContext(ctx).Clauses(clause.OnConflict{ Columns: []clause.Column{{Name: "user_id"}, {Name: "key"}}, DoUpdates: clause.Assignments(updates), - }).Create(&Profile{UserID: userID, Key: key, Value: value, Importance: importance, LastSeenAt: now}).Error + }).Create(p).Error } // Touch 仅刷新某条偏好的 last_seen（NOOP 印证：被再次提及但内容不变，强化 Recency）。 diff --git a/sundynix-mcp-go/internal/memory/store_test.go b/sundynix-mcp-go/internal/memory/store_test.go index ee0eed2..6be9560 100644 --- a/sundynix-mcp-go/internal/memory/store_test.go +++ b/sundynix-mcp-go/internal/memory/store_test.go @@ -99,7 +99,7 @@ func TestProfileStore_Integration(t *testing.T) { // Get 渲染多行（按 key 排序），软删的不出现。 _ = s.Upsert(ctx, "u1", "爱好", "围棋", 6) - got, _ := s.Get(ctx, "u1") + got, _ := s.Get(ctx, "u1", "") if got == "" || got != "- 城市：上海\n- 爱好：围棋" { t.Errorf("Get 渲染不符: %q", got) } diff --git a/sundynix-mcp-go/internal/rag/rag.go b/sundynix-mcp-go/internal/rag/rag.go index dc97a71..1da1f40 100644 --- a/sundynix-mcp-go/internal/rag/rag.go +++ b/sundynix-mcp-go/internal/rag/rag.go @@ -84,6 +84,12 @@ func (e *Engine) embed() *embedClient { return e.emb } +// Embed 导出当前 embedding 能力供 memory 包复用（满足 memory.Embedder）。 +// 未配置时返回错误，调用方（记忆 Relevance）据此优雅回落。热更新下发的模型即时生效。 +func (e *Engine) Embed(ctx context.Context, texts []string) ([][]float32, error) { + return e.embed().Embed(ctx, texts) +} + func (e *Engine) chatClient() *chatClient { e.mu.RLock() defer e.mu.RUnlock()