feat: optimize hybrid search by grouping targets and reusing query embeddings

- Enhanced the concurrent search functionality to group search targets by their embedding model, allowing for a single computation of query embeddings per model.
- Implemented batch fetching of knowledge base records to improve efficiency and reduce redundant API calls.
- Updated the HybridSearch method to support multiple knowledge base IDs, enabling combined retrieval for full-KB targets and improving overall search performance.
- Added a new GetQueryEmbedding method to compute embeddings for queries, facilitating reuse across multiple knowledge bases sharing the same model.

These changes significantly enhance the performance and efficiency of the knowledge search process, reducing API calls and improving response times.
This commit is contained in:
wizardchen
2026-03-13 20:33:47 +08:00
parent 3b006e8bf0
commit fc92b494b0
5 changed files with 392 additions and 133 deletions
+113 -30
View File
@@ -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()
@@ -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) {
+69 -29
View File
@@ -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,
}
}
@@ -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
+14 -9
View File
@@ -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.