feat: enhance knowledge search by resolving embedding model keys

- Introduced a new method to resolve embedding model IDs to their actual identity keys (name + endpoint), enabling optimal grouping of knowledge bases across different tenants.
- Updated the concurrent search functionality to utilize the resolved model keys, improving the efficiency of query embedding computations.
- Refactored search target grouping to reduce redundant API calls and enhance performance during hybrid searches.

These changes significantly improve the knowledge search process by ensuring that embeddings are computed efficiently and reused across multiple knowledge bases sharing the same underlying model.
This commit is contained in:
wizardchen
2026-03-13 20:54:25 +08:00
parent d127fe53fd
commit 4c66be1be0
4 changed files with 80 additions and 47 deletions
+15 -22
View File
@@ -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()
@@ -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()
@@ -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.
@@ -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