Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

Fix: allow datasets sharing a base embedding model to be searched together (#18166)

euvreb1de7e8136e1
diff --git a/api/apps/restful_apis/chunk_api.py b/api/apps/restful_apis/chunk_api.py
index 751df6fd9e..8a7485b790 100644
--- a/api/apps/restful_apis/chunk_api.py
+++ b/api/apps/restful_apis/chunk_api.py
@@ -26,17 +26,16 @@ from quart import request
from api.apps import login_required
from api.apps.services import structure_graph_common as sgc
+from api.db.db_models import Document, Task
from api.db.joint_services.tenant_model_service import (
- split_model_name,
- resolve_model_config,
get_tenant_default_model_by_type,
+ resolve_model_config,
)
-from api.db.db_models import Document, Task
from api.db.services.doc_metadata_service import DocMetadataService
from api.db.services.document_counter_service import release_reparse_counters
from api.db.services.document_service import DocumentService
from api.db.services.file2document_service import File2DocumentService
-from api.db.services.knowledgebase_service import KnowledgebaseService
+from api.db.services.knowledgebase_service import KnowledgebaseService, validate_dataset_embedding_models
from api.db.services.llm_service import LLMBundle
from api.db.services.task_service import TaskService, cancel_all_task_of, queue_tasks
from api.db.services.tenant_llm_service import TenantLLMService
@@ -49,8 +48,8 @@ from api.utils.api_utils import (
get_result,
server_error_response,
)
-from api.utils.pagination_utils import DEFAULT_PAGE, DEFAULT_PAGE_SIZE, validate_rest_api_ids, validate_rest_api_page, validate_rest_api_page_size
from api.utils.image_utils import store_chunk_image
+from api.utils.pagination_utils import DEFAULT_PAGE, DEFAULT_PAGE_SIZE, validate_rest_api_ids, validate_rest_api_page, validate_rest_api_page_size
from api.utils.reference_metadata_utils import (
enrich_chunks_with_document_metadata,
resolve_reference_metadata_preferences,
@@ -66,7 +65,6 @@ from rag.app.tag import label_question
from rag.nlp import search
from rag.prompts.generator import cross_languages, keyword_extraction
-
DOC_STOP_PARSING_INVALID_STATE_MESSAGE = "Can't stop parsing document that has not started or already completed"
DOC_STOP_PARSING_INVALID_STATE_ERROR_CODE = "DOC_STOP_PARSING_INVALID_STATE"
@@ -342,9 +340,9 @@ async def retrieval_test(tenant_id):
if not KnowledgebaseService.accessible(kb_id=id, user_id=tenant_id):
return get_error_data_result(f"You don't own the dataset {id}.")
kbs = KnowledgebaseService.get_by_ids(kb_ids)
- embd_nms = list(set([split_model_name(kb.embd_id)[0] for kb in kbs]))
- if len(embd_nms) != 1:
- return get_result(message="Datasets use different embedding models.", code=RetCode.DATA_ERROR)
+ embd_err = validate_dataset_embedding_models(kbs)
+ if embd_err:
+ return get_result(message=embd_err, code=RetCode.DATA_ERROR)
if "question" not in req:
return get_error_data_result("`question` is required.")
page = validate_rest_api_page(req.get("page", DEFAULT_PAGE))
@@ -605,9 +603,9 @@ async def get_document_structure_graph(tenant_id, dataset_id, document_id):
migration doesn't drop their data on the floor. Empty templates
(zero entities AND zero relations) are filtered out.
"""
- from rag.nlp import search
from api.db.services.compilation_template_group_service import CompilationTemplateGroupService
from api.db.services.compilation_template_service import CompilationTemplateService
+ from rag.nlp import search
if not KnowledgebaseService.accessible(kb_id=dataset_id, user_id=tenant_id):
return get_error_data_result(message=f"You don't own the dataset {dataset_id}.")
@@ -855,7 +853,7 @@ async def get_document_structure_graph(tenant_id, dataset_id, document_id):
for tid in configured_ids:
if tid in grouped and tid not in ordered_ids:
ordered_ids.append(tid)
- for bucket_id in grouped.keys():
+ for bucket_id in grouped:
if bucket_id not in ordered_ids:
ordered_ids.append(bucket_id)
diff --git a/api/db/services/knowledgebase_service.py b/api/db/services/knowledgebase_service.py
index dfa668f18d..2d906ad1e4 100644
--- a/api/db/services/knowledgebase_service.py
+++ b/api/db/services/knowledgebase_service.py
@@ -15,18 +15,19 @@
#
from datetime import datetime
-from peewee import fn, JOIN
+from peewee import JOIN, fn
+from api.constants import DATASET_NAME_LIMIT
from api.db import TenantPermission
from api.db.db_models import DB, Document, Knowledgebase, User, UserCanvas
-from api.db.services.common_service import CommonService
-from common.time_utils import current_timestamp, datetime_format
+from api.db.joint_services.tenant_model_service import get_composite_model_name_by_ids
from api.db.services import duplicate_name
+from api.db.services.common_service import CommonService
from api.db.services.user_service import TenantService
-from common.misc_utils import get_uuid
+from api.utils.api_utils import get_data_error_result, get_parser_config
from common.constants import StatusEnum
-from api.constants import DATASET_NAME_LIMIT
-from api.utils.api_utils import get_parser_config, get_data_error_result
+from common.misc_utils import get_uuid
+from common.time_utils import current_timestamp, datetime_format
def _base_model_name(embd_id: str) -> str:
@@ -35,9 +36,37 @@ def _base_model_name(embd_id: str) -> str:
return parts[0]
+def _kb_embedding_base_name(kb, resolved_names) -> str:
+ """Resolve a dataset's embedding reference to its base model name.
+
+ ``tenant_embd_id`` — or ``embd_id`` itself when it stores a raw
+ tenant_model id — is resolved through ``resolved_names`` (id to
+ ``model@instance@provider``). An id that no longer resolves falls back to
+ the composite base name when ``embd_id`` holds one, otherwise to the id
+ itself so only exact matches group together.
+ """
+ embd_id = (kb.embd_id or "").strip()
+ ref = (getattr(kb, "tenant_embd_id", None) or "").strip()
+ if not ref and "@" not in embd_id:
+ ref = embd_id
+ if not ref:
+ return _base_model_name(embd_id)
+ composite = resolved_names.get(ref)
+ if composite:
+ return _base_model_name(composite)
+ if embd_id and embd_id != ref:
+ return _base_model_name(embd_id)
+ return ref
+
+
def validate_dataset_embedding_models(kbs):
"""Validate that all given datasets use the same embedding model (or all use none).
+ Embedding references are resolved through tenant_model first, so datasets
+ storing a raw tenant_model id and datasets storing a legacy
+ ``model@instance@provider`` composite compare equal when they point at the
+ same model.
+
Returns an error message string on failure, or ``None`` on success.
"""
# Either all datasets have an embedding model, or none do. Mixing is not allowed.
@@ -46,7 +75,20 @@ def validate_dataset_embedding_models(kbs):
if has_embd and len(embd_ids) != len(kbs):
return "Cannot search across datasets where some have embedding models and others do not."
if has_embd:
- embd_nms = list({_base_model_name(eid) for eid in embd_ids})
+ candidates = []
+ for kb in kbs:
+ if not kb.embd_id:
+ continue
+ ref = (getattr(kb, "tenant_embd_id", None) or "").strip()
+ if not ref and "@" not in kb.embd_id:
+ ref = kb.embd_id.strip()
+ if ref:
+ candidates.append(ref)
+ try:
+ resolved_names = get_composite_model_name_by_ids(candidates)
+ except Exception: # noqa: BLE001 - resolution is best-effort; unresolvable ids keep their raw value
+ resolved_names = {}
+ embd_nms = {_kb_embedding_base_name(kb, resolved_names) for kb in kbs if kb.embd_id}
if len(embd_nms) > 1:
return f"Datasets use different embedding models: {[kb.embd_id for kb in kbs]}"
return None
@@ -129,8 +171,8 @@ class KnowledgebaseService(CommonService):
# Returns:
# If all documents are parsed successfully, returns (True, None)
# If any document is not fully parsed, returns (False, error_message)
- from common.constants import TaskStatus
from api.db.services.document_service import DocumentService
+ from common.constants import TaskStatus
# Get dataset information
kbs = cls.query(id=kb_id)
diff --git a/internal/agent/tool/retrieval_nlp.go b/internal/agent/tool/retrieval_nlp.go
index 7434c5fd6e..dc4976cc7d 100644
--- a/internal/agent/tool/retrieval_nlp.go
+++ b/internal/agent/tool/retrieval_nlp.go
@@ -215,7 +215,7 @@ func (a *NLPRetrievalAdapter) Search(ctx context.Context, db *gorm.DB, req Retri
if len(datasets.tenantIDs) != 1 {
return nil, fmt.Errorf("retrieval: datasets span multiple tenants")
}
- if err := validateEmbeddingModels(datasets.kbs); err != nil {
+ if err := validateEmbeddingModels(ctx, db, datasets.kbs); err != nil {
return nil, err
}
embeddingModel, err := a.resolveEmbeddingModel(ctx, datasets.kbs[0])
@@ -412,7 +412,7 @@ func (a *NLPRetrievalAdapter) resolveDatasets(
return &resolvedDatasets{kbs: kbs, kbIDs: resolvedKBIDs, tenantIDs: tenantIDs}, nil
}
-func validateEmbeddingModels(kbs []*entity.Knowledgebase) error {
+func validateEmbeddingModels(ctx context.Context, db *gorm.DB, kbs []*entity.Knowledgebase) error {
if len(kbs) == 0 {
return fmt.Errorf("retrieval: no datasets selected")
}
@@ -421,23 +421,26 @@ func validateEmbeddingModels(kbs []*entity.Knowledgebase) error {
return fmt.Errorf("retrieval: dataset record is nil")
}
}
- firstKey := knowledgebaseEmbeddingKey(kbs[0])
+ embdNameCache := make(map[string]string)
+ firstKey := knowledgebaseEmbeddingKey(ctx, db, kbs[0], embdNameCache)
for _, kb := range kbs[1:] {
- if knowledgebaseEmbeddingKey(kb) != firstKey {
+ if knowledgebaseEmbeddingKey(ctx, db, kb, embdNameCache) != firstKey {
return fmt.Errorf("retrieval: datasets use different embedding models")
}
}
return nil
}
-func knowledgebaseEmbeddingKey(kb *entity.Knowledgebase) string {
- if kb.TenantEmbdID != nil && strings.TrimSpace(*kb.TenantEmbdID) != "" {
- return "tenant:" + strings.TrimSpace(*kb.TenantEmbdID)
+// knowledgebaseEmbeddingKey groups datasets by their resolved base embedding
+// model name (e.g. "BAAI/bge-m3"), matching the chat/dataset-search
+// validation, so datasets pointing at the same model through different
+// provider instances or storage forms (tenant_model id vs legacy composite
+// name) retrieve together.
+func knowledgebaseEmbeddingKey(ctx context.Context, db *gorm.DB, kb *entity.Knowledgebase, cache map[string]string) string {
+ if strings.TrimSpace(kb.EmbdID) == "" && (kb.TenantEmbdID == nil || strings.TrimSpace(*kb.TenantEmbdID) == "") {
+ return "default:" + strings.TrimSpace(kb.TenantID)
}
- if strings.TrimSpace(kb.EmbdID) != "" {
- return "embedding:" + strings.TrimSpace(kb.EmbdID)
- }
- return "default:" + strings.TrimSpace(kb.TenantID)
+ return "embedding:" + dao.NewKnowledgebaseDAO().EmbeddingBaseName(ctx, db, kb, cache)
}
func (a *NLPRetrievalAdapter) resolveEmbeddingModel(
diff --git a/internal/agent/tool/retrieval_nlp_test.go b/internal/agent/tool/retrieval_nlp_test.go
index ed15ee6cd8..2de87c92fe 100644
--- a/internal/agent/tool/retrieval_nlp_test.go
+++ b/internal/agent/tool/retrieval_nlp_test.go
@@ -437,7 +437,7 @@ func TestNLPRetrievalAdapter_ResolveEmbeddingModelPriority(t *testing.T) {
func TestValidateEmbeddingModelsRejectsDifferentTenantModels(t *testing.T) {
firstID := "tenant-embedding-1"
secondID := "tenant-embedding-2"
- err := validateEmbeddingModels([]*entity.Knowledgebase{
+ err := validateEmbeddingModels(t.Context(), nil, []*entity.Knowledgebase{
{ID: "kb-1", TenantID: "tenant-1", TenantEmbdID: &firstID},
{ID: "kb-2", TenantID: "tenant-1", TenantEmbdID: &secondID},
})
@@ -446,6 +446,28 @@ func TestValidateEmbeddingModelsRejectsDifferentTenantModels(t *testing.T) {
}
}
+func TestValidateEmbeddingModelsAllowsSameBaseAcrossInstances(t *testing.T) {
+ // Datasets using the same base embedding model through different provider
+ // instances must validate together, matching the chat/dataset-search rule.
+ err := validateEmbeddingModels(t.Context(), nil, []*entity.Knowledgebase{
+ {ID: "kb-1", TenantID: "tenant-1", EmbdID: "BAAI/bge-m3@renew@SILICONFLOW"},
+ {ID: "kb-2", TenantID: "tenant-1", EmbdID: "BAAI/bge-m3@COPY@SILICONFLOW"},
+ })
+ if err != nil {
+ t.Fatalf("expected same-base composites to be accepted, got %v", err)
+ }
+}
+
+func TestValidateEmbeddingModelsRejectsDifferentBases(t *testing.T) {
+ err := validateEmbeddingModels(t.Context(), nil, []*entity.Knowledgebase{
+ {ID: "kb-1", TenantID: "tenant-1", EmbdID: "BAAI/bge-m3@renew@SILICONFLOW"},
+ {ID: "kb-2", TenantID: "tenant-1", EmbdID: "Qwen/Qwen3-Embedding-0.6B@renew@SILICONFLOW"},
+ })
+ if err == nil {
+ t.Fatal("expected different base embedding models to be rejected")
+ }
+}
+
type fakeKnowledgebaseLookup struct {
kbs []*entity.Knowledgebase
err error
diff --git a/internal/common/format.go b/internal/common/format.go
index 7d1ac423c4..5cd807a0e9 100644
--- a/internal/common/format.go
+++ b/internal/common/format.go
@@ -58,6 +58,22 @@ func IsUUID(uuid string) bool {
return false
}
+// BaseModelName returns the bare model name of a (possibly composite) model
+// reference by stripping the trailing "@instance@provider" (or "@provider")
+// segments. The split is right-anchored so model names that legitimately
+// contain '@' (e.g. LM Studio quant suffixes) are preserved. Mirrors Python's
+// api/db/services/knowledgebase_service.py _base_model_name (rsplit("@", 2)[0]).
+func BaseModelName(modelName string) string {
+ if idx := strings.LastIndex(modelName, "@"); idx > 0 {
+ base := modelName[:idx]
+ if idx2 := strings.LastIndex(base, "@"); idx2 > 0 {
+ return base[:idx2]
+ }
+ return base
+ }
+ return modelName
+}
+
// ExtractCompositeName splits a composite model name into three parts.
// Returns (modelName, instanceName, providerName, true) on success,
// or ("", "", "", false) if the name is not a valid composite name.
diff --git a/internal/common/format_test.go b/internal/common/format_test.go
index 32c657f8d8..24bc1f0bcf 100644
--- a/internal/common/format_test.go
+++ b/internal/common/format_test.go
@@ -53,3 +53,25 @@ func TestChunkID_PreservesLeadingZero(t *testing.T) {
t.Fatalf("ChunkID length = %d, want 16", len(got))
}
}
+
+func TestBaseModelName(t *testing.T) {
+ tests := []struct {
+ name string
+ input string
+ want string
+ }{
+ {"bare model name stays", "BAAI/bge-m3", "BAAI/bge-m3"},
+ {"2-part composite strips provider", "BAAI/bge-m3@SILICONFLOW", "BAAI/bge-m3"},
+ {"3-part composite strips instance and provider", "BAAI/bge-m3@renew@SILICONFLOW", "BAAI/bge-m3"},
+ {"embedded @ in model name is preserved", "text-embedding-nomic-embed-text-v1.5@q8_0@lmstudio@LM-Studio", "text-embedding-nomic-embed-text-v1.5@q8_0"},
+ {"opaque id without @ stays intact", "2d8ff0a97d75431c8c91526549939328", "2d8ff0a97d75431c8c91526549939328"},
+ {"empty string", "", ""},
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := BaseModelName(tt.input); got != tt.want {
+ t.Fatalf("BaseModelName(%q) = %q, want %q", tt.input, got, tt.want)
+ }
+ })
+ }
+}
diff --git a/internal/dao/kb.go b/internal/dao/kb.go
index bd265e2c96..c723437a53 100644
--- a/internal/dao/kb.go
+++ b/internal/dao/kb.go
@@ -21,6 +21,7 @@ import (
"errors"
"fmt"
"path"
+ "ragflow/internal/common"
"ragflow/internal/entity"
"strconv"
@@ -59,6 +60,50 @@ func NewKnowledgebaseDAO() *KnowledgebaseDAO {
return &KnowledgebaseDAO{}
}
+// EmbeddingBaseName resolves a knowledge base's embedding model reference to
+// the bare model name (e.g. "BAAI/bge-m3") used to decide whether datasets
+// can be selected and searched together. tenant_embd_id — or embd_id itself
+// when it stores a raw tenant_model id — is resolved through tenant_model;
+// legacy composite "model@instance@provider" values are reduced with
+// common.BaseModelName. An id that no longer resolves falls back to the
+// composite base name when embd_id holds one, otherwise to the id itself so
+// only exact matches group together.
+func (dao *KnowledgebaseDAO) EmbeddingBaseName(ctx context.Context, db *gorm.DB, kb *entity.Knowledgebase, cache map[string]string) string {
+ raw := strings.TrimSpace(kb.EmbdID)
+ id := ""
+ if kb.TenantEmbdID != nil {
+ id = strings.TrimSpace(*kb.TenantEmbdID)
+ }
+ if id == "" && raw != "" && !strings.Contains(raw, "@") {
+ id = raw
+ }
+ if id == "" {
+ return common.BaseModelName(raw)
+ }
+ if cache != nil {
+ if cached, ok := cache[id]; ok {
+ return cached
+ }
+ }
+ base := ""
+ if db != nil {
+ if model, err := NewTenantModelDAO().GetByID(ctx, db, id); err == nil && model != nil {
+ base = strings.TrimSpace(model.ModelName)
+ }
+ }
+ if base == "" {
+ if raw != "" && raw != id {
+ base = common.BaseModelName(raw)
+ } else {
+ base = id
+ }
+ }
+ if cache != nil {
+ cache[id] = base
+ }
+ return base
+}
+
// Create creates a new knowledge base record
func (dao *KnowledgebaseDAO) Create(ctx context.Context, db *gorm.DB, kb *entity.Knowledgebase) error {
return db.WithContext(ctx).Create(kb).Error
diff --git a/internal/service/chat.go b/internal/service/chat.go
index a924a6c25c..13e2970bf4 100644
--- a/internal/service/chat.go
+++ b/internal/service/chat.go
@@ -401,7 +401,7 @@ func (s *ChatService) validateCreateDatasetIDs(ctx context.Context, value interf
kbs = append(kbs, kb)
}
- if err := ValidateDatasetEmbeddingModels(kbs); err != nil {
+ if err := ValidateDatasetEmbeddingModels(ctx, dao.DB, kbs); err != nil {
return nil, err
}
return normalizedIDs, nil
@@ -774,21 +774,6 @@ const (
pyDefaultEmptyResponse = "Sorry! No relevant content was found in the knowledge base!"
)
-// splitModelNameAndFactory extracts the base model name by stripping
-// provider and instance suffixes, matching Python's rsplit("@", 2)[0].
-func (s *ChatService) splitModelNameAndFactory(embeddingModelID string) string {
- if idx := strings.LastIndex(embeddingModelID, "@"); idx > 0 {
- // Strip the provider segment.
- base := embeddingModelID[:idx]
- // Strip the instance segment (second-to-last @).
- if idx2 := strings.LastIndex(base, "@"); idx2 > 0 {
- return base[:idx2]
- }
- return base
- }
- return embeddingModelID
-}
-
func (s *ChatService) getOwnedValidChat(ctx context.Context, userID, chatID string) (*entity.Chat, error) {
chat, err := s.chatDAO.GetByIDAndStatus(ctx, dao.DB, chatID, string(entity.StatusValid))
if err != nil {
@@ -1067,9 +1052,10 @@ func (s *ChatService) validateRESTDatasetIDs(ctx context.Context, value interfac
embeddingModelIDs := make([]string, 0, len(kbs))
seenEmbedIDs := make(map[string]struct{})
+ embdNameCache := make(map[string]string)
for _, kb := range kbs {
embeddingModelIDs = append(embeddingModelIDs, kb.EmbdID)
- seenEmbedIDs[s.splitModelNameAndFactory(kb.EmbdID)] = struct{}{}
+ seenEmbedIDs[s.kbDAO.EmbeddingBaseName(ctx, dao.DB, kb, embdNameCache)] = struct{}{}
}
if len(seenEmbedIDs) > 1 {
return nil, fmt.Errorf("datasets use different embedding models: %v", embeddingModelIDs)
@@ -1112,7 +1098,7 @@ func (s *ChatService) resolveRESTRerankID(ctx context.Context, rerankID, tenantI
if rerankID == "" {
return "", nil
}
- baseName := s.splitModelNameAndFactory(rerankID)
+ baseName := common.BaseModelName(rerankID)
if _, ok := defaultRerankModels[baseName]; ok {
return "", nil
}
diff --git a/internal/service/chat_pipeline.go b/internal/service/chat_pipeline.go
index f029701a8c..05f689eb32 100644
--- a/internal/service/chat_pipeline.go
+++ b/internal/service/chat_pipeline.go
@@ -1971,7 +1971,7 @@ func (s *ChatPipelineService) getModels(ctx context.Context, chat *entity.Chat)
// Embedding model.
var embModel *modelModule.EmbeddingModel
if len(kbs) > 0 {
- if err := ValidateDatasetEmbeddingModels(kbs); err != nil {
+ if err := ValidateDatasetEmbeddingModels(ctx, dao.DB, kbs); err != nil {
return nil, nil, nil, nil, nil, err
}
if kbs[0].EmbdID != "" {
diff --git a/internal/service/chunk/chunk.go b/internal/service/chunk/chunk.go
index 8c14cebf88..0eebfa677e 100644
--- a/internal/service/chunk/chunk.go
+++ b/internal/service/chunk/chunk.go
@@ -192,11 +192,12 @@ func (s *ChunkService) RetrievalTest(ctx context.Context, req *service.Retrieval
}
}
- // Check if all kbs have the same embedding model
+ // Check if all kbs resolve to the same base embedding model
if len(kbRecords) > 1 {
- firstEmbeddingKey := knowledgebaseEmbeddingKey(kbRecords[0], tenantIDs[0])
+ embdNameCache := make(map[string]string)
+ firstEmbeddingKey := knowledgebaseEmbeddingKey(ctx, dao.DB, kbRecords[0], tenantIDs[0], embdNameCache)
for i := 1; i < len(kbRecords); i++ {
- if knowledgebaseEmbeddingKey(kbRecords[i], tenantIDs[i]) != firstEmbeddingKey {
+ if knowledgebaseEmbeddingKey(ctx, dao.DB, kbRecords[i], tenantIDs[i], embdNameCache) != firstEmbeddingKey {
return nil, fmt.Errorf("cannot retrieve across datasets with different embedding models")
}
}
@@ -444,14 +445,15 @@ func (s *ChunkService) RetrievalTest(ctx context.Context, req *service.Retrieval
}, nil
}
-func knowledgebaseEmbeddingKey(kb *entity.Knowledgebase, tenantID string) string {
- if kb.TenantEmbdID != nil && *kb.TenantEmbdID != "" {
- return fmt.Sprintf("tenant:%s", *kb.TenantEmbdID)
- }
- if kb.EmbdID == "" {
+// knowledgebaseEmbeddingKey groups datasets by their resolved base embedding
+// model name (e.g. "BAAI/bge-m3") so datasets pointing at the same model
+// through different provider instances or storage forms (tenant_model id vs
+// legacy composite name) retrieve together.
+func knowledgebaseEmbeddingKey(ctx context.Context, db *gorm.DB, kb *entity.Knowledgebase, tenantID string, cache map[string]string) string {
+ if strings.TrimSpace(kb.EmbdID) == "" && (kb.TenantEmbdID == nil || strings.TrimSpace(*kb.TenantEmbdID) == "") {
return fmt.Sprintf("default:%s", tenantID)
}
- return fmt.Sprintf("embd:%s", kb.EmbdID)
+ return "embd:" + dao.NewKnowledgebaseDAO().EmbeddingBaseName(ctx, db, kb, cache)
}
// hydrateChunkVectors replaces zero (placeholder) vectors in chunks with real
diff --git a/internal/service/chunk/chunk_test.go b/internal/service/chunk/chunk_test.go
index 2a54adac26..fe529a0904 100644
--- a/internal/service/chunk/chunk_test.go
+++ b/internal/service/chunk/chunk_test.go
@@ -81,6 +81,7 @@ func TestHydrateChunkVectors_NoDim(t *testing.T) {
func TestKnowledgebaseEmbeddingKey(t *testing.T) {
tenantEmbdID := "42"
+ staleTenantEmbdID := "stale-id"
tests := []struct {
name string
@@ -89,12 +90,20 @@ func TestKnowledgebaseEmbeddingKey(t *testing.T) {
want string
}{
{
- name: "uses tenant embedding id before embd id",
+ name: "resolves tenant embedding id to base model name",
kb: &entity.Knowledgebase{
EmbdID: "shared-model",
TenantEmbdID: &tenantEmbdID,
},
- want: "tenant:42",
+ want: "embd:BAAI/bge-m3",
+ },
+ {
+ name: "stale tenant embedding id falls back to composite base name",
+ kb: &entity.Knowledgebase{
+ EmbdID: "BAAI/bge-m3@1@SILICONFLOW",
+ TenantEmbdID: &staleTenantEmbdID,
+ },
+ want: "embd:BAAI/bge-m3",
},
{
name: "uses embd id without tenant embedding id",
@@ -117,11 +126,29 @@ func TestKnowledgebaseEmbeddingKey(t *testing.T) {
},
want: "embd:shared-model",
},
+ {
+ name: "legacy composite reduces to base model name",
+ kb: &entity.Knowledgebase{
+ EmbdID: "BAAI/bge-m3@2@SILICONFLOW",
+ },
+ want: "embd:BAAI/bge-m3",
+ },
+ }
+
+ db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{TranslateError: true})
+ if err != nil {
+ t.Fatalf("failed to open sqlite: %v", err)
+ }
+ if err := db.AutoMigrate(&entity.TenantModel{}); err != nil {
+ t.Fatalf("failed to migrate test schema: %v", err)
+ }
+ if err := db.Create(&entity.TenantModel{ID: "42", ModelName: "BAAI/bge-m3"}).Error; err != nil {
+ t.Fatalf("failed to seed tenant_model: %v", err)
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
- if got := knowledgebaseEmbeddingKey(tt.kb, tt.tenantID); got != tt.want {
+ if got := knowledgebaseEmbeddingKey(t.Context(), db, tt.kb, tt.tenantID, map[string]string{}); got != tt.want {
t.Fatalf("knowledgebaseEmbeddingKey() = %q, want %q", got, tt.want)
}
})
diff --git a/internal/service/dataset/search.go b/internal/service/dataset/search.go
index 272a10a894..4394af649e 100644
--- a/internal/service/dataset/search.go
+++ b/internal/service/dataset/search.go
@@ -102,7 +102,7 @@ func (d *DatasetService) SearchDatasets(ctx context.Context, req *service.Search
}
// Check if all kbs have the same embedding model
- if err := service.ValidateDatasetEmbeddingModels(kbRecords); err != nil {
+ if err := service.ValidateDatasetEmbeddingModels(ctx, dao.DB, kbRecords); err != nil {
return nil, err
}
diff --git a/internal/service/pipeline_params.go b/internal/service/pipeline_params.go
index 88fbf0d23a..4adddf06ac 100644
--- a/internal/service/pipeline_params.go
+++ b/internal/service/pipeline_params.go
@@ -10,6 +10,8 @@ import (
"ragflow/internal/dao"
"ragflow/internal/entity"
pipelinepkg "ragflow/internal/ingestion/pipeline"
+
+ "gorm.io/gorm"
)
// loadCanvasDSLJSON returns the DSL JSON for a custom canvas pipeline. The
@@ -97,24 +99,21 @@ func ResolveComponentParamsDefaults(ctx context.Context, parserID string, pipeli
}
// ValidateDatasetEmbeddingModels checks that all knowledge bases in the list
-// either have an embedding model or none do, and that they all use the same model.
-func ValidateDatasetEmbeddingModels(kbs []*entity.Knowledgebase) error {
- embdIDs := make(map[string]struct{})
+// either have an embedding model or none do, and that they all resolve to the
+// same base embedding model name (e.g. "BAAI/bge-m3"). Embedding references
+// are resolved through tenant_model first, so datasets storing a raw
+// tenant_model id and datasets storing a legacy "model@instance@provider"
+// composite compare equal when they point at the same model.
+func ValidateDatasetEmbeddingModels(ctx context.Context, db *gorm.DB, kbs []*entity.Knowledgebase) error {
+ embdNames := make(map[string]struct{})
hasEmbd := false
noEmbd := false
+ cache := make(map[string]string)
+ kbDAO := dao.NewKnowledgebaseDAO()
for _, kb := range kbs {
if kb.EmbdID != "" {
hasEmbd = true
- baseName := kb.EmbdID
- if idx := strings.LastIndex(kb.EmbdID, "@"); idx > 0 {
- baseName = kb.EmbdID[:idx]
- // Strip the second-to-last @-segment too (instance name),
- // matching Python's _base_model_name which uses rsplit("@", 2).
- if idx2 := strings.LastIndex(baseName, "@"); idx2 > 0 {
- baseName = baseName[:idx2]
- }
- }
- embdIDs[baseName] = struct{}{}
+ embdNames[kbDAO.EmbeddingBaseName(ctx, db, kb, cache)] = struct{}{}
} else {
noEmbd = true
}
@@ -122,7 +121,7 @@ func ValidateDatasetEmbeddingModels(kbs []*entity.Knowledgebase) error {
if hasEmbd && noEmbd {
return fmt.Errorf("cannot search across datasets where some have embedding models and others do not")
}
- if len(embdIDs) > 1 {
+ if len(embdNames) > 1 {
return fmt.Errorf("datasets use different embedding models: %v", getEmbdIDs(kbs))
}
return nil
diff --git a/internal/service/pipeline_params_test.go b/internal/service/pipeline_params_test.go
index a9da3ccbce..fcb56e9bbd 100644
--- a/internal/service/pipeline_params_test.go
+++ b/internal/service/pipeline_params_test.go
@@ -4,14 +4,32 @@ import (
"testing"
"ragflow/internal/entity"
+
+ "github.com/glebarez/sqlite"
+ "gorm.io/gorm"
)
+func setupValidateEmbeddingTestDB(t *testing.T) *gorm.DB {
+ t.Helper()
+
+ db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{
+ TranslateError: true,
+ })
+ if err != nil {
+ t.Fatalf("failed to open sqlite: %v", err)
+ }
+ if err := db.AutoMigrate(&entity.TenantModel{}); err != nil {
+ t.Fatalf("failed to migrate test schema: %v", err)
+ }
+ return db
+}
+
func TestValidateDatasetEmbeddingModels_AllHaveEmbeddingModel(t *testing.T) {
kbs := []*entity.Knowledgebase{
{EmbdID: "BAAI/bge-large-zh-v1.5@Builtin"},
{EmbdID: "BAAI/bge-large-zh-v1.5@Builtin"},
}
- if err := ValidateDatasetEmbeddingModels(kbs); err != nil {
+ if err := ValidateDatasetEmbeddingModels(t.Context(), nil, kbs); err != nil {
t.Fatalf("expected nil, got %v", err)
}
}
@@ -21,7 +39,7 @@ func TestValidateDatasetEmbeddingModels_NoneHasEmbeddingModel(t *testing.T) {
{EmbdID: ""},
{EmbdID: ""},
}
- if err := ValidateDatasetEmbeddingModels(kbs); err != nil {
+ if err := ValidateDatasetEmbeddingModels(t.Context(), nil, kbs); err != nil {
t.Fatalf("expected nil, got %v", err)
}
}
@@ -31,7 +49,7 @@ func TestValidateDatasetEmbeddingModels_MixedErrors(t *testing.T) {
{EmbdID: "BAAI/bge-large-zh-v1.5@Builtin"},
{EmbdID: ""},
}
- err := ValidateDatasetEmbeddingModels(kbs)
+ err := ValidateDatasetEmbeddingModels(t.Context(), nil, kbs)
if err == nil {
t.Fatal("expected error for mixed embedding")
}
@@ -45,7 +63,7 @@ func TestValidateDatasetEmbeddingModels_DifferentEmbeddingsErrors(t *testing.T)
{EmbdID: "model-a@provider-1"},
{EmbdID: "model-b@provider-2"},
}
- err := ValidateDatasetEmbeddingModels(kbs)
+ err := ValidateDatasetEmbeddingModels(t.Context(), nil, kbs)
if err == nil {
t.Fatal("expected error for different embeddings")
}
@@ -58,7 +76,7 @@ func TestValidateDatasetEmbeddingModels_SameBaseDifferentInstanceOK(t *testing.T
{EmbdID: "BAAI/bge-large-zh-v1.5@instance1@provider1"},
{EmbdID: "BAAI/bge-large-zh-v1.5@instance2@provider2"},
}
- if err := ValidateDatasetEmbeddingModels(kbs); err != nil {
+ if err := ValidateDatasetEmbeddingModels(t.Context(), nil, kbs); err != nil {
t.Fatalf("expected nil, got %v", err)
}
}
@@ -68,14 +86,84 @@ func TestValidateDatasetEmbeddingModels_DifferentBasesErrors(t *testing.T) {
{EmbdID: "model-a@instance1@provider1"},
{EmbdID: "model-b@instance2@provider2"},
}
- err := ValidateDatasetEmbeddingModels(kbs)
+ err := ValidateDatasetEmbeddingModels(t.Context(), nil, kbs)
if err == nil {
t.Fatal("expected error for different base models")
}
}
func TestValidateDatasetEmbeddingModels_EmptyList(t *testing.T) {
- if err := ValidateDatasetEmbeddingModels(nil); err != nil {
+ if err := ValidateDatasetEmbeddingModels(t.Context(), nil, nil); err != nil {
t.Fatalf("expected nil for empty list, got %v", err)
}
}
+
+func TestValidateDatasetEmbeddingModels_TenantModelIDsResolveToSameBase(t *testing.T) {
+ db := setupValidateEmbeddingTestDB(t)
+ for _, m := range []entity.TenantModel{
+ {ID: "11111111111111111111111111111111", ModelName: "BAAI/bge-m3"},
+ {ID: "22222222222222222222222222222222", ModelName: "BAAI/bge-m3"},
+ } {
+ if err := db.Create(&m).Error; err != nil {
+ t.Fatalf("failed to seed tenant_model: %v", err)
+ }
+ }
+
+ // Two KBs referencing different tenant_model rows (e.g. different provider
+ // instances) that serve the same base model must validate together.
+ kbs := []*entity.Knowledgebase{
+ {EmbdID: "11111111111111111111111111111111"},
+ {EmbdID: "22222222222222222222222222222222"},
+ }
+ if err := ValidateDatasetEmbeddingModels(t.Context(), db, kbs); err != nil {
+ t.Fatalf("expected nil, got %v", err)
+ }
+}
+
+func TestValidateDatasetEmbeddingModels_TenantModelIDAndLegacyCompositeMatch(t *testing.T) {
+ db := setupValidateEmbeddingTestDB(t)
+ if err := db.Create(&entity.TenantModel{ID: "11111111111111111111111111111111", ModelName: "BAAI/bge-m3"}).Error; err != nil {
+ t.Fatalf("failed to seed tenant_model: %v", err)
+ }
+
+ // One KB stores the tenant_model id, the other a legacy composite name
+ // pointing at the same base model through another instance.
+ kbs := []*entity.Knowledgebase{
+ {EmbdID: "11111111111111111111111111111111"},
+ {EmbdID: "BAAI/bge-m3@2@SILICONFLOW"},
+ }
+ if err := ValidateDatasetEmbeddingModels(t.Context(), db, kbs); err != nil {
+ t.Fatalf("expected nil, got %v", err)
+ }
+}
+
+func TestValidateDatasetEmbeddingModels_ResolvedDifferentBasesError(t *testing.T) {
+ db := setupValidateEmbeddingTestDB(t)
+ for _, m := range []entity.TenantModel{
+ {ID: "11111111111111111111111111111111", ModelName: "BAAI/bge-m3"},
+ {ID: "22222222222222222222222222222222", ModelName: "Qwen/Qwen3-Embedding-0.6B"},
+ } {
+ if err := db.Create(&m).Error; err != nil {
+ t.Fatalf("failed to seed tenant_model: %v", err)
+ }
+ }
+
+ kbs := []*entity.Knowledgebase{
+ {EmbdID: "11111111111111111111111111111111"},
+ {EmbdID: "22222222222222222222222222222222"},
+ }
+ if err := ValidateDatasetEmbeddingModels(t.Context(), db, kbs); err == nil {
+ t.Fatal("expected error for different resolved base models")
+ }
+}
+
+func TestValidateDatasetEmbeddingModels_UnresolvableIDsStayIsolated(t *testing.T) {
+ // Stale ids that no longer resolve must not suddenly compare equal.
+ kbs := []*entity.Knowledgebase{
+ {EmbdID: "11111111111111111111111111111111"},
+ {EmbdID: "22222222222222222222222222222222"},
+ }
+ if err := ValidateDatasetEmbeddingModels(t.Context(), nil, kbs); err == nil {
+ t.Fatal("expected error for distinct unresolvable embedding ids")
+ }
+}
diff --git a/test/unit_test/api/db/services/test_knowledgebase_embedding_validation.py b/test/unit_test/api/db/services/test_knowledgebase_embedding_validation.py
new file mode 100644
index 0000000000..4ad63ada47
--- /dev/null
+++ b/test/unit_test/api/db/services/test_knowledgebase_embedding_validation.py
@@ -0,0 +1,174 @@
+#
+# Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""Regression tests for validate_dataset_embedding_models() in
+api.db.services.knowledgebase_service.
+
+Datasets may store their embedding reference either as a tenant_model id
+(hex) or as a legacy composite ``model@instance@provider`` string. Datasets
+that resolve to the same base embedding model must validate together even
+when the storage forms or provider instances differ (e.g.
+``BAAI/bge-m3@renew@SILICONFLOW`` vs ``BAAI/bge-m3@COPY@SILICONFLOW``).
+
+This test loads only the relevant function definitions from the source file
+via AST, so it doesn't pull in the full ``api.db.db_models`` import chain and
+can run in any minimal pytest environment.
+"""
+
+import ast
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+pytestmark = pytest.mark.p2
+
+
+def _load_validator(resolved_names):
+ """Exec the validator + helpers from the production source file with a
+ stubbed ``get_composite_model_name_by_ids``."""
+ src_path = Path(__file__).resolve().parents[5] / "api" / "db" / "services" / "knowledgebase_service.py"
+ tree = ast.parse(src_path.read_text(encoding="utf-8"))
+ wanted = {
+ "_base_model_name",
+ "_kb_embedding_base_name",
+ "validate_dataset_embedding_models",
+ }
+ nodes = [node for node in tree.body if isinstance(node, ast.FunctionDef) and node.name in wanted]
+ assert len(nodes) == len(wanted), f"missing functions: {wanted - {n.name for n in nodes}}"
+ module = ast.Module(body=nodes, type_ignores=[])
+ ns = {"get_composite_model_name_by_ids": lambda _ids: resolved_names}
+ exec(compile(module, str(src_path), "exec"), ns) # noqa: S102 - exec'ing AST-extracted functions from our own source file
+ return ns["validate_dataset_embedding_models"]
+
+
+def test_same_composite_validates():
+ validate = _load_validator({})
+ kbs = [
+ SimpleNamespace(embd_id="BAAI/bge-m3@1@SILICONFLOW", tenant_embd_id=None),
+ SimpleNamespace(embd_id="BAAI/bge-m3@1@SILICONFLOW", tenant_embd_id=None),
+ ]
+ assert validate(kbs) is None
+
+
+def test_same_base_different_instances_validate():
+ """The search-settings bug: same model/provider, different instance name."""
+ validate = _load_validator({})
+ kbs = [
+ SimpleNamespace(embd_id="BAAI/bge-m3@renew@SILICONFLOW", tenant_embd_id=None),
+ SimpleNamespace(embd_id="BAAI/bge-m3@COPY@SILICONFLOW", tenant_embd_id=None),
+ ]
+ assert validate(kbs) is None
+
+
+def test_different_base_models_rejected():
+ validate = _load_validator({})
+ kbs = [
+ SimpleNamespace(embd_id="BAAI/bge-m3@1@SILICONFLOW", tenant_embd_id=None),
+ SimpleNamespace(embd_id="Qwen/Qwen3-Embedding-0.6B@1@SILICONFLOW", tenant_embd_id=None),
+ ]
+ assert "different embedding models" in validate(kbs)
+
+
+def test_tenant_model_id_and_composite_resolve_together():
+ """A raw tenant_model id and a legacy composite pointing at the same base
+ model must validate together."""
+ validate = _load_validator({"5fb939ba64d04dd2b6dd9c1c08775d52": "BAAI/bge-m3@1@SILICONFLOW"})
+ kbs = [
+ SimpleNamespace(
+ embd_id="5fb939ba64d04dd2b6dd9c1c08775d52",
+ tenant_embd_id="5fb939ba64d04dd2b6dd9c1c08775d52",
+ ),
+ SimpleNamespace(embd_id="BAAI/bge-m3@2@SILICONFLOW", tenant_embd_id=None),
+ ]
+ assert validate(kbs) is None
+
+
+def test_two_tenant_model_ids_resolving_to_same_base_validate():
+ validate = _load_validator(
+ {
+ "5fb939ba64d04dd2b6dd9c1c08775d52": "BAAI/bge-m3@1@SILICONFLOW",
+ "fdbbd8f9a0564a6f92d068bd596de861": "BAAI/bge-m3@2@SILICONFLOW",
+ }
+ )
+ kbs = [
+ SimpleNamespace(
+ embd_id="5fb939ba64d04dd2b6dd9c1c08775d52",
+ tenant_embd_id="5fb939ba64d04dd2b6dd9c1c08775d52",
+ ),
+ SimpleNamespace(
+ embd_id="fdbbd8f9a0564a6f92d068bd596de861",
+ tenant_embd_id="fdbbd8f9a0564a6f92d068bd596de861",
+ ),
+ ]
+ assert validate(kbs) is None
+
+
+def test_resolved_different_bases_rejected():
+ validate = _load_validator(
+ {
+ "5fb939ba64d04dd2b6dd9c1c08775d52": "BAAI/bge-m3@1@SILICONFLOW",
+ "b346fecb098e4305b58926f1bae6bbc9": "Qwen/Qwen3-Embedding-0.6B@1@SILICONFLOW",
+ }
+ )
+ kbs = [
+ SimpleNamespace(
+ embd_id="5fb939ba64d04dd2b6dd9c1c08775d52",
+ tenant_embd_id="5fb939ba64d04dd2b6dd9c1c08775d52",
+ ),
+ SimpleNamespace(
+ embd_id="b346fecb098e4305b58926f1bae6bbc9",
+ tenant_embd_id="b346fecb098e4305b58926f1bae6bbc9",
+ ),
+ ]
+ assert "different embedding models" in validate(kbs)
+
+
+def test_unresolvable_ids_stay_isolated():
+ validate = _load_validator({})
+ kbs = [
+ SimpleNamespace(embd_id="2d8ff0a97d75431c8c91526549939328", tenant_embd_id="2d8ff0a97d75431c8c91526549939328"),
+ SimpleNamespace(embd_id="BAAI/bge-m3@1@SILICONFLOW", tenant_embd_id=None),
+ ]
+ assert "different embedding models" in validate(kbs)
+
+
+def test_stale_tenant_id_falls_back_to_composite_base():
+ """A KB whose tenant_embd_id no longer resolves still groups by its
+ legacy composite embd_id."""
+ validate = _load_validator({})
+ kbs = [
+ SimpleNamespace(embd_id="BAAI/bge-m3@1@SILICONFLOW", tenant_embd_id="2540bad87b7511f197c0d16229aaaa64"),
+ SimpleNamespace(embd_id="BAAI/bge-m3@2@SILICONFLOW", tenant_embd_id=None),
+ ]
+ assert validate(kbs) is None
+
+
+def test_mixed_embedding_and_none_rejected():
+ validate = _load_validator({})
+ kbs = [
+ SimpleNamespace(embd_id="BAAI/bge-m3@1@SILICONFLOW", tenant_embd_id=None),
+ SimpleNamespace(embd_id="", tenant_embd_id=None),
+ ]
+ assert "some have embedding models and others do not" in validate(kbs)
+
+
+def test_all_without_embedding_validates():
+ validate = _load_validator({})
+ kbs = [
+ SimpleNamespace(embd_id="", tenant_embd_id=None),
+ SimpleNamespace(embd_id="", tenant_embd_id=None),
+ ]
+ assert validate(kbs) is None
diff --git a/web/src/components/knowledge-base-item.tsx b/web/src/components/knowledge-base-item.tsx
index 3e96698575..b2e58b05f8 100644
--- a/web/src/components/knowledge-base-item.tsx
+++ b/web/src/components/knowledge-base-item.tsx
@@ -21,6 +21,7 @@ import {
} from '@/hooks/use-knowledge-request';
import { IDataset } from '@/interfaces/database/dataset';
import { useBuildQueryVariableOptions } from '@/pages/agent/hooks/use-get-begin-query';
+import { getEmbeddingBaseName } from '@/utils/llm-util';
import { useDebounce } from 'ahooks';
import { toLower } from 'lodash';
import { type ReactNode, useCallback, useMemo, useRef, useState } from 'react';
@@ -94,9 +95,12 @@ export function useDisableDifferenceEmbeddingDataset(name: string) {
);
}, [datasetListOrigin, selectedDatasetIds, missingDatasets]);
- const selectedEmbedId = useMemo(() => {
+ // Datasets are mutually selectable when their embedding models resolve to
+ // the same base model name, even if they use different provider instances
+ // (e.g. "BAAI/bge-m3@renew@SILICONFLOW" vs "BAAI/bge-m3@COPY@SILICONFLOW").
+ const selectedEmbedBaseName = useMemo(() => {
const data = datasetList?.find((item) => item.id === datasetId?.[0]);
- return data?.embedding_model ?? '';
+ return getEmbeddingBaseName(data?.embedding_model);
}, [datasetId, datasetList]);
const nextOptions = useMemo(() => {
@@ -126,12 +130,13 @@ export function useDisableDifferenceEmbeddingDataset(name: string) {
disabled:
item.chunk_count <= 0 ||
item.chunk_method === DocumentParserType.Tag ||
- (item.embedding_model !== selectedEmbedId && selectedEmbedId !== ''),
+ (selectedEmbedBaseName !== '' &&
+ getEmbeddingBaseName(item.embedding_model) !== selectedEmbedBaseName),
};
});
return datasetListMap;
- }, [datasetList, selectedEmbedId]);
+ }, [datasetList, selectedEmbedBaseName]);
const handleSearchChange = useCallback((value: string) => {
setSearchString(value);
diff --git a/web/src/utils/llm-util.ts b/web/src/utils/llm-util.ts
index a1a12f4113..7f18b9d810 100644
--- a/web/src/utils/llm-util.ts
+++ b/web/src/utils/llm-util.ts
@@ -123,6 +123,21 @@ export function parseModelValue(val: string) {
};
}
+/**
+ * Base embedding model name used to decide whether two datasets can be
+ * selected and searched together. Composite references
+ * ("modelName@instanceName@providerName" or "modelName@providerName") reduce
+ * to the bare model name, so datasets using the same embedding model through
+ * different provider instances still group together. Opaque values without
+ * '@' (e.g. an unresolved tenant_model id) are returned unchanged, so only
+ * exact matches group together. Mirrors the backend's base-name comparison
+ * (Python `_base_model_name`, Go `common.BaseModelName`).
+ */
+export function getEmbeddingBaseName(embeddingModel?: string | null): string {
+ if (!embeddingModel) return '';
+ return parseModelValue(embeddingModel)?.model_name ?? embeddingModel;
+}
+
// Extract model name and factory ID from a model UUID
// Supports both "model_name@factory_id" and "model_name@factory_id#instance_name".
// Uses right-anchored split for the same reason as parseModelValue:
diff --git a/web/src/utils/tests/llm-util.test.ts b/web/src/utils/tests/llm-util.test.ts
index 776c421593..4b9392c26f 100644
--- a/web/src/utils/tests/llm-util.test.ts
+++ b/web/src/utils/tests/llm-util.test.ts
@@ -1,4 +1,9 @@
-import { buildModelValue, parseModelUuid, parseModelValue } from '../llm-util';
+import {
+ buildModelValue,
+ getEmbeddingBaseName,
+ parseModelUuid,
+ parseModelValue,
+} from '../llm-util';
// Composite model keys are right-anchored:
// "model_name@instance_name@provider_name" or "model_name@provider_name".
@@ -117,3 +122,41 @@ describe('parseModelUuid — right-anchored', () => {
});
});
});
+
+describe('getEmbeddingBaseName — dataset co-selection grouping', () => {
+ test('3-part composite reduces to bare model name', () => {
+ expect(getEmbeddingBaseName('BAAI/bge-m3@renew@SILICONFLOW')).toBe(
+ 'BAAI/bge-m3',
+ );
+ });
+
+ test('same model through different instances shares one base name', () => {
+ expect(
+ getEmbeddingBaseName('BAAI/bge-m3@renew@SILICONFLOW') ===
+ getEmbeddingBaseName('BAAI/bge-m3@COPY@SILICONFLOW'),
+ ).toBe(true);
+ });
+
+ test('2-part composite strips the provider', () => {
+ expect(getEmbeddingBaseName('BAAI/bge-m3@SILICONFLOW')).toBe('BAAI/bge-m3');
+ });
+
+ test('model names containing "@" keep their suffix', () => {
+ expect(
+ getEmbeddingBaseName(
+ 'text-embedding-nomic-embed-text-v1.5@q8_0@lmstudio@LM-Studio',
+ ),
+ ).toBe('text-embedding-nomic-embed-text-v1.5@q8_0');
+ });
+
+ test('opaque tenant_model id is returned unchanged', () => {
+ expect(getEmbeddingBaseName('2d8ff0a97d75431c8c91526549939328')).toBe(
+ '2d8ff0a97d75431c8c91526549939328',
+ );
+ });
+
+ test('empty and undefined values produce an empty base name', () => {
+ expect(getEmbeddingBaseName('')).toBe('');
+ expect(getEmbeddingBaseName(undefined)).toBe('');
+ });
+});