diff --git a/internal/agent/tools/knowledge_search.go b/internal/agent/tools/knowledge_search.go index fb6eff80..08441c72 100644 --- a/internal/agent/tools/knowledge_search.go +++ b/internal/agent/tools/knowledge_search.go @@ -430,8 +430,9 @@ func (t *KnowledgeSearchTool) getKnowledgeBaseTypes(ctx context.Context, kbIDs [ return kbTypeMap } -// concurrentSearchByTargets executes hybrid search using pre-computed search targets -// This avoids duplicate searches when a knowledge file is already covered by its KB's full search +// 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. func (t *KnowledgeSearchTool) concurrentSearchByTargets( ctx context.Context, queries []string, @@ -440,50 +441,132 @@ func (t *KnowledgeSearchTool) concurrentSearchByTargets( vectorThreshold, keywordThreshold float64, kbTypeMap map[string]string, ) []*searchResultWithMeta { + // Batch-fetch KB records for embedding model grouping + kbIDs := searchTargets.GetAllKnowledgeBaseIDs() + kbMap := make(map[string]*types.KnowledgeBase) + if kbs, err := t.knowledgeBaseService.GetKnowledgeBasesByIDsOnly(ctx, kbIDs); err == nil { + for _, kb := range kbs { + if kb != nil { + kbMap[kb.ID] = kb + } + } + } + + type embGroupKey struct { + ModelID string + TenantID uint64 + } + groups := make(map[embGroupKey][]*types.SearchTarget) + for _, st := range searchTargets { + var key embGroupKey + if kb, ok := kbMap[st.KnowledgeBaseID]; ok { + key = embGroupKey{ModelID: kb.EmbeddingModelID, TenantID: kb.TenantID} + } + groups[key] = append(groups[key], st) + } + var wg sync.WaitGroup var mu sync.Mutex allResults := make([]*searchResultWithMeta, 0) for _, query := range queries { q := query - for _, target := range searchTargets { - st := target + for gk, targets := range groups { wg.Add(1) - go func() { + go func(q string, gk embGroupKey, targets []*types.SearchTarget) { defer wg.Done() - searchParams := types.SearchParams{ - QueryText: q, - MatchCount: topK, - VectorThreshold: vectorThreshold, - KeywordThreshold: keywordThreshold, + // Compute embedding once for this (model, query) pair + var queryEmbedding []float32 + if gk.ModelID != "" { + 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) + } else { + queryEmbedding = emb + } } - // If target has specific knowledge IDs, add them to search params - if st.Type == types.SearchTargetTypeKnowledge { - searchParams.KnowledgeIDs = st.KnowledgeIDs + // Separate full-KB targets (combinable) from specific-knowledge targets + var fullKBIDs []string + var knowledgeTargets []*types.SearchTarget + for _, st := range targets { + if st.Type == types.SearchTargetTypeKnowledgeBase { + fullKBIDs = append(fullKBIDs, st.KnowledgeBaseID) + } else { + knowledgeTargets = append(knowledgeTargets, st) + } } - kbResults, err := t.knowledgeBaseService.HybridSearch(ctx, st.KnowledgeBaseID, searchParams) - if err != nil { - logger.Warnf(ctx, "[Tool][KnowledgeSearch] Failed to search KB %s: %v", st.KnowledgeBaseID, err) - return + var innerWg sync.WaitGroup + + // Combined retrieval for all full-KB targets in this group + if len(fullKBIDs) > 0 { + innerWg.Add(1) + go func() { + defer innerWg.Done() + searchParams := types.SearchParams{ + QueryText: q, + QueryEmbedding: queryEmbedding, + KnowledgeBaseIDs: fullKBIDs, + MatchCount: topK, + VectorThreshold: vectorThreshold, + KeywordThreshold: keywordThreshold, + } + kbResults, err := t.knowledgeBaseService.HybridSearch(ctx, fullKBIDs[0], searchParams) + if err != nil { + logger.Warnf(ctx, "[Tool][KnowledgeSearch] Combined search failed for KBs %v: %v", fullKBIDs, err) + return + } + mu.Lock() + for _, r := range kbResults { + allResults = append(allResults, &searchResultWithMeta{ + SearchResult: r, + SourceQuery: q, + QueryType: "hybrid", + KnowledgeBaseID: r.KnowledgeBaseID, + KnowledgeBaseType: kbTypeMap[r.KnowledgeBaseID], + }) + } + mu.Unlock() + }() } - // Wrap results with metadata and write back KB ID - mu.Lock() - for _, r := range kbResults { - r.KnowledgeBaseID = st.KnowledgeBaseID - allResults = append(allResults, &searchResultWithMeta{ - SearchResult: r, - SourceQuery: q, - QueryType: "hybrid", - KnowledgeBaseID: st.KnowledgeBaseID, - KnowledgeBaseType: kbTypeMap[st.KnowledgeBaseID], - }) + // Individual retrieval for specific-knowledge targets + for _, target := range knowledgeTargets { + st := target + innerWg.Add(1) + go func() { + defer innerWg.Done() + searchParams := types.SearchParams{ + QueryText: q, + QueryEmbedding: queryEmbedding, + MatchCount: topK, + VectorThreshold: vectorThreshold, + KeywordThreshold: keywordThreshold, + KnowledgeIDs: st.KnowledgeIDs, + } + kbResults, err := t.knowledgeBaseService.HybridSearch(ctx, st.KnowledgeBaseID, searchParams) + if err != nil { + logger.Warnf(ctx, "[Tool][KnowledgeSearch] Failed to search KB %s: %v", st.KnowledgeBaseID, err) + return + } + mu.Lock() + for _, r := range kbResults { + allResults = append(allResults, &searchResultWithMeta{ + SearchResult: r, + SourceQuery: q, + QueryType: "hybrid", + KnowledgeBaseID: r.KnowledgeBaseID, + KnowledgeBaseType: kbTypeMap[r.KnowledgeBaseID], + }) + } + mu.Unlock() + }() } - mu.Unlock() - }() + + innerWg.Wait() + }(q, gk, targets) } } wg.Wait() diff --git a/internal/application/service/chat_pipline/search.go b/internal/application/service/chat_pipline/search.go index 4422f2cb..9df34467 100644 --- a/internal/application/service/chat_pipline/search.go +++ b/internal/application/service/chat_pipline/search.go @@ -209,8 +209,18 @@ func logSearchScoreSample(ctx context.Context, action string, results []*types.S } } -// searchByTargets performs KB searches using pre-computed SearchTargets -// This is the main search method that uses the unified search targets +// 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. func (p *PluginSearch) searchByTargets( ctx context.Context, chatManage *types.ChatManage, @@ -219,86 +229,131 @@ func (p *PluginSearch) searchByTargets( return nil } + 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 + // computes the embedding per-KB (graceful degradation). + kbIDs := make([]string, 0, len(chatManage.SearchTargets)) + for _, t := range chatManage.SearchTargets { + kbIDs = append(kbIDs, t.KnowledgeBaseID) + } + kbMap := make(map[string]*types.KnowledgeBase) + if kbs, err := p.knowledgeBaseService.GetKnowledgeBasesByIDsOnly(ctx, kbIDs); err == nil { + for _, kb := range kbs { + if kb != nil { + kbMap[kb.ID] = kb + } + } + } else { + pipelineWarn(ctx, "Search", "batch_kb_fetch_error", map[string]interface{}{ + "error": err.Error(), + }) + } + + groups := make(map[embeddingGroupKey][]*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} + } + groups[key] = append(groups[key], t) + } + + pipelineInfo(ctx, "Search", "embedding_groups", map[string]interface{}{ + "total_targets": len(chatManage.SearchTargets), + "unique_models": len(groups), + }) + var wg sync.WaitGroup var mu sync.Mutex var results []*types.SearchResult - // Search each target concurrently - for _, target := range chatManage.SearchTargets { + for gk, targets := range groups { wg.Add(1) - go func(t *types.SearchTarget) { + go func(gk embeddingGroupKey, targets []*types.SearchTarget) { defer wg.Done() - // List of knowledge IDs to perform vector search on - // Default to all IDs in the target - searchKnowledgeIDs := t.KnowledgeIDs + // Compute embedding once for this model group. + var queryEmbedding []float32 + if gk.ModelID != "" { + 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(), + }) + } else { + queryEmbedding = emb + } + } - // Try direct loading for specific knowledge targets - if t.Type == types.SearchTargetTypeKnowledge { - directResults, skippedIDs := p.tryDirectChunkLoading(ctx, chatManage.TenantID, t.KnowledgeIDs) + // Separate full-KB targets (can be combined into one retrieval) + // from specific-knowledge targets (need per-target direct loading). + var fullKBIDs []string + var knowledgeTargets []*types.SearchTarget + for _, t := range targets { + if t.Type == types.SearchTargetTypeKnowledgeBase { + fullKBIDs = append(fullKBIDs, t.KnowledgeBaseID) + } else { + knowledgeTargets = append(knowledgeTargets, t) + } + } - if len(directResults) > 0 { - for _, r := range directResults { - r.KnowledgeBaseID = t.KnowledgeBaseID + pipelineInfo(ctx, "Search", "group_plan", map[string]interface{}{ + "model_id": gk.ModelID, + "combined_kb_count": len(fullKBIDs), + "individual_targets": len(knowledgeTargets), + "vector_len": len(queryEmbedding), + }) + + var innerWg sync.WaitGroup + + // Combined search: one HybridSearch call spanning all full-KB targets + if len(fullKBIDs) > 0 { + innerWg.Add(1) + go func() { + defer innerWg.Done() + + params := types.SearchParams{ + QueryText: queryText, + QueryEmbedding: queryEmbedding, + KnowledgeBaseIDs: fullKBIDs, + VectorThreshold: chatManage.VectorThreshold, + KeywordThreshold: chatManage.KeywordThreshold, + MatchCount: chatManage.EmbeddingTopK, + SkipContextEnrichment: true, } - pipelineInfo(ctx, "Search", "direct_load", map[string]interface{}{ - "kb_id": t.KnowledgeBaseID, - "loaded_count": len(directResults), - "skipped_ids": len(skippedIDs), + res, err := p.knowledgeBaseService.HybridSearch(ctx, fullKBIDs[0], params) + if err != nil { + pipelineWarn(ctx, "Search", "combined_kb_search_error", map[string]interface{}{ + "kb_ids": fullKBIDs, + "error": err.Error(), + }) + return + } + pipelineInfo(ctx, "Search", "combined_kb_result", map[string]interface{}{ + "kb_ids": fullKBIDs, + "hit_count": len(res), }) mu.Lock() - results = append(results, directResults...) + results = append(results, res...) mu.Unlock() - } - - // If all files were loaded directly, we don't need to search anything - if len(skippedIDs) == 0 && len(t.KnowledgeIDs) > 0 { - return - } - - // Otherwise, only search the files that were skipped (too large) - searchKnowledgeIDs = skippedIDs + }() } - // If no IDs left to search (and we are in Knowledge mode), we are done - if t.Type == types.SearchTargetTypeKnowledge && len(searchKnowledgeIDs) == 0 { - return + // Individual search: per-target handling for specific-knowledge targets + for _, target := range knowledgeTargets { + innerWg.Add(1) + go func(t *types.SearchTarget) { + defer innerWg.Done() + p.searchSingleTarget(ctx, chatManage, t, queryText, queryEmbedding, &mu, &results) + }(target) } - // Build params for rewrite query - params := types.SearchParams{ - QueryText: strings.TrimSpace(chatManage.RewriteQuery), - VectorThreshold: chatManage.VectorThreshold, - KeywordThreshold: chatManage.KeywordThreshold, - MatchCount: chatManage.EmbeddingTopK, - SkipContextEnrichment: true, // Pipeline handles context assembly in merge stage - } - // Apply knowledge ID filter if this is a partial KB search - if t.Type == types.SearchTargetTypeKnowledge { - params.KnowledgeIDs = searchKnowledgeIDs - } - res, err := p.knowledgeBaseService.HybridSearch(ctx, t.KnowledgeBaseID, params) - if err != nil { - pipelineWarn(ctx, "Search", "kb_search_error", map[string]interface{}{ - "kb_id": t.KnowledgeBaseID, - "target_type": t.Type, - "query": params.QueryText, - "error": err.Error(), - }) - return - } - for _, r := range res { - r.KnowledgeBaseID = t.KnowledgeBaseID - } - pipelineInfo(ctx, "Search", "kb_result", map[string]interface{}{ - "kb_id": t.KnowledgeBaseID, - "target_type": t.Type, - "hit_count": len(res), - }) - mu.Lock() - results = append(results, res...) - mu.Unlock() - }(target) + innerWg.Wait() + }(gk, targets) } wg.Wait() @@ -309,6 +364,77 @@ func (p *PluginSearch) searchByTargets( return results } +// searchSingleTarget handles the search logic for a single SearchTarget +// with specific knowledge IDs, including direct chunk loading and HybridSearch. +func (p *PluginSearch) searchSingleTarget( + ctx context.Context, + chatManage *types.ChatManage, + t *types.SearchTarget, + queryText string, + queryEmbedding []float32, + mu *sync.Mutex, + results *[]*types.SearchResult, +) { + searchKnowledgeIDs := t.KnowledgeIDs + + if t.Type == types.SearchTargetTypeKnowledge { + directResults, skippedIDs := p.tryDirectChunkLoading(ctx, chatManage.TenantID, t.KnowledgeIDs) + + if len(directResults) > 0 { + for _, r := range directResults { + r.KnowledgeBaseID = t.KnowledgeBaseID + } + pipelineInfo(ctx, "Search", "direct_load", map[string]interface{}{ + "kb_id": t.KnowledgeBaseID, + "loaded_count": len(directResults), + "skipped_ids": len(skippedIDs), + }) + mu.Lock() + *results = append(*results, directResults...) + mu.Unlock() + } + + if len(skippedIDs) == 0 && len(t.KnowledgeIDs) > 0 { + return + } + searchKnowledgeIDs = skippedIDs + } + + if t.Type == types.SearchTargetTypeKnowledge && len(searchKnowledgeIDs) == 0 { + return + } + + params := types.SearchParams{ + QueryText: queryText, + QueryEmbedding: queryEmbedding, + VectorThreshold: chatManage.VectorThreshold, + KeywordThreshold: chatManage.KeywordThreshold, + MatchCount: chatManage.EmbeddingTopK, + SkipContextEnrichment: true, + } + if t.Type == types.SearchTargetTypeKnowledge { + params.KnowledgeIDs = searchKnowledgeIDs + } + res, err := p.knowledgeBaseService.HybridSearch(ctx, t.KnowledgeBaseID, params) + if err != nil { + pipelineWarn(ctx, "Search", "kb_search_error", map[string]interface{}{ + "kb_id": t.KnowledgeBaseID, + "target_type": t.Type, + "query": params.QueryText, + "error": err.Error(), + }) + return + } + pipelineInfo(ctx, "Search", "kb_result", map[string]interface{}{ + "kb_id": t.KnowledgeBaseID, + "target_type": t.Type, + "hit_count": len(res), + }) + mu.Lock() + *results = append(*results, res...) + mu.Unlock() +} + // tryDirectChunkLoading attempts to load chunks for given knowledge IDs directly // Returns loaded results and a list of knowledge IDs that were skipped (e.g. due to size limits) func (p *PluginSearch) tryDirectChunkLoading(ctx context.Context, tenantID uint64, knowledgeIDs []string) ([]*types.SearchResult, []string) { diff --git a/internal/application/service/knowledgebase.go b/internal/application/service/knowledgebase.go index afc0759e..b29d7dd1 100644 --- a/internal/application/service/knowledgebase.go +++ b/internal/application/service/knowledgebase.go @@ -605,12 +605,46 @@ func (s *knowledgeBaseService) CopyKnowledgeBase(ctx context.Context, return sourceKB, targetKB, nil } -// HybridSearch performs hybrid search, including vector retrieval and keyword retrieval +// GetQueryEmbedding computes the query embedding using the embedding model +// associated with the given knowledge base. Callers can pre-compute and reuse +// the result across multiple KBs that share the same embedding model to avoid +// redundant embedding API calls. +func (s *knowledgeBaseService) GetQueryEmbedding(ctx context.Context, kbID string, queryText string) ([]float32, error) { + kb, err := s.repo.GetKnowledgeBaseByID(ctx, kbID) + if err != nil { + return nil, err + } + + currentTenantID := types.MustTenantIDFromContext(ctx) + var embeddingModel embedding.Embedder + + if kb.TenantID != currentTenantID { + embeddingModel, err = s.modelService.GetEmbeddingModelForTenant(ctx, kb.EmbeddingModelID, kb.TenantID) + } else { + embeddingModel, err = s.modelService.GetEmbeddingModel(ctx, kb.EmbeddingModelID) + } + if err != nil { + logger.Errorf(ctx, "GetQueryEmbedding: failed to get embedding model %s: %v", kb.EmbeddingModelID, err) + return nil, err + } + + return embeddingModel.Embed(ctx, queryText) +} + +// 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. func (s *knowledgeBaseService) HybridSearch(ctx context.Context, id string, params types.SearchParams, ) ([]*types.SearchResult, error) { - logger.Infof(ctx, "Hybrid search parameters, knowledge base ID: %s, query text: %s", id, params.QueryText) + // Determine the set of KB IDs to search + searchKBIDs := params.KnowledgeBaseIDs + if len(searchKBIDs) == 0 { + searchKBIDs = []string{id} + } + + logger.Infof(ctx, "Hybrid search parameters, knowledge base IDs: %v, query text: %s", searchKBIDs, params.QueryText) tenantInfo, _ := types.TenantInfoFromContext(ctx) currentTenantID := types.MustTenantIDFromContext(ctx) @@ -635,43 +669,48 @@ func (s *knowledgeBaseService) HybridSearch(ctx context.Context, } // Use 5x over-retrieval to ensure sufficient candidates for RRF fusion and reranking. - // Minimum 50 to handle large knowledge bases with diverse content. - matchCount := max(params.MatchCount*5, 50) + // Scale proportionally when searching multiple KBs to maintain per-KB recall quality. + matchCount := max(params.MatchCount*5, 50) * len(searchKBIDs) + if matchCount > 1000 { + matchCount = 1000 + } // Add vector retrieval params if supported if retrieveEngine.SupportRetriever(types.VectorRetrieverType) && !params.DisableVectorMatch { logger.Info(ctx, "Vector retrieval supported, preparing vector retrieval parameters") - logger.Infof(ctx, "Getting embedding model, model ID: %s", kb.EmbeddingModelID) + var queryEmbedding []float32 - // Check if this is a cross-tenant shared knowledge base - // For shared KB, we must use the source tenant's embedding model to ensure vector compatibility - if kb.TenantID != currentTenantID { - logger.Infof(ctx, "Cross-tenant knowledge base detected, using source tenant's embedding model. KB tenant: %d, current tenant: %d", kb.TenantID, currentTenantID) - embeddingModel, err = s.modelService.GetEmbeddingModelForTenant(ctx, kb.EmbeddingModelID, kb.TenantID) + if len(params.QueryEmbedding) > 0 { + queryEmbedding = params.QueryEmbedding + logger.Infof(ctx, "Using pre-computed query embedding, vector length: %d", len(queryEmbedding)) } else { - embeddingModel, err = s.modelService.GetEmbeddingModel(ctx, kb.EmbeddingModelID) - } + // Check if this is a cross-tenant shared knowledge base + // For shared KB, we must use the source tenant's embedding model to ensure vector compatibility + if kb.TenantID != currentTenantID { + logger.Infof(ctx, "Cross-tenant knowledge base detected, using source tenant's embedding model. KB tenant: %d, current tenant: %d", kb.TenantID, currentTenantID) + embeddingModel, err = s.modelService.GetEmbeddingModelForTenant(ctx, kb.EmbeddingModelID, kb.TenantID) + } else { + embeddingModel, err = s.modelService.GetEmbeddingModel(ctx, kb.EmbeddingModelID) + } - if err != nil { - logger.Errorf(ctx, "Failed to get embedding model, model ID: %s, error: %v", kb.EmbeddingModelID, err) - return nil, err + if err != nil { + logger.Errorf(ctx, "Failed to get embedding model, model ID: %s, error: %v", kb.EmbeddingModelID, err) + return nil, err + } + logger.Infof(ctx, "Embedding model retrieved: %v", embeddingModel) + queryEmbedding, err = embeddingModel.Embed(context.WithValue(ctx, types.EmbedQueryContextKey, true), params.QueryText) + if err != nil { + logger.Errorf(ctx, "Failed to embed query text, query text: %s, error: %v", params.QueryText, err) + return nil, err + } + logger.Infof(ctx, "Query embedding generated successfully, embedding vector length: %d", len(queryEmbedding)) } - logger.Infof(ctx, "Embedding model retrieved: %v", embeddingModel) - - // Generate embedding vector for the query text - logger.Info(ctx, "Starting to generate query embedding") - queryEmbedding, err := embeddingModel.Embed(context.WithValue(ctx, types.EmbedQueryContextKey, true), params.QueryText) - if err != nil { - logger.Errorf(ctx, "Failed to embed query text, query text: %s, error: %v", params.QueryText, err) - return nil, err - } - logger.Infof(ctx, "Query embedding generated successfully, embedding vector length: %d", len(queryEmbedding)) vectorParams := types.RetrieveParams{ Query: params.QueryText, Embedding: queryEmbedding, - KnowledgeBaseIDs: []string{id}, + KnowledgeBaseIDs: searchKBIDs, TopK: matchCount, Threshold: params.VectorThreshold, RetrieverType: types.VectorRetrieverType, @@ -694,7 +733,7 @@ func (s *knowledgeBaseService) HybridSearch(ctx context.Context, logger.Info(ctx, "Keyword retrieval supported, preparing keyword retrieval parameters") retrieveParams = append(retrieveParams, types.RetrieveParams{ Query: params.QueryText, - KnowledgeBaseIDs: []string{id}, + KnowledgeBaseIDs: searchKBIDs, TopK: matchCount, Threshold: params.KeywordThreshold, RetrieverType: types.KeywordsRetrieverType, @@ -714,8 +753,8 @@ func (s *knowledgeBaseService) HybridSearch(ctx context.Context, retrieveResults, err := retrieveEngine.Retrieve(ctx, retrieveParams) if err != nil { logger.ErrorWithFields(ctx, err, map[string]interface{}{ - "knowledge_base_id": id, - "query_text": params.QueryText, + "knowledge_base_ids": searchKBIDs, + "query_text": params.QueryText, }) return nil, err } @@ -1344,6 +1383,7 @@ func (s *knowledgeBaseService) buildSearchResult(chunk *types.Chunk, KnowledgeSource: knowledge.Source, ChunkMetadata: chunk.Metadata, MatchedContent: matchedContent, + KnowledgeBaseID: knowledge.KnowledgeBaseID, } } diff --git a/internal/types/interfaces/knowledgebase.go b/internal/types/interfaces/knowledgebase.go index d79426f0..6aab8d2f 100644 --- a/internal/types/interfaces/knowledgebase.go +++ b/internal/types/interfaces/knowledgebase.go @@ -93,6 +93,11 @@ type KnowledgeBaseService interface { // - Possible errors such as not existing, insufficient permissions, search engine errors, etc. HybridSearch(ctx context.Context, id string, params types.SearchParams) ([]*types.SearchResult, error) + // GetQueryEmbedding computes the query embedding using the embedding model + // associated with the given knowledge base. This allows callers to pre-compute + // and reuse embeddings across multiple KBs that share the same model. + GetQueryEmbedding(ctx context.Context, kbID string, queryText string) ([]float32, error) + // CopyKnowledgeBase copies a knowledge base // Parameters: // - ctx: Context information diff --git a/internal/types/search.go b/internal/types/search.go index 2bbe2a7b..367f1266 100644 --- a/internal/types/search.go +++ b/internal/types/search.go @@ -133,15 +133,20 @@ type SearchResult struct { // SearchParams represents the search parameters type SearchParams struct { - QueryText string `json:"query_text"` - VectorThreshold float64 `json:"vector_threshold"` - KeywordThreshold float64 `json:"keyword_threshold"` - MatchCount int `json:"match_count"` - DisableKeywordsMatch bool `json:"disable_keywords_match"` - DisableVectorMatch bool `json:"disable_vector_match"` - KnowledgeIDs []string `json:"knowledge_ids"` - TagIDs []string `json:"tag_ids"` // Tag IDs for filtering (used for FAQ priority filtering) - OnlyRecommended bool `json:"only_recommended"` + QueryText string `json:"query_text"` + QueryEmbedding []float32 `json:"query_embedding,omitempty"` + VectorThreshold float64 `json:"vector_threshold"` + KeywordThreshold float64 `json:"keyword_threshold"` + MatchCount int `json:"match_count"` + DisableKeywordsMatch bool `json:"disable_keywords_match"` + DisableVectorMatch bool `json:"disable_vector_match"` + KnowledgeIDs []string `json:"knowledge_ids"` + TagIDs []string `json:"tag_ids"` // Tag IDs for filtering (used for FAQ priority filtering) + OnlyRecommended bool `json:"only_recommended"` + // KnowledgeBaseIDs overrides the single KB ID passed to HybridSearch, + // allowing a single retrieval call to span multiple KBs that share the + // same embedding model. When empty, HybridSearch uses its own id parameter. + KnowledgeBaseIDs []string `json:"knowledge_base_ids,omitempty"` // SkipContextEnrichment skips fetching parent, nearby, and relation chunks // in processSearchResults. Used by the chat pipeline where context assembly // is handled separately in the merge stage.