diff --git a/internal/agent/tools/knowledge_search.go b/internal/agent/tools/knowledge_search.go index 08441c72..22c657c7 100644 --- a/internal/agent/tools/knowledge_search.go +++ b/internal/agent/tools/knowledge_search.go @@ -431,8 +431,9 @@ func (t *KnowledgeSearchTool) getKnowledgeBaseTypes(ctx context.Context, kbIDs [ } // concurrentSearchByTargets executes hybrid search using pre-computed search targets. -// Targets sharing the same embedding model are grouped so the query embedding is -// computed only once per (model, query) pair, reducing redundant API calls. +// Targets sharing the same underlying embedding model (identified by model name + endpoint) +// are grouped so the query embedding is computed once per (model, query) pair, and all +// full-KB targets in a group are combined into a single retrieval call. func (t *KnowledgeSearchTool) concurrentSearchByTargets( ctx context.Context, queries []string, @@ -443,25 +444,17 @@ func (t *KnowledgeSearchTool) concurrentSearchByTargets( ) []*searchResultWithMeta { // Batch-fetch KB records for embedding model grouping kbIDs := searchTargets.GetAllKnowledgeBaseIDs() - kbMap := make(map[string]*types.KnowledgeBase) + var kbList []*types.KnowledgeBase if kbs, err := t.knowledgeBaseService.GetKnowledgeBasesByIDsOnly(ctx, kbIDs); err == nil { - for _, kb := range kbs { - if kb != nil { - kbMap[kb.ID] = kb - } - } + kbList = kbs } - type embGroupKey struct { - ModelID string - TenantID uint64 - } - groups := make(map[embGroupKey][]*types.SearchTarget) + // Resolve actual model identities (name + endpoint) for cross-tenant grouping + modelKeyMap := t.knowledgeBaseService.ResolveEmbeddingModelKeys(ctx, kbList) + + groups := make(map[string][]*types.SearchTarget) for _, st := range searchTargets { - var key embGroupKey - if kb, ok := kbMap[st.KnowledgeBaseID]; ok { - key = embGroupKey{ModelID: kb.EmbeddingModelID, TenantID: kb.TenantID} - } + key := modelKeyMap[st.KnowledgeBaseID] groups[key] = append(groups[key], st) } @@ -471,17 +464,17 @@ func (t *KnowledgeSearchTool) concurrentSearchByTargets( for _, query := range queries { q := query - for gk, targets := range groups { + for modelKey, targets := range groups { wg.Add(1) - go func(q string, gk embGroupKey, targets []*types.SearchTarget) { + go func(q string, modelKey string, targets []*types.SearchTarget) { defer wg.Done() // Compute embedding once for this (model, query) pair var queryEmbedding []float32 - if gk.ModelID != "" { + if modelKey != "" { emb, err := t.knowledgeBaseService.GetQueryEmbedding(ctx, targets[0].KnowledgeBaseID, q) if err != nil { - logger.Warnf(ctx, "[Tool][KnowledgeSearch] Failed to pre-compute embedding for model %s: %v", gk.ModelID, err) + logger.Warnf(ctx, "[Tool][KnowledgeSearch] Failed to pre-compute embedding for model %s: %v", modelKey, err) } else { queryEmbedding = emb } @@ -566,7 +559,7 @@ func (t *KnowledgeSearchTool) concurrentSearchByTargets( } innerWg.Wait() - }(q, gk, targets) + }(q, modelKey, targets) } } wg.Wait() diff --git a/internal/application/service/chat_pipline/search.go b/internal/application/service/chat_pipline/search.go index 9df34467..f5b067b9 100644 --- a/internal/application/service/chat_pipline/search.go +++ b/internal/application/service/chat_pipline/search.go @@ -209,18 +209,11 @@ func logSearchScoreSample(ctx context.Context, action string, results []*types.S } } -// embeddingGroupKey groups search targets that share the same embedding model -// so we only compute the query embedding once per distinct model. -type embeddingGroupKey struct { - ModelID string - TenantID uint64 -} - // searchByTargets performs KB searches using pre-computed SearchTargets. -// Targets sharing the same embedding model are grouped so the query embedding -// is computed only once per model AND all full-KB targets in a group are -// combined into a single retrieval call, reducing both embedding API calls and -// database round-trips. +// Targets sharing the same underlying embedding model (identified by model +// name + endpoint, not just model ID) are grouped so the query embedding is +// computed once per model AND all full-KB targets in a group are combined into +// a single retrieval call, reducing both embedding API calls and DB round-trips. func (p *PluginSearch) searchByTargets( ctx context.Context, chatManage *types.ChatManage, @@ -232,14 +225,16 @@ func (p *PluginSearch) searchByTargets( queryText := strings.TrimSpace(chatManage.RewriteQuery) // Batch-fetch KB records to determine embedding model grouping. - // On failure, all targets fall into a zero-key group and HybridSearch + // On failure, all targets fall into an empty-key group and HybridSearch // computes the embedding per-KB (graceful degradation). kbIDs := make([]string, 0, len(chatManage.SearchTargets)) for _, t := range chatManage.SearchTargets { kbIDs = append(kbIDs, t.KnowledgeBaseID) } + var kbList []*types.KnowledgeBase kbMap := make(map[string]*types.KnowledgeBase) if kbs, err := p.knowledgeBaseService.GetKnowledgeBasesByIDsOnly(ctx, kbIDs); err == nil { + kbList = kbs for _, kb := range kbs { if kb != nil { kbMap[kb.ID] = kb @@ -251,12 +246,13 @@ func (p *PluginSearch) searchByTargets( }) } - groups := make(map[embeddingGroupKey][]*types.SearchTarget) + // Resolve actual model identities (name + endpoint) so that cross-tenant + // KBs backed by the same physical model share one embedding computation. + modelKeyMap := p.knowledgeBaseService.ResolveEmbeddingModelKeys(ctx, kbList) + + groups := make(map[string][]*types.SearchTarget) for _, t := range chatManage.SearchTargets { - var key embeddingGroupKey - if kb, ok := kbMap[t.KnowledgeBaseID]; ok { - key = embeddingGroupKey{ModelID: kb.EmbeddingModelID, TenantID: kb.TenantID} - } + key := modelKeyMap[t.KnowledgeBaseID] // empty string if unresolved groups[key] = append(groups[key], t) } @@ -269,20 +265,20 @@ func (p *PluginSearch) searchByTargets( var mu sync.Mutex var results []*types.SearchResult - for gk, targets := range groups { + for modelKey, targets := range groups { wg.Add(1) - go func(gk embeddingGroupKey, targets []*types.SearchTarget) { + go func(modelKey string, targets []*types.SearchTarget) { defer wg.Done() // Compute embedding once for this model group. var queryEmbedding []float32 - if gk.ModelID != "" { + if modelKey != "" { emb, err := p.knowledgeBaseService.GetQueryEmbedding(ctx, targets[0].KnowledgeBaseID, queryText) if err != nil { pipelineWarn(ctx, "Search", "group_embed_error", map[string]interface{}{ - "model_id": gk.ModelID, - "kb_id": targets[0].KnowledgeBaseID, - "error": err.Error(), + "model_key": modelKey, + "kb_id": targets[0].KnowledgeBaseID, + "error": err.Error(), }) } else { queryEmbedding = emb @@ -302,7 +298,7 @@ func (p *PluginSearch) searchByTargets( } pipelineInfo(ctx, "Search", "group_plan", map[string]interface{}{ - "model_id": gk.ModelID, + "model_key": modelKey, "combined_kb_count": len(fullKBIDs), "individual_targets": len(knowledgeTargets), "vector_len": len(queryEmbedding), @@ -353,7 +349,7 @@ func (p *PluginSearch) searchByTargets( } innerWg.Wait() - }(gk, targets) + }(modelKey, targets) } wg.Wait() diff --git a/internal/application/service/knowledgebase.go b/internal/application/service/knowledgebase.go index b29d7dd1..d5016006 100644 --- a/internal/application/service/knowledgebase.go +++ b/internal/application/service/knowledgebase.go @@ -631,6 +631,44 @@ func (s *knowledgeBaseService) GetQueryEmbedding(ctx context.Context, kbID strin return embeddingModel.Embed(ctx, queryText) } +// ResolveEmbeddingModelKeys resolves embedding model IDs to their actual model +// identity key (name + endpoint). KBs using the same underlying model across +// different tenants will share the same key, enabling optimal grouping. +func (s *knowledgeBaseService) ResolveEmbeddingModelKeys(ctx context.Context, kbs []*types.KnowledgeBase) map[string]string { + type modelRef struct { + ModelID string + TenantID uint64 + } + + // Deduplicate model references + uniqueRefs := make(map[modelRef]struct{}) + kbRefs := make(map[string]modelRef, len(kbs)) + for _, kb := range kbs { + ref := modelRef{ModelID: kb.EmbeddingModelID, TenantID: kb.TenantID} + uniqueRefs[ref] = struct{}{} + kbRefs[kb.ID] = ref + } + + // Resolve each unique (modelID, tenantID) to a model identity key + resolvedKeys := make(map[modelRef]string, len(uniqueRefs)) + for ref := range uniqueRefs { + tenantCtx := context.WithValue(ctx, types.TenantIDContextKey, ref.TenantID) + model, err := s.modelService.GetModelByID(tenantCtx, ref.ModelID) + if err != nil || model == nil { + logger.Warnf(ctx, "ResolveEmbeddingModelKeys: cannot resolve model %s for tenant %d: %v", ref.ModelID, ref.TenantID, err) + resolvedKeys[ref] = ref.ModelID + continue + } + resolvedKeys[ref] = model.Name + "|" + model.Parameters.BaseURL + } + + result := make(map[string]string, len(kbs)) + for _, kb := range kbs { + result[kb.ID] = resolvedKeys[kbRefs[kb.ID]] + } + return result +} + // HybridSearch performs hybrid search, including vector retrieval and keyword retrieval. // When params.KnowledgeBaseIDs is set, those IDs are used for retrieval instead of `id`, // allowing a single call to span multiple KBs that share the same embedding model. diff --git a/internal/types/interfaces/knowledgebase.go b/internal/types/interfaces/knowledgebase.go index 6aab8d2f..bbb77ee1 100644 --- a/internal/types/interfaces/knowledgebase.go +++ b/internal/types/interfaces/knowledgebase.go @@ -98,6 +98,12 @@ type KnowledgeBaseService interface { // and reuse embeddings across multiple KBs that share the same model. GetQueryEmbedding(ctx context.Context, kbID string, queryText string) ([]float32, error) + // ResolveEmbeddingModelKeys resolves embedding model IDs to their actual + // model identity key (name + endpoint). KBs using the same underlying model + // across different tenants will share the same key, enabling optimal grouping. + // Returns a map from KB ID to model identity key string. + ResolveEmbeddingModelKeys(ctx context.Context, kbs []*types.KnowledgeBase) map[string]string + // CopyKnowledgeBase copies a knowledge base // Parameters: // - ctx: Context information