Skip to content

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

refa: simplify model resolution and rerank calls (#20457)

buua4369e548794e717
diff --git a/cmd/ragflow_server.go b/cmd/ragflow_server.go
index 471422aa43..244b25758c 100644
--- a/cmd/ragflow_server.go
+++ b/cmd/ragflow_server.go
@@ -69,7 +69,6 @@ import (
infnative "ragflow/internal/deepdoc/parser/pdf/inference/native_analyzer"
"ragflow/internal/engine"
"ragflow/internal/engine/kvrocks"
- "ragflow/internal/entity"
_ "ragflow/internal/ingestion/wire"
"ragflow/internal/server"
"ragflow/internal/server/config"
@@ -939,15 +938,14 @@ func runIngestor(ctx context.Context, cancel context.CancelFunc, serverName stri
// unavailable, skipping dataset-nav upsert"), leaving the dataset tree empty.
// The embedder resolves the tenant's embedding model on demand, so both
// Search and UpsertDoc can embed queries/summaries automatically.
- navModelService := service.NewModelProviderService()
- navService := nlp.NewNavService(service.NewNavEmbedder(navModelService, ""))
+ navService := nlp.NewNavService(service.NewNavEmbedder(service.NewModelFactory(), ""))
// The cluster namer/merger is the counterpart of Python's
// _llm_create_summary / _llm_merge: a new cluster is named after the model's
// topic title and an existing cluster's description is fused with the joining
// document. Passing an empty model ref resolves each tenant's default chat
// model on demand; without one the nav service keeps its deterministic
// behaviour.
- navService.SetNavMergeLLM(service.NewNavMergeLLM(navModelService, ""))
+ navService.SetNavMergeLLM(service.NewNavMergeLLM(service.NewModelFactory(), ""))
nav.SetNavService(navService)
// Memory extraction runs on the Ingestor's shared NATS consumer + worker
// pool (task_type="memory" dispatched by handleAndExecute -> executeMemoryTask),
@@ -1123,8 +1121,8 @@ func startServer(ctx context.Context, serverName string, arguments *serverArgs)
memoryService := service.NewMemoryService()
mcpService := service.NewMCPService()
modelProviderService := service.NewModelProviderService()
- modelCallService := service.NewModelCallServiceWithProviderService(modelProviderService)
- modelSolver := service.NewModelSolver()
+ modelFactory := service.NewModelFactory()
+ modelCallService := service.NewModelCallServiceWithProviderService(modelProviderService, modelFactory)
// Wire the real MemorySaver so the Message component can persist
// conversation turns to memory stores declared in the canvas DSL.
@@ -1142,22 +1140,27 @@ func startServer(ctx context.Context, serverName string, arguments *serverArgs)
retrievalAdapter := agenttool.NewNLPRetrievalAdapterFromDeps(
docEngine,
documentDAO,
- nil,
+ agenttool.RetrievalModelConstructors{
+ Embedding: func(ctx context.Context, tenantID, modelRef string) (*modelModule.EmbeddingModel, error) {
+ access := service.ModelAccess{TenantID: tenantID}
+ if strings.TrimSpace(modelRef) == "" {
+ return modelFactory.NewDefaultEmbeddingModel(ctx, access)
+ }
+ return modelFactory.NewEmbeddingModel(ctx, access, modelRef)
+ },
+ Chat: func(ctx context.Context, tenantID, modelRef string) (*modelModule.ChatModel, error) {
+ access := service.ModelAccess{TenantID: tenantID}
+ if strings.TrimSpace(modelRef) == "" {
+ return modelFactory.NewDefaultChatModel(ctx, access)
+ }
+ return modelFactory.NewChatModel(ctx, access, modelRef)
+ },
+ Rerank: func(ctx context.Context, tenantID, modelRef string) (*modelModule.RerankModel, error) {
+ return modelFactory.NewRerankModel(ctx, service.ModelAccess{TenantID: tenantID}, modelRef)
+ },
+ },
retrievalEnhancer,
)
- retrievalAdapter.SetModelConfigResolver(func(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
- var target *service.ModelTarget
- var err error
- if strings.TrimSpace(modelRef) == "" {
- target, err = modelSolver.ResolveDefaultModelConfig(ctx, tenantID, modelType)
- } else {
- target, err = modelSolver.ResolveModelConfig(ctx, tenantID, modelType, modelRef)
- }
- if err != nil {
- return nil, "", nil, 0, err
- }
- return target.Driver, target.ModelName, target.APIConfig, target.MaxTokens, nil
- })
agenttool.SetRetrievalService(retrievalAdapter)
agenttool.SetMemoryRetrievalService(retrievalbridge.NewMemoryAdapter(memoryService))
common.Info("agent: retrieval service adapter installed")
@@ -1179,7 +1182,7 @@ func startServer(ctx context.Context, serverName string, arguments *serverArgs)
// reasoning chats.
runtime.SetRetrievalService(retrievalbridge.NewRuntimeAdapter(retrievalAdapter))
agentic_rag.SetAgenticLoop(agentic_rag.NewAgenticLoop())
- service.SetHarnessRetriever(retrievalbridge.NewHarnessRetriever(modelProviderService, metadataService, docEngine))
+ service.SetHarnessRetriever(retrievalbridge.NewHarnessRetriever(modelFactory, metadataService, docEngine))
common.Info("agent: runtime chat retriever wired (runtime retrieval + agentic loop)")
// Initialize handler layer
@@ -1242,14 +1245,13 @@ func startServer(ctx context.Context, serverName string, arguments *serverArgs)
searchBotHandler := handler.NewSearchBotHandler(
searchService,
tenantService,
- modelProviderService,
+ modelFactory,
chunkService,
)
- searchBotHandler.SetStreamLLM(modelProviderService)
askService := service.NewAskService(chunkService, nil, 0, 0)
searchBotHandler.SetAskService(askService)
- chatHandler.SetMindMapDependencies(searchService, tenantService, modelProviderService, chunkService)
- searchHandler.SetCompletionDependencies(modelProviderService, askService)
+ chatHandler.SetMindMapDependencies(searchService, tenantService, modelFactory, chunkService)
+ searchHandler.SetCompletionDependencies(modelFactory, askService)
pluginHandler := handler.NewPluginHandler(service.NewPluginService())
modelHandler := handler.NewModelHandler(service.NewModelProviderService())
fileCommitHandler := handler.NewFileCommitHandler(file.NewFileCommitService())
@@ -1258,7 +1260,7 @@ func startServer(ctx context.Context, serverName string, arguments *serverArgs)
retrievalService := nlp.NewRetrievalService(docEngine, documentDAO)
difyRetrievalHandler := handler.NewDifyRetrievalHandler(
datasetsService,
- modelSolver,
+ modelFactory,
metadataService,
retrievalService,
documentDAO,
@@ -1281,8 +1283,8 @@ func startServer(ctx context.Context, serverName string, arguments *serverArgs)
// on demand so Search/UpsertDoc can embed queries/summaries automatically,
// and the cluster namer/merger resolves the tenant's default chat model the
// same way (see the ingestor's wrapping of SetNavMergeLLM).
- apiNavService := nlp.NewNavService(service.NewNavEmbedder(modelProviderService, ""))
- apiNavService.SetNavMergeLLM(service.NewNavMergeLLM(modelProviderService, ""))
+ apiNavService := nlp.NewNavService(service.NewNavEmbedder(modelFactory, ""))
+ apiNavService.SetNavMergeLLM(service.NewNavMergeLLM(modelFactory, ""))
nav.SetNavService(apiNavService)
// Install the compiled-wiki search service. It is backed directly by the
diff --git a/internal/agent/component/llm.go b/internal/agent/component/llm.go
index c0a3e9cef2..8063b95681 100644
--- a/internal/agent/component/llm.go
+++ b/internal/agent/component/llm.go
@@ -508,32 +508,29 @@ func streamEinoChat(ctx context.Context, wrapper *models.EinoChatModel, msgs []*
return resp, nil
}
-// resolvedModelInvoker is a ChatInvoker pinned to an already-resolved model
-// (driver/modelName/apiConfig). Unlike einoChatInvoker it never consults the
-// process-global default model name nor splits a composite llm id — the caller
-// (e.g. the Go chat pipeline's harness bridge) resolves the tenant model up
-// front via the model provider service. This mirrors Python, where RAGTools
-// receives a fully-resolved LLMBundle, and lets the agentic-RAG harness call a
-// tenant's actual chat model (which may be a UUID/tenant_model id) instead of
-// falling through to a dummy driver.
+// resolvedModelInvoker pins agent calls to one factory-created tenant model.
+// Unlike einoChatInvoker it never consults a process-global default or parses a
+// composite model reference.
type resolvedModelInvoker struct {
- driver models.ModelDriver
- modelName string
- apiConfig *models.APIConfig
+ model *models.ChatModel
}
-// NewResolvedInvoker builds a ChatInvoker bound to the given resolved model
-// config. modelName may be a bare model name; apiConfig carries the api key and
-// base url already resolved for the tenant.
-func NewResolvedInvoker(driver models.ModelDriver, modelName string, apiConfig *models.APIConfig) ChatInvoker {
- return &resolvedModelInvoker{driver: driver, modelName: modelName, apiConfig: apiConfig}
+// NewResolvedInvoker builds a ChatInvoker around a typed, resolved chat model.
+func NewResolvedInvoker(model *models.ChatModel) ChatInvoker {
+ if model == nil {
+ return nil
+ }
+ return &resolvedModelInvoker{model: model}
}
// resolvedChatWrapper builds the eino wrapper for the pinned model, applying the
// request's sampling config, thinking switch and tool binding. Invoke and Stream
// share it so both send an identical request; only the transport differs.
func (c *resolvedModelInvoker) resolvedChatWrapper(modelName string, req ChatInvokeRequest) (*models.EinoChatModel, *models.ChatModel, error) {
- cm := models.NewChatModel(c.driver, &modelName, c.apiConfig)
+ cm := c.model
+ if cm.ModelName == nil || *cm.ModelName != modelName {
+ cm = models.NewChatModelWithInfo(cm.ModelDriver, &modelName, cm.APIConfig, cm.Info())
+ }
chatCfg := &models.ChatConfig{
Temperature: req.Temperature,
TopP: req.TopP,
@@ -565,7 +562,13 @@ func (c *resolvedModelInvoker) modelFor(req ChatInvokeRequest) string {
if req.ModelName != "" {
return req.ModelName
}
- return c.modelName
+ if info := c.model.Info(); info != nil {
+ return info.Name
+ }
+ if c.model.ModelName != nil {
+ return *c.model.ModelName
+ }
+ return ""
}
// Invoke satisfies ChatInvoker.
diff --git a/internal/agent/component/llm_test.go b/internal/agent/component/llm_test.go
index cf0401c543..a334df4f49 100644
--- a/internal/agent/component/llm_test.go
+++ b/internal/agent/component/llm_test.go
@@ -663,7 +663,8 @@ func (d *streamingStubDriver) ChatStreamlyWithSender(_ context.Context, _ string
// "chat invoker *component.resolvedModelInvoker does not support streaming" —
// and the client received the whole answer in one piece.
func TestResolvedModelInvokerStreams(t *testing.T) {
- invoker := NewResolvedInvoker(&streamingStubDriver{}, "stub-model", &models.APIConfig{})
+ modelName := "stub-model"
+ invoker := NewResolvedInvoker(models.NewChatModel(&streamingStubDriver{}, &modelName, &models.APIConfig{}))
streamer, ok := invoker.(chat.StreamingInvoker)
if !ok {
t.Fatalf("resolved invoker %T must implement chat.StreamingInvoker", invoker)
diff --git a/internal/agent/retrievalbridge/harness.go b/internal/agent/retrievalbridge/harness.go
index 63dff5c7ac..f64601937c 100644
--- a/internal/agent/retrievalbridge/harness.go
+++ b/internal/agent/retrievalbridge/harness.go
@@ -40,7 +40,7 @@ import (
// NewHarnessRetriever connects chat requests to the agentic runtime using the
// shared model, metadata and document services initialized by the API server.
-func NewHarnessRetriever(modelProviderService *service.ModelProviderService, metadataService *service.MetadataService, docEngine engineDocEngine) func(context.Context, service.HarnessRequest) (service.HarnessResult, error) {
+func NewHarnessRetriever(modelFactory *service.ModelFactory, metadataService *service.MetadataService, docEngine engineDocEngine) func(context.Context, service.HarnessRequest) (service.HarnessResult, error) {
return func(ctx context.Context, req service.HarnessRequest) (service.HarnessResult, error) {
// Resolve the tenant's actual chat model, mirroring Python where RAGTools
// receives a fully-resolved LLMBundle: chat.LLMID may be a UUID/tenant_model
@@ -60,28 +60,29 @@ func NewHarnessRetriever(modelProviderService *service.ModelProviderService, met
// Resolve the same Chat model that the pipeline uses. An empty model ID
// selects the tenant default; an explicit reference must be enrolled as
// Chat, so an image2text-only model is rejected here.
- var target *service.ModelTarget
+ var chatModel *modelModule.ChatModel
var mErr error
- if modelProviderService == nil {
- mErr = errors.New("model provider service is not initialized")
+ if modelFactory == nil {
+ mErr = errors.New("model factory is not initialized")
} else {
- solver := service.NewModelSolver()
+ access := service.ModelAccess{TenantID: req.TenantID}
if strings.TrimSpace(req.ModelID) == "" {
- target, mErr = solver.ResolveDefaultModelConfig(ctx, req.TenantID, entity.ModelTypeChat)
+ chatModel, mErr = modelFactory.NewDefaultChatModel(ctx, access)
} else {
- target, mErr = solver.ResolveModelConfig(ctx, req.TenantID, entity.ModelTypeChat, req.ModelID)
+ chatModel, mErr = modelFactory.NewChatModel(ctx, access, req.ModelID)
}
}
- if mErr == nil {
- if inv := component.NewResolvedInvoker(target.Driver, target.ModelName, target.APIConfig); inv != nil {
- // MaxLength mirrors Python LLMBundle.max_length (the model's
- // context window in tokens); message-fitting nodes (calculate,
- // structure_qa) use it as their chat.FitMessages budget.
- model = &agenticruntime.InvokerSessionModel{Invoker: inv, DB: dao.DB, MaxLength: target.ContextLength}
- resolvedModelName = target.ModelName
- // Reuse the same resolved driver/name/api as the invoker so
- // the outer loop and the inner tool calls share one model.
- outerModel = modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
+ if mErr == nil && chatModel != nil {
+ if inv := component.NewResolvedInvoker(chatModel); inv != nil {
+ info := chatModel.Info()
+ contextLength := 0
+ if info != nil {
+ contextLength = info.ContextLength
+ resolvedModelName = info.Name
+ }
+ // Message fitting uses the input context window, not MaxOutput.
+ model = &agenticruntime.InvokerSessionModel{Invoker: inv, DB: dao.DB, MaxLength: contextLength}
+ outerModel = chatModel
}
} else {
common.Warn("runtime: failed to resolve chat model for reasoning; runtime will degrade to direct search", zap.Error(mErr))
@@ -166,7 +167,7 @@ func NewHarnessRetriever(modelProviderService *service.ModelProviderService, met
// The scope config lets each dataset be scanned under its own tenant
// and a doc scope be grouped by real owner, like graph_explore.
Expand: agenticruntime.NewCompiledExpander(
- newDatasetCompiledStore(docEngine, modelProviderService, kbs),
+ newDatasetCompiledStore(docEngine, modelFactory, kbs),
agenticruntime.CompiledScopeConfig{
DatasetIDs: req.DatasetIDs,
TenantID: req.TenantID,
@@ -188,7 +189,7 @@ func NewHarnessRetriever(modelProviderService *service.ModelProviderService, met
// paraphrase-phrased claims are never recalled. Bound to
// kbs[0].EmbdID (validateDatasetEmbeddingModels above guarantees
// every bound dataset shares it), query-side encoded.
- Embedder: embedderForDatasets(kbs, modelProviderService),
+ Embedder: embedderForDatasets(kbs, modelFactory),
// Tagger is the Go equivalent of Python's label_question
// (agentic_rag.py:668): classifies the query into question-type
// tags the retriever boosts on. metadataService implements it
@@ -376,11 +377,11 @@ func hasEmbedderFor(kbs []*entity.Knowledgebase) bool {
// guarantees the rest share it). Nil when no dataset carries an embedding
// model — the claim leg then degrades to BM25-only, matching a Python run
// without embed_mdl.
-func embedderForDatasets(kbs []*entity.Knowledgebase, modelSvc *service.ModelProviderService) nlp.NavEmbedder {
+func embedderForDatasets(kbs []*entity.Knowledgebase, modelFactory *service.ModelFactory) nlp.NavEmbedder {
if len(kbs) == 0 || kbs[0] == nil || kbs[0].EmbdID == "" {
return nil
}
- return service.NewNavEmbedder(modelSvc, kbs[0].EmbdID)
+ return service.NewNavEmbedder(modelFactory, kbs[0].EmbdID)
}
func validateLoadedDatasets(datasetIDs []string, kbs []*entity.Knowledgebase) error {
@@ -547,12 +548,12 @@ func newEngineCompiledStore(e engineDocEngine, embed compiledQueryEncoder, embed
// expansion; using the tenant-default model instead would compare the query
// against rows embedded by a different model — different vector spaces, so the
// dense hits would be noise.
-func newDatasetCompiledStore(e engineDocEngine, modelSvc *service.ModelProviderService, kbs []*entity.Knowledgebase) agenticruntime.CompiledStore {
+func newDatasetCompiledStore(e engineDocEngine, modelFactory *service.ModelFactory, kbs []*entity.Knowledgebase) agenticruntime.CompiledStore {
if e == nil {
return nil
}
if hasEmbedderFor(kbs) {
- return newEngineCompiledStore(e, service.NewNavEmbedder(modelSvc, kbs[0].EmbdID), kbs[0].TenantID)
+ return newEngineCompiledStore(e, service.NewNavEmbedder(modelFactory, kbs[0].EmbdID), kbs[0].TenantID)
}
return newEngineCompiledStore(e, nil, "")
}
diff --git a/internal/agent/retrievalbridge/harness_test.go b/internal/agent/retrievalbridge/harness_test.go
index ac4f61e7a6..01cf5210bd 100644
--- a/internal/agent/retrievalbridge/harness_test.go
+++ b/internal/agent/retrievalbridge/harness_test.go
@@ -292,7 +292,7 @@ func TestNewDatasetCompiledStore(t *testing.T) {
if got := newDatasetCompiledStore(eng, nil, []*entity.Knowledgebase{{ID: "kb1", TenantID: "t1"}}); got == nil {
t.Error("engine without an embedder must still build a keyword-only store")
}
- store := newDatasetCompiledStore(eng, service.NewModelProviderService(),
+ store := newDatasetCompiledStore(eng, service.NewModelFactory(),
[]*entity.Knowledgebase{{ID: "kb1", EmbdID: "bge-m3@inst@prov", TenantID: "owner-tenant"}})
es, ok := store.(*engineCompiledStore)
if !ok {
diff --git a/internal/agent/tool/retrieval_nlp.go b/internal/agent/tool/retrieval_nlp.go
index 3c12b1a4c4..5af4f491ce 100644
--- a/internal/agent/tool/retrieval_nlp.go
+++ b/internal/agent/tool/retrieval_nlp.go
@@ -87,18 +87,19 @@ var retrievalUserPrefixPattern = regexp.MustCompile(`(?i)^user[::\s]*`)
// beyond its docEngine + documentDAO handles, both of which the
// nlp package treats as concurrent-safe.
type NLPRetrievalAdapter struct {
- svc *nlp.RetrievalService
- kbDAO knowledgebaseLookup
- modelConfigResolver modelConfigResolver
- enhancer retrievalEnhancer
+ svc *nlp.RetrievalService
+ kbDAO knowledgebaseLookup
+ modelConstructors RetrievalModelConstructors
+ enhancer retrievalEnhancer
}
-type modelConfigResolver func(
- ctx context.Context,
- tenantID string,
- modelType entity.ModelType,
- modelRef string,
-) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error)
+// RetrievalModelConstructors constructs typed models for retrieval without
+// exposing provider drivers or API credentials to the agent-tool package.
+type RetrievalModelConstructors struct {
+ Embedding func(ctx context.Context, tenantID, modelRef string) (*modelModule.EmbeddingModel, error)
+ Chat func(ctx context.Context, tenantID, modelRef string) (*modelModule.ChatModel, error)
+ Rerank func(ctx context.Context, tenantID, modelRef string) (*modelModule.RerankModel, error)
+}
type knowledgebaseLookup interface {
GetByIDs(ctx context.Context, sqlDB *gorm.DB, ids []string) ([]*entity.Knowledgebase, error)
@@ -145,54 +146,34 @@ type retrievalEnhancer interface {
// *nlp.RetrievalService.
func NewNLPRetrievalAdapter(
svc *nlp.RetrievalService,
- resolver modelConfigResolver,
+ constructors RetrievalModelConstructors,
enhancer retrievalEnhancer,
) *NLPRetrievalAdapter {
return &NLPRetrievalAdapter{
- svc: svc,
- kbDAO: dao.NewKnowledgebaseDAO(),
- modelConfigResolver: resolver,
- enhancer: enhancer,
+ svc: svc,
+ kbDAO: dao.NewKnowledgebaseDAO(),
+ modelConstructors: constructors,
+ enhancer: enhancer,
}
}
// NewNLPRetrievalAdapterFromDeps is the convenience constructor
// for the common boot path:
//
-// The boot path supplies the model provider and service enhancement bridge so
-// the adapter can build a complete hybrid-retrieval request.
+// The boot path supplies typed model constructors and a service enhancement
+// bridge so the adapter can build a complete hybrid-retrieval request.
func NewNLPRetrievalAdapterFromDeps(
docEngine engine.DocEngine,
documentDAO *dao.DocumentDAO,
- resolver modelConfigResolver,
+ constructors RetrievalModelConstructors,
enhancer retrievalEnhancer,
) *NLPRetrievalAdapter {
return &NLPRetrievalAdapter{
- svc: nlp.NewRetrievalService(docEngine, documentDAO),
- kbDAO: dao.NewKnowledgebaseDAO(),
- modelConfigResolver: resolver,
- enhancer: enhancer,
- }
-}
-
-// SetModelConfigResolver installs modelRef-based resolution without coupling
-// the agent tool package to the parent service package.
-func (a *NLPRetrievalAdapter) SetModelConfigResolver(resolver modelConfigResolver) {
- if a != nil {
- a.modelConfigResolver = resolver
- }
-}
-
-func (a *NLPRetrievalAdapter) resolveModelConfig(
- ctx context.Context,
- tenantID string,
- modelType entity.ModelType,
- modelRef string,
-) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
- if a == nil || a.modelConfigResolver == nil {
- return nil, "", nil, 0, fmt.Errorf("retrieval: model config resolver is not configured")
+ svc: nlp.NewRetrievalService(docEngine, documentDAO),
+ kbDAO: dao.NewKnowledgebaseDAO(),
+ modelConstructors: constructors,
+ enhancer: enhancer,
}
- return a.modelConfigResolver(ctx, tenantID, modelType, modelRef)
}
// Search implements RetrievalService. The translation rules live
@@ -506,35 +487,18 @@ func (a *NLPRetrievalAdapter) resolveEmbeddingModel(
ctx context.Context,
kb *entity.Knowledgebase,
) (*modelModule.EmbeddingModel, error) {
- if a == nil {
- return nil, fmt.Errorf("retrieval: embedding model resolver is not configured")
- }
-
- var (
- driver modelModule.ModelDriver
- modelName string
- apiConfig *modelModule.APIConfig
- maxTokens int
- err error
- )
- switch {
- case kb.TenantEmbdID != nil && strings.TrimSpace(*kb.TenantEmbdID) != "":
- driver, modelName, apiConfig, maxTokens, err = a.resolveModelConfig(
- ctx, kb.TenantID, entity.ModelTypeEmbedding, *kb.TenantEmbdID,
- )
- case strings.TrimSpace(kb.EmbdID) != "":
- driver, modelName, apiConfig, maxTokens, err = a.resolveModelConfig(
- ctx, kb.TenantID, entity.ModelTypeEmbedding, kb.EmbdID,
- )
- default:
- driver, modelName, apiConfig, maxTokens, err = a.resolveModelConfig(
- ctx, kb.TenantID, entity.ModelTypeEmbedding, "",
- )
+ if a == nil || a.modelConstructors.Embedding == nil {
+ return nil, fmt.Errorf("retrieval: embedding model constructor is not configured")
}
+ modelRef := kb.EmbdID
+ if kb.TenantEmbdID != nil && strings.TrimSpace(*kb.TenantEmbdID) != "" {
+ modelRef = *kb.TenantEmbdID
+ }
+ model, err := a.modelConstructors.Embedding(ctx, kb.TenantID, modelRef)
if err != nil {
return nil, fmt.Errorf("retrieval: resolve embedding model for dataset %s: %w", kb.ID, err)
}
- return modelModule.NewEmbeddingModel(driver, &modelName, apiConfig, maxTokens), nil
+ return model, nil
}
func (a *NLPRetrievalAdapter) resolveChatModel(
@@ -547,16 +511,14 @@ func (a *NLPRetrievalAdapter) resolveChatModel(
if !needsChatModel {
return nil, nil
}
- if a == nil {
- return nil, fmt.Errorf("retrieval: model resolver is not configured")
+ if a == nil || a.modelConstructors.Chat == nil {
+ return nil, fmt.Errorf("retrieval: chat model constructor is not configured")
}
- driver, modelName, apiConfig, _, err := a.resolveModelConfig(
- ctx, tenantID, entity.ModelTypeChat, "",
- )
+ model, err := a.modelConstructors.Chat(ctx, tenantID, "")
if err != nil {
return nil, fmt.Errorf("retrieval: resolve default chat model: %w", err)
}
- return modelModule.NewChatModel(driver, &modelName, apiConfig), nil
+ return model, nil
}
func (a *NLPRetrievalAdapter) resolveRerankModel(
@@ -567,23 +529,14 @@ func (a *NLPRetrievalAdapter) resolveRerankModel(
if req.RerankID == "" {
return nil, nil
}
- if a == nil || a.modelConfigResolver == nil {
- return nil, fmt.Errorf("retrieval: model resolver is not configured")
- }
- var (
- driver modelModule.ModelDriver
- modelName string
- apiConfig *modelModule.APIConfig
- maxTokens int
- err error
- )
- driver, modelName, apiConfig, maxTokens, err = a.resolveModelConfig(
- ctx, tenantID, entity.ModelTypeRerank, req.RerankID,
- )
+ if a == nil || a.modelConstructors.Rerank == nil {
+ return nil, fmt.Errorf("retrieval: rerank model constructor is not configured")
+ }
+ model, err := a.modelConstructors.Rerank(ctx, tenantID, req.RerankID)
if err != nil {
return nil, fmt.Errorf("retrieval: resolve rerank model: %w", err)
}
- return modelModule.NewRerankModel(driver, &modelName, apiConfig, maxTokens), nil
+ return model, nil
}
// translateChunk converts one nlp chunk map into a RetrievalChunk.
diff --git a/internal/agent/tool/retrieval_nlp_test.go b/internal/agent/tool/retrieval_nlp_test.go
index 80d53ab27d..f5c1105751 100644
--- a/internal/agent/tool/retrieval_nlp_test.go
+++ b/internal/agent/tool/retrieval_nlp_test.go
@@ -225,7 +225,7 @@ func TestTranslateChunk_MissingAllScores(t *testing.T) {
// must produce an adapter whose Search returns the missing-service
// error, not a panic.
func TestNewNLPRetrievalAdapter_NilService(t *testing.T) {
- a := NewNLPRetrievalAdapter(nil, nil, nil)
+ a := NewNLPRetrievalAdapter(nil, RetrievalModelConstructors{}, nil)
_, err := a.Search(context.TODO(), nil, RetrievalRequest{Query: "hi"})
if err == nil {
t.Fatal("expected error from nil-service adapter")
@@ -491,24 +491,22 @@ func TestNLPRetrievalAdapter_ResolveEmbeddingModelPriority(t *testing.T) {
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
- resolver := &fakeModelResolver{modelName: "resolved-model"}
+ var gotRef string
adapter := &NLPRetrievalAdapter{
- modelConfigResolver: func(
- _ context.Context,
- _ string,
- _ entity.ModelType,
- modelRef string,
- ) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
- resolver.call = "resolve:" + modelRef
- return nil, resolver.modelName, &modelModule.APIConfig{}, 512, resolver.err
+ modelConstructors: RetrievalModelConstructors{
+ Embedding: func(_ context.Context, _ string, modelRef string) (*modelModule.EmbeddingModel, error) {
+ gotRef = modelRef
+ modelName := "resolved-model"
+ return modelModule.NewEmbeddingModel(&modelModule.DummyModel{}, &modelName, &modelModule.APIConfig{}, 512), nil
+ },
},
}
model, err := adapter.resolveEmbeddingModel(t.Context(), test.kb)
if err != nil {
t.Fatalf("resolveEmbeddingModel: %v", err)
}
- if resolver.call != test.wantCall {
- t.Fatalf("resolver call = %q, want %q", resolver.call, test.wantCall)
+ if got := "resolve:" + gotRef; got != test.wantCall {
+ t.Fatalf("constructor model ref = %q, want %q", got, test.wantCall)
}
if model == nil || model.ModelName == nil || *model.ModelName != "resolved-model" {
t.Fatalf("resolved model = %#v", model)
@@ -556,12 +554,6 @@ type fakeKnowledgebaseLookup struct {
err error
}
-type fakeModelResolver struct {
- call string
- modelName string
- err error
-}
-
func (f fakeKnowledgebaseLookup) GetByIDs(ctx context.Context, db *gorm.DB, ids []string) ([]*entity.Knowledgebase, error) {
requested := make(map[string]struct{}, len(ids))
for _, id := range ids {
diff --git a/internal/dao/tenant_model.go b/internal/dao/tenant_model.go
index 48a5aacceb..d7751efa38 100644
--- a/internal/dao/tenant_model.go
+++ b/internal/dao/tenant_model.go
@@ -99,25 +99,6 @@ func (dao *TenantModelDAO) GetByIDs(ctx context.Context, db *gorm.DB, ids []stri
return models, nil
}
-// GetActiveChatModelsByProviderAndInstanceIDs returns every ACTIVE model whose
-// model_type bitmask covers `modelType`, scoped to the given provider /
-// instance pairs. Used to enumerate a tenant's chat-capable models for the
-// EinoChatModel failover chain: each returned row's ID doubles as the
-// "model ref" that ModelProviderService.ResolveModelConfig accepts.
-func (dao *TenantModelDAO) GetActiveModelsByProviderAndInstanceIDsAndType(ctx context.Context, db *gorm.DB, providerIDs, instanceIDs []string, modelType int) ([]*entity.TenantModel, error) {
- var models []*entity.TenantModel
- q := db.WithContext(ctx).
- Where("provider_id IN ?", providerIDs).
- Where("instance_id IN ?", instanceIDs).
- Where("model_type & ? != 0", modelType).
- Where("status = ?", "active")
- err := q.Find(&models).Error
- if err != nil {
- return nil, err
- }
- return models, nil
-}
-
func (dao *TenantModelDAO) GetModelByProviderIDAndInstanceIDAndModelName(ctx context.Context, db *gorm.DB, providerID, instanceID, modelName string) (*entity.TenantModel, error) {
var model entity.TenantModel
err := db.WithContext(ctx).Where("provider_id = ? AND instance_id = ? AND model_name = ?", providerID, instanceID, modelName).First(&model).Error
diff --git a/internal/entity/models/embed_limit_test.go b/internal/entity/models/embed_limit_test.go
index 218b879825..69dfc62316 100644
--- a/internal/entity/models/embed_limit_test.go
+++ b/internal/entity/models/embed_limit_test.go
@@ -85,6 +85,22 @@ func newEmbedModel(t *testing.T, driver ModelDriver, tokenizerID string, maxToke
return NewEmbeddingModel(driver, nil, &APIConfig{ApiKey: &apiKey}, maxTokens)
}
+func TestEmbeddingModelResolveBatchSizeUsesStrictestLimit(t *testing.T) {
+ t.Setenv("TOKENIZER_EMBEDDING_BATCH_SIZE", "16")
+ modelName := "unlisted-embedding-model"
+ maxBatchSize := 32
+ model := &EmbeddingModel{ModelName: &modelName, MaxBatchSize: &maxBatchSize}
+ if got := model.ResolveBatchSize(); got != 16 {
+ t.Fatalf("ResolveBatchSize() = %d, want 16 (provider/runtime limit)", got)
+ }
+
+ t.Setenv("TOKENIZER_EMBEDDING_BATCH_SIZE", "32")
+ maxBatchSize = 8
+ if got := model.ResolveBatchSize(); got != 8 {
+ t.Fatalf("ResolveBatchSize() = %d, want 8 (model limit)", got)
+ }
+}
+
// embedBudget is the budget a single cut would use, computed the same way
// Embed computes its first rung.
func embedBudget(t *testing.T, model *EmbeddingModel) (int, tokenizer.Counter) {
diff --git a/internal/entity/models/model.go b/internal/entity/models/model.go
index ef8a414595..240c611034 100644
--- a/internal/entity/models/model.go
+++ b/internal/entity/models/model.go
@@ -417,8 +417,10 @@ func (pm *ProviderManager) ListAllModels() ([]map[string]interface{}, error) {
for _, model := range pm.AllModels {
modelData := map[string]interface{}{
- "name": model.Name,
- "model_types": model.ModelTypes,
+ "name": model.Name,
+ "model_types": model.ModelTypes,
+ "context_length": model.ContextLength,
+ "max_output": model.MaxOutput,
}
if model.Alias != nil {
modelData["alias"] = model.Alias
@@ -518,7 +520,7 @@ func GetModelTokenizer(modelName string) string {
}
// GetEmbeddingMaxTokens returns the input window declared for the named model:
-// its own max_tokens first, then the provider catalog's context_length. It
+// its context_length first, then the legacy max_tokens field. It
// returns 0 when the catalog knows nothing, leaving the caller to apply its
// default — deliberately, because a wrong non-zero value here is a rejected
// request (an oversized input) rather than a shorter one.
@@ -531,12 +533,12 @@ func GetEmbeddingMaxTokens(modelName string) int {
if modelName != "" {
if pm := GetProviderManager(); pm != nil {
if m := pm.GetModelByNameOrAlias(modelName); m != nil {
- if m.MaxTokens != nil && *m.MaxTokens > 0 {
- return *m.MaxTokens
- }
if m.ContextLength != nil && *m.ContextLength > 0 {
return *m.ContextLength
}
+ if m.MaxTokens != nil && *m.MaxTokens > 0 {
+ return *m.MaxTokens
+ }
}
}
}
@@ -584,13 +586,17 @@ func (pm *ProviderManager) ListModels(providerName string) ([]map[string]interfa
// the object.
modelData := map[string]interface{}{
"name": model.Name,
+ "context_length": model.ContextLength,
"max_output": model.MaxOutput,
"model_types": model.ModelTypes,
"max_dimension": model.MaxDimension,
"max_batch_size": model.MaxBatchSize,
"dimensions": model.Dimensions,
}
- if model.MaxTokens != nil {
+ if model.ContextLength != nil {
+ modelData["max_tokens"] = *model.ContextLength
+ } else if model.MaxTokens != nil {
+ // Persisted max_tokens predates the context_length/max_output split.
modelData["max_tokens"] = *model.MaxTokens
}
if model.BatchSize != nil {
diff --git a/internal/entity/models/model_test.go b/internal/entity/models/model_test.go
index 6a0c8442f3..7ada1845e3 100644
--- a/internal/entity/models/model_test.go
+++ b/internal/entity/models/model_test.go
@@ -711,6 +711,59 @@ func TestAllModelsCatalogTokenizerTagsAreKnown(t *testing.T) {
t.Logf("catalog tokenizer tags: %v", tags)
}
+func TestChatModelWithDefaults(t *testing.T) {
+ thinkingDefault := true
+ model := &ChatModel{info: &ModelInfo{
+ ModelClass: "chat",
+ Thinking: &ModelThinking{DefaultValue: thinkingDefault},
+ }}
+ config := model.withDefaults(nil)
+ if config.ModelClass == nil || *config.ModelClass != "chat" {
+ t.Fatalf("ModelClass = %v, want chat", config.ModelClass)
+ }
+ if config.Thinking == nil || !*config.Thinking {
+ t.Fatalf("Thinking = %v, want true", config.Thinking)
+ }
+
+ modelClass := "custom"
+ thinking := false
+ config = model.withDefaults(&ChatConfig{ModelClass: &modelClass, Thinking: &thinking})
+ if config.ModelClass != &modelClass || config.Thinking != &thinking {
+ t.Fatal("explicit chat config values should not be overwritten by model defaults")
+ }
+}
+
+func TestChatModelValidateMaxOutput(t *testing.T) {
+ maxOutput := 128
+ maxTokens := func(n int) *int { return &n }
+ model := &ChatModel{info: &ModelInfo{MaxOutput: maxOutput}}
+
+ tests := []struct {
+ name string
+ config *ChatConfig
+ wantErr bool
+ }{
+ {name: "below limit", config: &ChatConfig{MaxTokens: maxTokens(127)}},
+ {name: "at limit", config: &ChatConfig{MaxTokens: maxTokens(128)}},
+ {name: "above limit", config: &ChatConfig{MaxTokens: maxTokens(129)}, wantErr: true},
+ {name: "unset max tokens", config: &ChatConfig{}},
+ {name: "nil config"},
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ err := model.validateMaxOutput(tt.config)
+ if (err != nil) != tt.wantErr {
+ t.Fatalf("validateMaxOutput() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+
+ unknownLimitModel := &ChatModel{info: &ModelInfo{}}
+ if err := unknownLimitModel.validateMaxOutput(&ChatConfig{MaxTokens: maxTokens(1000)}); err != nil {
+ t.Fatalf("unknown model output limit should not reject config: %v", err)
+ }
+}
+
// sortedKeys returns the keys of a set, sorted, for a deterministic message.
func sortedKeys(set map[string]bool) []string {
out := make([]string, 0, len(set))
diff --git a/internal/entity/models/rerank_model_test.go b/internal/entity/models/rerank_model_test.go
index 4a6ca3ef40..2dc12d1700 100644
--- a/internal/entity/models/rerank_model_test.go
+++ b/internal/entity/models/rerank_model_test.go
@@ -31,7 +31,7 @@ func TestRerankModelTokenLimitModes(t *testing.T) {
t.Setenv(common.EnvRerankTokenLimitMode, "")
driver := &captureRerankDriver{}
model := NewRerankModel(driver, nil, nil, queryTokens+4)
- _, err := model.Rerank(t.Context(), RerankRequest{Query: query, Documents: []string{document}}, nil, nil, nil)
+ _, err := model.Rerank(t.Context(), RerankRequest{Query: query, Documents: []string{document}}, nil, nil)
if err != nil {
t.Fatalf("Rerank() error = %v", err)
}
@@ -47,7 +47,7 @@ func TestRerankModelTokenLimitModes(t *testing.T) {
t.Setenv(common.EnvRerankTokenLimitMode, " PASSTHROUGH ")
driver := &captureRerankDriver{}
model := NewRerankModel(driver, nil, nil, 1)
- _, err := model.Rerank(t.Context(), RerankRequest{Query: query, Documents: []string{document}}, nil, nil, nil)
+ _, err := model.Rerank(t.Context(), RerankRequest{Query: query, Documents: []string{document}}, nil, nil)
if err != nil {
t.Fatalf("Rerank() error = %v", err)
}
@@ -60,7 +60,7 @@ func TestRerankModelTokenLimitModes(t *testing.T) {
t.Setenv(common.EnvRerankTokenLimitMode, "raise_error")
driver := &captureRerankDriver{}
model := NewRerankModel(driver, nil, nil, queryTokens)
- _, err := model.Rerank(t.Context(), RerankRequest{Query: query, Documents: []string{"short"}}, nil, nil, nil)
+ _, err := model.Rerank(t.Context(), RerankRequest{Query: query, Documents: []string{"short"}}, nil, nil)
if !errors.Is(err, ErrRerankTokenLimitPolicy) || !strings.Contains(err.Error(), "document index 0") {
t.Fatalf("Rerank() error = %v, want token-limit error for document 0", err)
}
@@ -73,7 +73,7 @@ func TestRerankModelTokenLimitModes(t *testing.T) {
t.Setenv(common.EnvRerankTokenLimitMode, "invalid")
driver := &captureRerankDriver{}
model := NewRerankModel(driver, nil, nil, 10)
- _, err := model.Rerank(t.Context(), RerankRequest{Query: query, Documents: []string{"short"}}, nil, nil, nil)
+ _, err := model.Rerank(t.Context(), RerankRequest{Query: query, Documents: []string{"short"}}, nil, nil)
if !errors.Is(err, ErrRerankTokenLimitPolicy) || !strings.Contains(err.Error(), common.EnvRerankTokenLimitMode) {
t.Fatalf("Rerank() error = %v, want invalid-mode error", err)
}
diff --git a/internal/entity/models/types.go b/internal/entity/models/types.go
index 431d15ec0e..111e47dd15 100644
--- a/internal/entity/models/types.go
+++ b/internal/entity/models/types.go
@@ -273,6 +273,7 @@ type EmbeddingModel struct {
APIConfig *APIConfig
MaxTokens int // Max input tokens for the embedding model, used for text truncation
MaxBatchSize *int // Max texts per Embed request; nil means "resolve from provider capability at use site"
+ info *ModelInfo
}
// NewEmbeddingModel creates a new EmbeddingModel
@@ -285,20 +286,39 @@ func NewEmbeddingModel(driver ModelDriver, modelName *string, apiConfig *APIConf
}
}
-// ResolveBatchSize returns the max texts per Embed request for this embedding
-// model. It prefers an explicit MaxBatchSize set at construction time and falls
-// back to the provider capability (all_models.json batch_size, added by
-// #17877/#17878) via GetEmbeddingBatchSize, which itself defaults to
-// DefaultEmbeddingBatchSize.
-func (m *EmbeddingModel) ResolveBatchSize() int {
- if m != nil && m.MaxBatchSize != nil && *m.MaxBatchSize > 0 {
- return *m.MaxBatchSize
+// NewEmbeddingModelWithInfo creates an embedding model with resolved metadata.
+func NewEmbeddingModelWithInfo(driver ModelDriver, modelName *string, apiConfig *APIConfig, maxTokens int, info *ModelInfo) *EmbeddingModel {
+ model := NewEmbeddingModel(driver, modelName, apiConfig, maxTokens)
+ model.info = cloneModelInfo(info)
+ if info != nil && info.Catalog != nil {
+ model.MaxBatchSize = info.Catalog.MaxBatchSize
}
+ return model
+}
+
+// Info returns metadata for this selected embedding model.
+func (m *EmbeddingModel) Info() *ModelInfo {
+ if m == nil {
+ return nil
+ }
+ return cloneModelInfo(m.info)
+}
+
+// ResolveBatchSize returns the safe maximum texts per Embed request. The
+// effective limit cannot exceed either the model's declared maximum or the
+// provider/runtime batch capability; these values can differ (for example, a
+// provider model config can declare max_batch_size=32 while its driver only
+// accepts the default batch size of 16).
+func (m *EmbeddingModel) ResolveBatchSize() int {
var name string
if m != nil && m.ModelName != nil {
name = *m.ModelName
}
- return GetEmbeddingBatchSize(name)
+ batchSize := GetEmbeddingBatchSize(name)
+ if m != nil && m.MaxBatchSize != nil && *m.MaxBatchSize > 0 && *m.MaxBatchSize < batchSize {
+ return *m.MaxBatchSize
+ }
+ return batchSize
}
// ResolveMaxTokens is ResolveBatchSize's counterpart for the input window: the
@@ -373,6 +393,7 @@ type RerankModel struct {
limiter tokenizer.Limiter
limiterErr error
+ info *ModelInfo
}
// NewRerankModel creates a new RerankModel
@@ -394,18 +415,24 @@ func NewRerankModel(driver ModelDriver, modelName *string, apiConfig *APIConfig,
}
}
-// ResolveTokenizerID returns the tokenizer family declared for this reranker, or
-// an empty string when the model catalog does not provide one.
-func (r *RerankModel) ResolveTokenizerID() string {
- if r == nil || r.ModelName == nil {
- return ""
+// NewRerankModelWithInfo creates a rerank model with resolved metadata.
+func NewRerankModelWithInfo(driver ModelDriver, modelName *string, apiConfig *APIConfig, maxTokens int, info *ModelInfo) *RerankModel {
+ model := NewRerankModel(driver, modelName, apiConfig, maxTokens)
+ model.info = cloneModelInfo(info)
+ return model
+}
+
+// Info returns metadata for this selected rerank model.
+func (r *RerankModel) Info() *ModelInfo {
+ if r == nil {
+ return nil
}
- return GetModelTokenizer(*r.ModelName)
+ return cloneModelInfo(r.info)
}
// Rerank calculates similarity between query and texts. Rerank input is measured
// and truncated with the model's declared tokenizer, just like embedding input.
-func (r *RerankModel) Rerank(ctx context.Context, request RerankRequest, apiConfig *APIConfig, rerankConfig *RerankConfig, modelUsage *common.ModelUsage) (*RerankResponse, error) {
+func (r *RerankModel) Rerank(ctx context.Context, request RerankRequest, rerankConfig *RerankConfig, modelUsage *common.ModelUsage) (*RerankResponse, error) {
if r == nil || r.ModelDriver == nil {
return nil, errors.New("rerank model: driver is nil")
}
@@ -445,7 +472,43 @@ func (r *RerankModel) Rerank(ctx context.Context, request RerankRequest, apiConf
}
}
}
- return r.ModelDriver.Rerank(ctx, r.ModelName, request, apiConfig, rerankConfig, modelUsage)
+ return r.ModelDriver.Rerank(ctx, r.ModelName, request, r.APIConfig, rerankConfig, modelUsage)
+}
+
+// OCRModel wraps a ModelDriver with optical-character-recognition configuration.
+type OCRModel struct {
+ ModelDriver ModelDriver
+ ModelName *string
+ APIConfig *APIConfig
+ info *ModelInfo
+}
+
+// NewOCRModel creates an OCR model wrapper.
+func NewOCRModel(driver ModelDriver, modelName *string, apiConfig *APIConfig) *OCRModel {
+ return &OCRModel{ModelDriver: driver, ModelName: modelName, APIConfig: apiConfig}
+}
+
+// NewOCRModelWithInfo creates an OCR model with resolved metadata.
+func NewOCRModelWithInfo(driver ModelDriver, modelName *string, apiConfig *APIConfig, info *ModelInfo) *OCRModel {
+ model := NewOCRModel(driver, modelName, apiConfig)
+ model.info = cloneModelInfo(info)
+ return model
+}
+
+// Info returns metadata for this selected OCR model.
+func (m *OCRModel) Info() *ModelInfo {
+ if m == nil {
+ return nil
+ }
+ return cloneModelInfo(m.info)
+}
+
+// OCRFile extracts text from an image or document.
+func (m *OCRModel) OCRFile(ctx context.Context, content []byte, url *string, config *OCRConfig, usage *common.ModelUsage) (*OCRFileResponse, error) {
+ if m == nil || m.ModelDriver == nil {
+ return nil, errors.New("OCR model: driver is nil")
+ }
+ return m.ModelDriver.OCRFile(ctx, m.ModelName, content, url, m.APIConfig, config, usage)
}
// ASRModel wraps a ModelDriver with speech-to-text configuration.
@@ -453,6 +516,7 @@ type ASRModel struct {
ModelDriver ModelDriver
ModelName *string
APIConfig *APIConfig
+ info *ModelInfo
}
// NewASRModel creates a new ASRModel.
@@ -460,6 +524,21 @@ func NewASRModel(driver ModelDriver, modelName *string, apiConfig *APIConfig) *A
return &ASRModel{ModelDriver: driver, ModelName: modelName, APIConfig: apiConfig}
}
+// NewASRModelWithInfo creates an ASR model with resolved metadata.
+func NewASRModelWithInfo(driver ModelDriver, modelName *string, apiConfig *APIConfig, info *ModelInfo) *ASRModel {
+ model := NewASRModel(driver, modelName, apiConfig)
+ model.info = cloneModelInfo(info)
+ return model
+}
+
+// Info returns metadata for this selected ASR model.
+func (m *ASRModel) Info() *ModelInfo {
+ if m == nil {
+ return nil
+ }
+ return cloneModelInfo(m.info)
+}
+
// Transcribe converts audio to text.
func (m *ASRModel) Transcribe(ctx context.Context, audioFile *string, config *ASRConfig, usage *common.ModelUsage) (*ASRResponse, error) {
return m.ModelDriver.TranscribeAudio(ctx, m.ModelName, audioFile, m.APIConfig, config, usage)
@@ -475,6 +554,7 @@ type TTSModel struct {
ModelDriver ModelDriver
ModelName *string
APIConfig *APIConfig
+ info *ModelInfo
}
// NewTTSModel creates a new TTSModel.
@@ -482,6 +562,21 @@ func NewTTSModel(driver ModelDriver, modelName *string, apiConfig *APIConfig) *T
return &TTSModel{ModelDriver: driver, ModelName: modelName, APIConfig: apiConfig}
}
+// NewTTSModelWithInfo creates a TTS model with resolved metadata.
+func NewTTSModelWithInfo(driver ModelDriver, modelName *string, apiConfig *APIConfig, info *ModelInfo) *TTSModel {
+ model := NewTTSModel(driver, modelName, apiConfig)
+ model.info = cloneModelInfo(info)
+ return model
+}
+
+// Info returns metadata for this selected TTS model.
+func (m *TTSModel) Info() *ModelInfo {
+ if m == nil {
+ return nil
+ }
+ return cloneModelInfo(m.info)
+}
+
// Speech converts text to audio.
func (m *TTSModel) Speech(ctx context.Context, audioContent *string, config *TTSConfig, usage *common.ModelUsage) (*TTSResponse, error) {
return m.ModelDriver.AudioSpeech(ctx, m.ModelName, audioContent, m.APIConfig, config, usage)
@@ -512,6 +607,7 @@ type ChatModel struct {
ModelName *string
APIConfig *APIConfig
ToolConfig *ToolConfig
+ info *ModelInfo
}
// NewChatModel creates a new ChatModel
@@ -523,11 +619,30 @@ func NewChatModel(driver ModelDriver, modelName *string, apiConfig *APIConfig) *
}
}
+// NewChatModelWithInfo creates a chat model with resolved metadata.
+func NewChatModelWithInfo(driver ModelDriver, modelName *string, apiConfig *APIConfig, info *ModelInfo) *ChatModel {
+ model := NewChatModel(driver, modelName, apiConfig)
+ model.info = cloneModelInfo(info)
+ return model
+}
+
+// Info returns metadata for this selected chat model.
+func (m *ChatModel) Info() *ModelInfo {
+ if m == nil {
+ return nil
+ }
+ return cloneModelInfo(m.info)
+}
+
// ChatWithMessages sends a non-streaming chat request through the model wrapper.
func (m *ChatModel) ChatWithMessages(ctx context.Context, messages []Message, config *ChatConfig, usage *common.ModelUsage) (*ChatResponse, error) {
if m == nil || m.ModelDriver == nil {
return nil, errors.New("chat model: driver is nil")
}
+ config = m.withDefaults(config)
+ if err := m.validateMaxOutput(config); err != nil {
+ return nil, err
+ }
modelName := ""
if m.ModelName != nil {
modelName = *m.ModelName
@@ -540,6 +655,10 @@ func (m *ChatModel) ChatStreamlyWithSender(ctx context.Context, messages []Messa
if m == nil || m.ModelDriver == nil {
return errors.New("chat model: driver is nil")
}
+ config = m.withDefaults(config)
+ if err := m.validateMaxOutput(config); err != nil {
+ return err
+ }
modelName := ""
if m.ModelName != nil {
modelName = *m.ModelName
@@ -547,6 +666,34 @@ func (m *ChatModel) ChatStreamlyWithSender(ctx context.Context, messages []Messa
return m.ModelDriver.ChatStreamlyWithSender(ctx, modelName, messages, m.APIConfig, config, usage, sender)
}
+func (m *ChatModel) withDefaults(config *ChatConfig) *ChatConfig {
+ if config == nil {
+ config = &ChatConfig{}
+ }
+ if m.info == nil {
+ return config
+ }
+ if config.ModelClass == nil && m.info.ModelClass != "" {
+ modelClass := m.info.ModelClass
+ config.ModelClass = &modelClass
+ }
+ if config.Thinking == nil && m.info.Thinking != nil {
+ thinking := m.info.Thinking.DefaultValue
+ config.Thinking = &thinking
+ }
+ return config
+}
+
+func (m *ChatModel) validateMaxOutput(config *ChatConfig) error {
+ if m == nil || m.info == nil || m.info.MaxOutput <= 0 || config == nil || config.MaxTokens == nil {
+ return nil
+ }
+ if *config.MaxTokens > m.info.MaxOutput {
+ return fmt.Errorf("chat max_tokens %d exceeds model max_output %d", *config.MaxTokens, m.info.MaxOutput)
+ }
+ return nil
+}
+
// BindTools registers tools for the ChatModel to call.
// Mirrors Python's Base.bind_tools() in rag/llm/chat_model.py.
func (cm *ChatModel) BindTools(session ToolCallSession, tools interface{}) {
@@ -584,3 +731,41 @@ func (cm *ChatModel) SetTerminalTools(names ...string) {
}
cm.ToolConfig.TerminalTools = term
}
+
+// ModelInfo describes the selected model without exposing its driver
+// credentials. ContextLength is the input/context window; MaxOutput is the
+// provider's maximum generated-token budget.
+type ModelInfo struct {
+ ID string
+ Name string
+ ProviderName string
+ InstanceID string
+ InstanceName string
+ ModelTypes []string
+ ContextLength int
+ MaxOutput int
+ SupportsTools bool
+ ModelClass string
+ Thinking *ModelThinking
+ Catalog *Model
+}
+
+func cloneModelInfo(info *ModelInfo) *ModelInfo {
+ if info == nil {
+ return nil
+ }
+ copy := *info
+ copy.ModelTypes = append([]string(nil), info.ModelTypes...)
+ if info.Thinking != nil {
+ thinking := *info.Thinking
+ copy.Thinking = &thinking
+ }
+ if info.Catalog != nil {
+ catalog := *info.Catalog
+ catalog.ModelTypes = append([]string(nil), info.Catalog.ModelTypes...)
+ catalog.Dimensions = append([]int(nil), info.Catalog.Dimensions...)
+ catalog.Alias = append([]string(nil), info.Catalog.Alias...)
+ copy.Catalog = &catalog
+ }
+ return &copy
+}
diff --git a/internal/handler/chat.go b/internal/handler/chat.go
index 18571b0b45..089b1b3478 100644
--- a/internal/handler/chat.go
+++ b/internal/handler/chat.go
@@ -33,12 +33,12 @@ import (
// ChatHandler chat handler
type ChatHandler struct {
- chatService *service.ChatService
- userService *service.UserService
- searchSvc *service.SearchService
- tenantSvc *service.TenantService
- llm *service.ModelProviderService
- chunkSvc service.Retriever
+ chatService *service.ChatService
+ userService *service.UserService
+ searchSvc *service.SearchService
+ tenantSvc *service.TenantService
+ modelFactory *service.ModelFactory
+ chunkSvc service.Retriever
}
// NewChatHandler create chat handler
@@ -50,10 +50,10 @@ func NewChatHandler(chatService *service.ChatService, userService *service.UserS
}
// SetMindMapDependencies sets dependencies used by POST /api/v1/chat/mindmap.
-func (h *ChatHandler) SetMindMapDependencies(searchSvc *service.SearchService, tenantSvc *service.TenantService, llm *service.ModelProviderService, chunkSvc service.Retriever) {
+func (h *ChatHandler) SetMindMapDependencies(searchSvc *service.SearchService, tenantSvc *service.TenantService, modelFactory *service.ModelFactory, chunkSvc service.Retriever) {
h.searchSvc = searchSvc
h.tenantSvc = tenantSvc
- h.llm = llm
+ h.modelFactory = modelFactory
h.chunkSvc = chunkSvc
}
@@ -225,7 +225,7 @@ func (h *ChatHandler) MindMap(c *gin.Context) {
AuthUserID: user.ID,
ModelTenantID: modelTenantID,
ChunkSvc: h.chunkSvc,
- LLM: h.llm,
+ LLM: h.modelFactory,
TenantSvc: h.tenantSvc,
})
if err != nil {
diff --git a/internal/handler/chat_audio.go b/internal/handler/chat_audio.go
index 0743081d7b..a00aa5cdaf 100644
--- a/internal/handler/chat_audio.go
+++ b/internal/handler/chat_audio.go
@@ -30,7 +30,6 @@ import (
"go.uber.org/zap"
"ragflow/internal/common"
- "ragflow/internal/entity"
modelModule "ragflow/internal/entity/models"
"ragflow/internal/service"
)
@@ -69,21 +68,21 @@ func (h *ChatHandler) ChatAudioSpeech(c *gin.Context) {
return
}
- if h.llm == nil {
+ if h.modelFactory == nil {
common.ErrorWithCode(c, common.CodeServerError, "TTS service not available")
return
}
- target, err := service.NewModelSolver().ResolveDefaultModelConfig(ctx, user.ID, entity.ModelTypeTTS)
+ ttsModel, err := h.modelFactory.NewDefaultTTSModel(ctx, service.ModelAccess{UserID: user.ID, TenantID: user.ID})
if err != nil {
common.ErrorWithCode(c, common.CodeDataError, err.Error())
return
}
- driver := target.Driver
- modelName := target.ModelName
- apiConfig := target.APIConfig
- ttsModel := modelModule.NewTTSModel(driver, &modelName, apiConfig)
+ modelName, providerName := "", ""
+ if info := ttsModel.Info(); info != nil {
+ modelName, providerName = info.Name, info.ProviderName
+ }
writeAudioHeaders := func(mediaType string) {
c.Header("Content-Type", mediaType)
c.Header("Cache-Control", "no-cache")
@@ -176,11 +175,11 @@ func (h *ChatHandler) ChatAudioSpeech(c *gin.Context) {
if !headerWritten {
if firstSynthErr != nil {
common.ErrorWithCode(c, common.CodeServerError,
- fmt.Sprintf("TTS synthesis failed for model %s (%s)", modelName, driver.Name()))
+ fmt.Sprintf("TTS synthesis failed for model %s (%s)", modelName, providerName))
return
}
common.ErrorWithCode(c, common.CodeServerError,
- fmt.Sprintf("TTS synthesis produced no audio for model %s (%s)", modelName, driver.Name()))
+ fmt.Sprintf("TTS synthesis produced no audio for model %s (%s)", modelName, providerName))
}
}
@@ -218,7 +217,7 @@ func (h *ChatHandler) ChatAudioTranscription(c *gin.Context) {
return
}
- if h.llm == nil {
+ if h.modelFactory == nil {
common.ErrorWithCode(c, common.CodeServerError, "ASR service not available")
return
}
@@ -269,15 +268,11 @@ func (h *ChatHandler) ChatAudioTranscription(c *gin.Context) {
return
}
- target, err := service.NewModelSolver().ResolveDefaultModelConfig(ctx, user.ID, entity.ModelTypeSpeech2Text)
+ asrModel, err := h.modelFactory.NewDefaultASRModel(ctx, service.ModelAccess{UserID: user.ID, TenantID: user.ID})
if err != nil {
common.ErrorWithCode(c, common.CodeDataError, err.Error())
return
}
- driver := target.Driver
- modelName := target.ModelName
- apiConfig := target.APIConfig
- asrModel := modelModule.NewASRModel(driver, &modelName, apiConfig)
streamMode := strings.ToLower(c.PostForm("stream")) == "true"
if streamMode {
diff --git a/internal/handler/chat_audio_test.go b/internal/handler/chat_audio_test.go
index ecd82f7d29..db93617423 100644
--- a/internal/handler/chat_audio_test.go
+++ b/internal/handler/chat_audio_test.go
@@ -88,7 +88,7 @@ func TestChatAudioSpeechFailureOmitsProviderError(t *testing.T) {
}
h := NewChatHandler(service.NewChatService(), service.NewUserService())
- h.SetMindMapDependencies(nil, nil, service.NewModelProviderService(), nil)
+ h.SetMindMapDependencies(nil, nil, service.NewModelFactory(), nil)
c, w := setupGinContextWithUser(http.MethodPost, "/api/v1/chat/audio/speech", `{"text":"hello"}`)
h.ChatAudioSpeech(c)
diff --git a/internal/handler/chat_recommendation.go b/internal/handler/chat_recommendation.go
index 5245096a74..19c79cd0f9 100644
--- a/internal/handler/chat_recommendation.go
+++ b/internal/handler/chat_recommendation.go
@@ -59,7 +59,7 @@ func (h *ChatHandler) Recommendation(c *gin.Context) {
return
}
ctx := c.Request.Context()
- questions, err := service.GenerateRelatedQuestions(ctx, user.ID, req.Question, req.SearchID, h.searchSvc, h.tenantSvc, h.llm)
+ questions, err := service.GenerateRelatedQuestions(ctx, user.ID, req.Question, req.SearchID, h.searchSvc, h.tenantSvc, h.modelFactory)
if err != nil {
common.Warn("chat recommendation failed", zap.String("error", err.Error()))
common.ResponseWithCodeData(c, common.CodeOperatingError, nil, err.Error())
diff --git a/internal/handler/dify_retrieval_handler.go b/internal/handler/dify_retrieval_handler.go
index a3d0bf8f77..e40f8ad1c6 100644
--- a/internal/handler/dify_retrieval_handler.go
+++ b/internal/handler/dify_retrieval_handler.go
@@ -47,10 +47,10 @@ type KBServiceIface interface {
Accessible(ctx context.Context, kbID, userID string) bool
}
-// ModelResolver abstracts model configuration resolution for the Dify handler.
-type ModelResolver interface {
- ResolveModelConfig(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string) (*service.ModelTarget, error)
- ResolveDefaultModelConfig(ctx context.Context, tenantID string, modelType entity.ModelType) (*service.ModelTarget, error)
+// ModelCreator supplies typed model instances to Dify retrieval.
+type ModelCreator interface {
+ NewEmbeddingModel(ctx context.Context, access service.ModelAccess, modelRef string) (*modelModule.EmbeddingModel, error)
+ NewDefaultChatModel(ctx context.Context, access service.ModelAccess) (*modelModule.ChatModel, error)
}
// MetadataServiceIface abstracts MetadataService for the Dify handler.
@@ -131,12 +131,12 @@ type difyRecord struct {
// DifyRetrievalHandler handles Dify-compatible retrieval requests.
type DifyRetrievalHandler struct {
- kbSvc KBServiceIface
- modelResolver ModelResolver
- metadataSvc MetadataServiceIface
- retrievalSvc RetrievalServiceIface
- docDAO DocumentDAOIface
- docEngine engine.DocEngine
+ kbSvc KBServiceIface
+ modelFactory ModelCreator
+ metadataSvc MetadataServiceIface
+ retrievalSvc RetrievalServiceIface
+ docDAO DocumentDAOIface
+ docEngine engine.DocEngine
}
// NewDifyRetrievalHandler creates a new DifyRetrievalHandler.
@@ -144,19 +144,19 @@ type DifyRetrievalHandler struct {
// a pipeline that depends on per-request model configuration.
func NewDifyRetrievalHandler(
kbSvc KBServiceIface,
- modelResolver ModelResolver,
+ modelFactory ModelCreator,
metadataSvc MetadataServiceIface,
retrievalSvc RetrievalServiceIface,
docDAO DocumentDAOIface,
docEngine engine.DocEngine,
) *DifyRetrievalHandler {
return &DifyRetrievalHandler{
- kbSvc: kbSvc,
- modelResolver: modelResolver,
- metadataSvc: metadataSvc,
- retrievalSvc: retrievalSvc,
- docDAO: docDAO,
- docEngine: docEngine,
+ kbSvc: kbSvc,
+ modelFactory: modelFactory,
+ metadataSvc: metadataSvc,
+ retrievalSvc: retrievalSvc,
+ docDAO: docDAO,
+ docEngine: docEngine,
}
}
@@ -235,12 +235,12 @@ func (h *DifyRetrievalHandler) Retrieval(c *gin.Context) {
}
// Get embedding model
- target, err := h.modelResolver.ResolveModelConfig(ctx, kb.TenantID, entity.ModelTypeEmbedding, kb.EmbdID)
+ access := service.ModelAccess{UserID: user.ID, TenantID: kb.TenantID}
+ embModel, err := h.modelFactory.NewEmbeddingModel(ctx, access, kb.EmbdID)
if err != nil {
common.ResponseWithHttpCodeData(c, http.StatusInternalServerError, common.CodeServerError, nil, fmt.Sprintf("failed to get embedding model: %v", err))
return
}
- embModel := modelModule.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
// Metadata filter
metas, metaErr := h.metadataSvc.GetFlattedMetaByKBs(ctx, []string{req.KnowledgeID})
@@ -292,11 +292,10 @@ func (h *DifyRetrievalHandler) Retrieval(c *gin.Context) {
// KG retrieval (optional)
if req.UseKG {
- target, kgErr := h.modelResolver.ResolveDefaultModelConfig(ctx, kb.TenantID, entity.ModelTypeChat)
+ chatModel, kgErr := h.modelFactory.NewDefaultChatModel(ctx, access)
if kgErr != nil {
common.Warn("KG retrieval: failed to get chat model", zap.String("kbID", req.KnowledgeID), zap.Error(kgErr))
- } else if target != nil {
- chatModel := modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
+ } else if chatModel != nil {
kgPipeline := graph.NewPipeline(
h.docEngine,
[]string{req.KnowledgeID},
diff --git a/internal/handler/dify_retrieval_handler_test.go b/internal/handler/dify_retrieval_handler_test.go
index ace1ec4878..c5e248a213 100644
--- a/internal/handler/dify_retrieval_handler_test.go
+++ b/internal/handler/dify_retrieval_handler_test.go
@@ -31,6 +31,7 @@ import (
"ragflow/internal/engine"
"ragflow/internal/engine/types"
"ragflow/internal/entity"
+ modelModule "ragflow/internal/entity/models"
"ragflow/internal/service"
"ragflow/internal/service/nlp"
@@ -61,23 +62,16 @@ func (m *mockKBService) Accessible(ctx context.Context, kbID, userID string) boo
return true
}
-type mockModelResolver struct {
- resolveModelConfigFn func(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string) (*service.ModelTarget, error)
- resolveDefaultModelConfigFn func(ctx context.Context, tenantID string, modelType entity.ModelType) (*service.ModelTarget, error)
-}
+type mockModelFactory struct{}
-func (m *mockModelResolver) ResolveModelConfig(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string) (*service.ModelTarget, error) {
- if m.resolveModelConfigFn != nil {
- return m.resolveModelConfigFn(ctx, tenantID, modelType, modelRef)
- }
- return &service.ModelTarget{ModelName: "test-model"}, nil
+func (mockModelFactory) NewEmbeddingModel(context.Context, service.ModelAccess, string) (*modelModule.EmbeddingModel, error) {
+ name := "test-model"
+ return modelModule.NewEmbeddingModel(&modelModule.DummyModel{}, &name, &modelModule.APIConfig{}, 0), nil
}
-func (m *mockModelResolver) ResolveDefaultModelConfig(ctx context.Context, tenantID string, modelType entity.ModelType) (*service.ModelTarget, error) {
- if m.resolveDefaultModelConfigFn != nil {
- return m.resolveDefaultModelConfigFn(ctx, tenantID, modelType)
- }
- return &service.ModelTarget{ModelName: "test-model"}, nil
+func (mockModelFactory) NewDefaultChatModel(context.Context, service.ModelAccess) (*modelModule.ChatModel, error) {
+ name := "test-model"
+ return modelModule.NewChatModel(&modelModule.DummyModel{}, &name, &modelModule.APIConfig{}), nil
}
type mockMetadataService struct {
@@ -161,12 +155,12 @@ func (m *mockDocEngine) GetChunk(ctx context.Context, _, _ string, _ []string) (
func setupDifyTest(userID string) (*DifyRetrievalHandler, *gin.Engine) {
h := &DifyRetrievalHandler{
- kbSvc: &mockKBService{},
- modelResolver: &mockModelResolver{},
- metadataSvc: &mockMetadataService{},
- retrievalSvc: &mockRetrievalService{},
- docDAO: &mockDocDAO{},
- docEngine: &mockDocEngine{},
+ kbSvc: &mockKBService{},
+ modelFactory: mockModelFactory{},
+ metadataSvc: &mockMetadataService{},
+ retrievalSvc: &mockRetrievalService{},
+ docDAO: &mockDocDAO{},
+ docEngine: &mockDocEngine{},
}
gin.SetMode(gin.TestMode)
@@ -182,12 +176,12 @@ func setupDifyTest(userID string) (*DifyRetrievalHandler, *gin.Engine) {
func setupDifyTestNoAuth() (*DifyRetrievalHandler, *gin.Engine) {
h := &DifyRetrievalHandler{
- kbSvc: &mockKBService{},
- modelResolver: &mockModelResolver{},
- metadataSvc: &mockMetadataService{},
- retrievalSvc: &mockRetrievalService{},
- docDAO: &mockDocDAO{},
- docEngine: &mockDocEngine{},
+ kbSvc: &mockKBService{},
+ modelFactory: mockModelFactory{},
+ metadataSvc: &mockMetadataService{},
+ retrievalSvc: &mockRetrievalService{},
+ docDAO: &mockDocDAO{},
+ docEngine: &mockDocEngine{},
}
gin.SetMode(gin.TestMode)
r := gin.New()
diff --git a/internal/handler/mindmap.go b/internal/handler/mindmap.go
index 680ec5450d..679bbb6b7e 100644
--- a/internal/handler/mindmap.go
+++ b/internal/handler/mindmap.go
@@ -37,7 +37,7 @@ type mindMapRunConfig struct {
AuthUserID string
ModelTenantID string
ChunkSvc service.Retriever
- LLM *service.ModelProviderService
+ LLM *service.ModelFactory
TenantSvc *service.TenantService
}
@@ -67,20 +67,17 @@ func runMindMap(ctx context.Context, config mindMapRunConfig) (mindMapNode, erro
streamCtx, streamCancel := context.WithTimeout(ctx, 10*time.Minute)
defer streamCancel()
- // search_config chat_id can be a stale tenant_model ID that no longer
- // exists. ResolveModelConfig tries ID lookup first, then falls back to
- // composite-name parsing which fails for bare IDs. If the configured
- // model can't be resolved, fall back to the tenant's default chat model
- // (mirrors Python's gen_mindmap get_tenant_default_model_by_type).
- ch, streamErrs, findChatModelErr := config.LLM.ChatStream(streamCtx, modelTenantID, modelID, messages, &modelModule.ChatConfig{})
- if findChatModelErr != nil && config.TenantSvc != nil {
- if defaultModel, err := config.TenantSvc.GetDefaultModelName(streamCtx, modelTenantID, entity.ModelTypeChat); err == nil && defaultModel != "" && defaultModel != modelID {
- ch, streamErrs, findChatModelErr = config.LLM.ChatStream(streamCtx, modelTenantID, defaultModel, messages, &modelModule.ChatConfig{})
- }
+ // A stale search_config chat_id should not prevent mind-map generation;
+ // fall back to the tenant's configured default model.
+ access := service.ModelAccess{UserID: config.AuthUserID, TenantID: modelTenantID}
+ chatModel, modelErr := config.LLM.NewChatModel(streamCtx, access, modelID)
+ if modelErr != nil {
+ chatModel, modelErr = config.LLM.NewDefaultChatModel(streamCtx, access)
}
- if findChatModelErr != nil {
- return mindMapNode{}, findChatModelErr
+ if modelErr != nil {
+ return mindMapNode{}, modelErr
}
+ ch, streamErrs := streamChatModel(streamCtx, chatModel, messages)
fullText, err := collectMindMapStream(streamCtx, ch, streamErrs)
if err != nil {
return mindMapNode{}, err
@@ -91,6 +88,30 @@ func runMindMap(ctx context.Context, config mindMapRunConfig) (mindMapNode, erro
return parseMindMapMarkdown(fullText), nil
}
+func streamChatModel(ctx context.Context, chatModel *modelModule.ChatModel, messages []modelModule.Message) (<-chan string, <-chan error) {
+ chunks := make(chan string, 256)
+ errs := make(chan error, 1)
+ go func() {
+ defer close(chunks)
+ defer close(errs)
+ err := chatModel.ChatStreamlyWithSender(ctx, messages, &modelModule.ChatConfig{}, nil, func(delta *string, _ *string) error {
+ if delta == nil || *delta == "[DONE]" {
+ return nil
+ }
+ select {
+ case chunks <- *delta:
+ return nil
+ case <-ctx.Done():
+ return ctx.Err()
+ }
+ })
+ if err != nil && ctx.Err() == nil {
+ errs <- err
+ }
+ }()
+ return chunks, errs
+}
+
func collectMindMapStream(ctx context.Context, chunks <-chan string, streamErrs <-chan error) (string, error) {
var sb strings.Builder
for chunk := range chunks {
diff --git a/internal/handler/providers.go b/internal/handler/providers.go
index f553e4d8a6..0e2f2eaba6 100644
--- a/internal/handler/providers.go
+++ b/internal/handler/providers.go
@@ -222,14 +222,16 @@ func (h *ProviderHandler) ListModels(c *gin.Context) {
if liveModels, err := driver.ListModels(c.Request.Context(), apiConfig); err == nil {
remoteFetched = true
for _, m := range liveModels {
- maxTokens := 8192
- if m.MaxOutput != nil {
- maxTokens = *m.MaxOutput
+ legacyMaxTokens := 0
+ if m.ContextLength != nil {
+ legacyMaxTokens = *m.ContextLength
}
remoteModels = append(remoteModels, map[string]interface{}{
- "name": m.Name,
- "model_types": m.ModelTypes,
- "max_tokens": maxTokens,
+ "name": m.Name,
+ "model_types": m.ModelTypes,
+ "context_length": m.ContextLength,
+ "max_output": m.MaxOutput,
+ "max_tokens": legacyMaxTokens,
})
}
} else if bedrockAPIKeyAuth {
@@ -285,16 +287,15 @@ func (h *ProviderHandler) ListModels(c *gin.Context) {
// wins, so a model already saved under the catalog's name keeps it.
//
// Remote entries override the catalog entry, with two exceptions: a remote
-// entry that carries no model types inherits the catalog's types, and
-// `max_tokens` always comes from the catalog when the catalog declares one —
-// an upstream listing reports the provider's ceiling, which is not the value
-// RAGFlow is configured to send.
+// entry that carries no model types inherits the catalog's types, and the
+// legacy `max_tokens` alias remains the input/context window. `max_output` is
+// kept as a separate provider generation ceiling.
func mergeProviderModels(staticModels, remoteModels []map[string]interface{}) []map[string]interface{} {
merged := make(map[string]map[string]interface{}, len(staticModels)+len(remoteModels))
for _, m := range staticModels {
if maxTokens, ok := m["max_tokens"]; !ok || maxTokens == nil {
- if maxOutput, ok := m["max_output"]; ok && maxOutput != nil {
- m["max_tokens"] = maxOutput
+ if contextLength, ok := m["context_length"]; ok && contextLength != nil {
+ m["max_tokens"] = contextLength
}
}
name, ok := m["name"].(string)
diff --git a/internal/handler/providers_test.go b/internal/handler/providers_test.go
index b4821f6a3e..4be18e967a 100644
--- a/internal/handler/providers_test.go
+++ b/internal/handler/providers_test.go
@@ -185,6 +185,24 @@ func TestMergeProviderModelsMatchesNamesCaseInsensitively(t *testing.T) {
}
}
+func TestMergeProviderModelsDoesNotUseMaxOutputAsContextWindow(t *testing.T) {
+ static := []map[string]interface{}{
+ {"name": "chat-model", "model_types": []string{"chat"}, "context_length": 128000, "max_output": 4096},
+ }
+ remote := []map[string]interface{}{
+ {"name": "CHAT-MODEL", "model_types": []string{"chat"}, "context_length": 256000, "max_output": 8192},
+ }
+
+ got := indexProviderModels(t, mergeProviderModels(static, remote))
+ model := got["chat-model"]
+ if model["max_tokens"] != 128000 {
+ t.Fatalf("legacy max_tokens = %v, want catalog context length 128000", model["max_tokens"])
+ }
+ if model["max_output"] != 8192 {
+ t.Fatalf("max_output = %v, want remote output ceiling 8192", model["max_output"])
+ }
+}
+
func TestMergeProviderModelsInheritsCatalogTypesOnConflict(t *testing.T) {
static := []map[string]interface{}{
{"name": "rerank-1", "model_types": []string{"rerank"}, "max_tokens": 1024},
diff --git a/internal/handler/search.go b/internal/handler/search.go
index dd74758352..a80c18b3fa 100644
--- a/internal/handler/search.go
+++ b/internal/handler/search.go
@@ -31,7 +31,7 @@ import (
type SearchHandler struct {
searchService *service.SearchService
userService *service.UserService
- streamLLM *service.ModelProviderService
+ modelFactory *service.ModelFactory
askService *service.AskService
sseWriter SSEWriter
}
@@ -46,8 +46,8 @@ func NewSearchHandler(searchService *service.SearchService, userService *service
}
// SetCompletionDependencies wires the streaming search completion runtime.
-func (h *SearchHandler) SetCompletionDependencies(streamLLM *service.ModelProviderService, askService *service.AskService) {
- h.streamLLM = streamLLM
+func (h *SearchHandler) SetCompletionDependencies(modelFactory *service.ModelFactory, askService *service.AskService) {
+ h.modelFactory = modelFactory
h.askService = askService
}
@@ -426,12 +426,12 @@ func (h *SearchHandler) Completion(c *gin.Context) {
writer.Write(c, sseError("ask service not configured"))
return
}
- if h.streamLLM == nil {
- writer.Write(c, sseError("streaming LLM not configured"))
+ if h.modelFactory == nil {
+ writer.Write(c, sseError("model factory not configured"))
return
}
- adapter := &service.TenantStreamAdapter{LLM: h.streamLLM, TenantID: plan.UserID, ModelID: plan.ModelID}
+ adapter := &service.TenantStreamAdapter{Factory: h.modelFactory, TenantID: plan.UserID, ModelID: plan.ModelID}
hadError := false
for delta := range h.askService.StreamWithOptions(c.Request.Context(), adapter, plan.UserID, plan.Question, plan.DatasetIDs, plan.Options) {
diff --git a/internal/handler/searchbot.go b/internal/handler/searchbot.go
index 85e2096e80..e9640182f2 100644
--- a/internal/handler/searchbot.go
+++ b/internal/handler/searchbot.go
@@ -103,23 +103,19 @@ type SearchBotRequest struct {
// POST /api/v1/searchbots/ask
// POST /api/v1/searchbots/mindmap
type SearchBotHandler struct {
- searchSvc *service.SearchService
- tenantSvc *service.TenantService
- llm *service.ModelProviderService
- streamLLM *service.ModelProviderService
- chunkSvc service.Retriever
- askSvc *service.AskService
- sseWriter SSEWriter
+ searchSvc *service.SearchService
+ tenantSvc *service.TenantService
+ modelFactory *service.ModelFactory
+ chunkSvc service.Retriever
+ askSvc *service.AskService
+ sseWriter SSEWriter
}
// NewSearchBotHandler creates a new SearchBotHandler.
-func NewSearchBotHandler(searchSvc *service.SearchService, tenantSvc *service.TenantService, llm *service.ModelProviderService, chunkSvc service.Retriever) *SearchBotHandler {
- return &SearchBotHandler{searchSvc: searchSvc, tenantSvc: tenantSvc, llm: llm, chunkSvc: chunkSvc, sseWriter: &ginSSEWriter{}}
+func NewSearchBotHandler(searchSvc *service.SearchService, tenantSvc *service.TenantService, modelFactory *service.ModelFactory, chunkSvc service.Retriever) *SearchBotHandler {
+ return &SearchBotHandler{searchSvc: searchSvc, tenantSvc: tenantSvc, modelFactory: modelFactory, chunkSvc: chunkSvc, sseWriter: &ginSSEWriter{}}
}
-// SetStreamLLM sets the streaming LLM for the Ask endpoint.
-func (h *SearchBotHandler) SetStreamLLM(llm *service.ModelProviderService) { h.streamLLM = llm }
-
// SetAskService sets the AskService used by the Ask endpoint.
func (h *SearchBotHandler) SetAskService(svc *service.AskService) { h.askSvc = svc }
@@ -151,7 +147,7 @@ func (h *SearchBotHandler) Handle(c *gin.Context) {
return
}
- questions, err := service.GenerateRelatedQuestions(ctx, user.ID, req.Question, req.SearchID, h.searchSvc, h.tenantSvc, h.llm)
+ questions, err := service.GenerateRelatedQuestions(ctx, user.ID, req.Question, req.SearchID, h.searchSvc, h.tenantSvc, h.modelFactory)
if err != nil {
common.Warn("searchbot related questions failed", zap.String("error", err.Error()))
common.ResponseWithCodeData(c, common.CodeOperatingError, nil, err.Error())
@@ -297,12 +293,12 @@ func (h *SearchBotHandler) Ask(c *gin.Context) {
h.sseWriter.Write(c, sseError("ask service not configured"))
return
}
- if h.streamLLM == nil {
- h.sseWriter.Write(c, sseError("streaming LLM not configured"))
+ if h.modelFactory == nil {
+ h.sseWriter.Write(c, sseError("model factory not configured"))
return
}
ctx := c.Request.Context()
- adapter := &service.TenantStreamAdapter{LLM: h.streamLLM, TenantID: user.ID, ModelID: modelID}
+ adapter := &service.TenantStreamAdapter{Factory: h.modelFactory, TenantID: user.ID, ModelID: modelID}
for delta := range h.askSvc.StreamWithOptions(ctx, adapter, user.ID, req.Question, filtered, options) {
switch delta.Kind {
case service.AskDeltaAnswer:
@@ -358,7 +354,7 @@ func (h *SearchBotHandler) MindMap(c *gin.Context) {
jsonInternalError(c, fmt.Errorf("chunk service not configured"))
return
}
- if h.llm == nil {
+ if h.modelFactory == nil {
jsonInternalError(c, fmt.Errorf("LLM not configured"))
return
}
@@ -387,7 +383,7 @@ func (h *SearchBotHandler) MindMap(c *gin.Context) {
AuthUserID: user.ID,
ModelTenantID: user.ID,
ChunkSvc: h.chunkSvc,
- LLM: h.llm,
+ LLM: h.modelFactory,
TenantSvc: h.tenantSvc,
})
if err != nil {
diff --git a/internal/ingestion/component/dispatch_model.go b/internal/ingestion/component/dispatch_model.go
index 649fd683f6..f0244c44c5 100644
--- a/internal/ingestion/component/dispatch_model.go
+++ b/internal/ingestion/component/dispatch_model.go
@@ -247,9 +247,13 @@ func resolveModelConfigByID(ctx context.Context, db *gorm.DB, tenantID string, m
if err != nil {
return nil, "", nil, 0, err
}
- maxTokens := 0
- if mi, _ := dao.GetModelProviderManager().GetModelByName(provider.ProviderName, modelObj.ModelName); mi != nil && mi.MaxOutput != nil {
- maxTokens = *mi.MaxOutput
+ contextLength := 0
+ if mi, _ := dao.GetModelProviderManager().GetModelByName(provider.ProviderName, modelObj.ModelName); mi != nil {
+ if mi.ContextLength != nil {
+ contextLength = *mi.ContextLength
+ } else if mi.MaxTokens != nil {
+ contextLength = *mi.MaxTokens
+ }
}
if strings.TrimSpace(modelObj.Extra) != "" {
var tenantExtra tenantModelExtra
@@ -257,11 +261,11 @@ func resolveModelConfigByID(ctx context.Context, db *gorm.DB, tenantID string, m
return nil, "", nil, 0, err
}
if tenantExtra.MaxTokens != nil && *tenantExtra.MaxTokens > 0 {
- maxTokens = *tenantExtra.MaxTokens
+ contextLength = *tenantExtra.MaxTokens
}
}
apiConfig := &modelModule.APIConfig{ApiKey: &apiKey, Region: &region, BaseURL: &baseURL}
- return driver, modelObj.ModelName, apiConfig, maxTokens, nil
+ return driver, modelObj.ModelName, apiConfig, contextLength, nil
}
func resolveModelConfigFromProviderInstance(ctx context.Context, db *gorm.DB, tenantID string, modelType entity.ModelType, modelName string) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
@@ -305,9 +309,13 @@ func resolveModelConfigFromProviderInstance(ctx context.Context, db *gorm.DB, te
if err != nil {
return nil, "", nil, 0, err
}
- maxTokens := 0
- if mi, _ := dao.GetModelProviderManager().GetModelByName(providerName, pureModelName); mi != nil && mi.MaxOutput != nil {
- maxTokens = *mi.MaxOutput
+ contextLength := 0
+ if mi, _ := dao.GetModelProviderManager().GetModelByName(providerName, pureModelName); mi != nil {
+ if mi.ContextLength != nil {
+ contextLength = *mi.ContextLength
+ } else if mi.MaxTokens != nil {
+ contextLength = *mi.MaxTokens
+ }
}
if modelObj != nil && strings.TrimSpace(modelObj.Extra) != "" {
var tenantExtra tenantModelExtra
@@ -315,11 +323,11 @@ func resolveModelConfigFromProviderInstance(ctx context.Context, db *gorm.DB, te
return nil, "", nil, 0, err
}
if tenantExtra.MaxTokens != nil && *tenantExtra.MaxTokens > 0 {
- maxTokens = *tenantExtra.MaxTokens
+ contextLength = *tenantExtra.MaxTokens
}
}
apiConfig := &modelModule.APIConfig{ApiKey: &apiKey, Region: &region, BaseURL: &baseURL}
- return driver, modelObj.ModelName, apiConfig, maxTokens, nil
+ return driver, modelObj.ModelName, apiConfig, contextLength, nil
case !errorsIsRecordNotFound(modelErr):
return nil, "", nil, 0, fmt.Errorf("model %q lookup failed: %w", modelName, modelErr)
}
@@ -347,11 +355,13 @@ func resolveModelConfigFromProviderInstance(ctx context.Context, db *gorm.DB, te
return nil, "", nil, 0, err
}
apiConfig := &modelModule.APIConfig{ApiKey: &apiKey, Region: &region, BaseURL: &baseURL}
- maxTokens := 0
- if llmInfo.MaxOutput != nil {
- maxTokens = *llmInfo.MaxOutput
+ contextLength := 0
+ if llmInfo.ContextLength != nil {
+ contextLength = *llmInfo.ContextLength
+ } else if llmInfo.MaxTokens != nil {
+ contextLength = *llmInfo.MaxTokens
}
- return driver, llmInfo.Name, apiConfig, maxTokens, nil
+ return driver, llmInfo.Name, apiConfig, contextLength, nil
}
func parseCompositeModelName(compositeName string) (modelName, instanceName, providerName string, err error) {
diff --git a/internal/ingestion/component/knowledge_compiler/common/deps.go b/internal/ingestion/component/knowledge_compiler/common/deps.go
index dacd7d3127..d2f3652951 100644
--- a/internal/ingestion/component/knowledge_compiler/common/deps.go
+++ b/internal/ingestion/component/knowledge_compiler/common/deps.go
@@ -190,8 +190,9 @@ type Deps struct {
ModelMaxOutput int
}
-// DepsResolver resolves the per-run Deps from a tenant/llm/embedding triple.
-type DepsResolver func(tenantID, llmID, embeddingModel string) (Deps, error)
+// DepsResolver resolves the per-run Deps from the active task context and
+// tenant/model references.
+type DepsResolver func(ctx context.Context, tenantID, llmID, embeddingModel string) (Deps, error)
// DepsResolver / SetDepsResolver / ResolveDeps are the only injection seams the
// component exposes. The component is DB-independent: it compiles knowledge
@@ -214,14 +215,14 @@ func SetDepsResolver(r DepsResolver) {
}
// ResolveDeps resolves Deps via the installed resolver.
-func ResolveDeps(tenantID, llmID, embeddingModel string) (Deps, error) {
+func ResolveDeps(ctx context.Context, tenantID, llmID, embeddingModel string) (Deps, error) {
depsResolverMu.RLock()
r := depsResolver
depsResolverMu.RUnlock()
if r == nil {
return Deps{}, fmt.Errorf("knowledge_compiler: no DepsResolver registered (call common.SetDepsResolver in production wiring)")
}
- return r(tenantID, llmID, embeddingModel)
+ return r(ctx, tenantID, llmID, embeddingModel)
}
// GroupResolver resolves compilation-template-group ids to the concrete
diff --git a/internal/ingestion/component/knowledge_compiler/component.go b/internal/ingestion/component/knowledge_compiler/component.go
index 5dbb2c0aed..892a352488 100644
--- a/internal/ingestion/component/knowledge_compiler/component.go
+++ b/internal/ingestion/component/knowledge_compiler/component.go
@@ -149,7 +149,7 @@ func (c *KnowledgeCompilerComponent) Invoke(ctx context.Context, db *gorm.DB, in
specParam.TemplateConfig = spec.Config
overlayTemplateConfig(&specParam, spec.Config)
- deps, err := common.ResolveDeps(tenantID, specParam.LLMID, specParam.EmbeddingModel)
+ deps, err := common.ResolveDeps(ctx, tenantID, specParam.LLMID, specParam.EmbeddingModel)
if err != nil {
return nil, err
}
diff --git a/internal/ingestion/component/knowledge_compiler/component_test.go b/internal/ingestion/component/knowledge_compiler/component_test.go
index 3b06bd49da..e26a3bcc1f 100644
--- a/internal/ingestion/component/knowledge_compiler/component_test.go
+++ b/internal/ingestion/component/knowledge_compiler/component_test.go
@@ -150,7 +150,7 @@ func firstWords(s string, n int) string {
func installProseDeps(t *testing.T) {
t.Helper()
- common.SetDepsResolver(func(tenantID, llmID, embeddingModel string) (common.Deps, error) {
+ common.SetDepsResolver(func(_ context.Context, tenantID, llmID, embeddingModel string) (common.Deps, error) {
return common.Deps{Chat: proseChat{}, Embed: mockEmbedder{dim: 8}, TenantID: tenantID}, nil
})
t.Cleanup(func() { common.SetDepsResolver(nil) })
@@ -179,7 +179,7 @@ func deterministicVec(s string, dim int) []float32 {
func installMockDeps(t *testing.T) {
t.Helper()
- common.SetDepsResolver(func(tenantID, llmID, embeddingModel string) (common.Deps, error) {
+ common.SetDepsResolver(func(_ context.Context, tenantID, llmID, embeddingModel string) (common.Deps, error) {
return common.Deps{Chat: mockChat{}, Embed: mockEmbedder{dim: 8}, TenantID: tenantID}, nil
})
t.Cleanup(func() { common.SetDepsResolver(nil) })
@@ -447,7 +447,7 @@ func wikiScopeFixtureChunks() []any {
func installStrictScopeWikiDeps(t *testing.T, store *strictScopeWikiMapVersions) {
t.Helper()
- common.SetDepsResolver(func(tenantID, _, _ string) (common.Deps, error) {
+ common.SetDepsResolver(func(_ context.Context, tenantID, _, _ string) (common.Deps, error) {
return common.Deps{
Chat: proseChat{},
Embed: mockEmbedder{dim: 8},
@@ -781,7 +781,7 @@ func TestKnowledgeCompiler_Tree_DegenerateNoInfiniteLoop(t *testing.T) {
// product share one vector, and we supply that vector as a historical candidate;
// the run must drop the near-duplicate products so none survive in the output.
func TestKnowledgeCompiler_Wiki_HistoricalDedupDropsDuplicates(t *testing.T) {
- common.SetDepsResolver(func(tenantID, llmID, embeddingModel string) (common.Deps, error) {
+ common.SetDepsResolver(func(_ context.Context, tenantID, llmID, embeddingModel string) (common.Deps, error) {
return common.Deps{
Chat: proseChat{},
Embed: constEmbedder{dim: 8, vec: []float32{1, 0, 0, 0, 0, 0, 0, 0}},
@@ -829,7 +829,7 @@ func TestKnowledgeCompiler_Wiki_HistoricalDedupDropsDuplicates(t *testing.T) {
}
func TestKnowledgeCompiler_Wiki_UpdateMergesExistingPage(t *testing.T) {
- common.SetDepsResolver(func(tenantID, llmID, embeddingModel string) (common.Deps, error) {
+ common.SetDepsResolver(func(_ context.Context, tenantID, llmID, embeddingModel string) (common.Deps, error) {
return common.Deps{
Chat: wikiUpdateChat{},
Embed: mockEmbedder{dim: 8},
@@ -920,7 +920,7 @@ func (f *fakeHistoricalKNN) TopKHistory(_ context.Context, _ string, datasetID,
// scoped to the dataset, not the document.
func TestKnowledgeCompiler_Wiki_HistoricalDedupScopedByDataset(t *testing.T) {
knn := &fakeHistoricalKNN{hit: true} // every product is a near-dup -> dropped
- common.SetDepsResolver(func(tenantID, llmID, embeddingModel string) (common.Deps, error) {
+ common.SetDepsResolver(func(_ context.Context, tenantID, llmID, embeddingModel string) (common.Deps, error) {
return common.Deps{
Chat: proseChat{},
Embed: constEmbedder{dim: 8, vec: []float32{1, 0, 0, 0, 0, 0, 0, 0}},
@@ -1040,7 +1040,7 @@ func (s wikiStoreTestStub) GetPageBySlug(_ context.Context, _, _, slug string) (
// entity/relation. A fenced ```json ... ``` reply is now unwrapped and parsed,
// so the extraction still yields its entities.
func TestKnowledgeCompiler_Structure_FencedJSONNotDropped(t *testing.T) {
- common.SetDepsResolver(func(tenantID, llmID, embeddingModel string) (common.Deps, error) {
+ common.SetDepsResolver(func(_ context.Context, tenantID, llmID, embeddingModel string) (common.Deps, error) {
return common.Deps{Chat: fencedChat{}, Embed: mockEmbedder{dim: 8}, TenantID: tenantID}, nil
})
t.Cleanup(func() { common.SetDepsResolver(nil) })
@@ -1080,7 +1080,7 @@ func TestKnowledgeCompiler_Structure_FencedJSONNotDropped(t *testing.T) {
// regression: when the reply is genuinely unparseable (not just fenced), the
// component must fail loudly instead of silently emitting zero knowledge units.
func TestKnowledgeCompiler_Structure_MalformedJSONFailsLoud(t *testing.T) {
- common.SetDepsResolver(func(tenantID, llmID, embeddingModel string) (common.Deps, error) {
+ common.SetDepsResolver(func(_ context.Context, tenantID, llmID, embeddingModel string) (common.Deps, error) {
return common.Deps{Chat: proseOnlyChat{}, Embed: mockEmbedder{dim: 8}, TenantID: tenantID}, nil
})
t.Cleanup(func() { common.SetDepsResolver(nil) })
diff --git a/internal/ingestion/component/knowledge_compiler/golden_test.go b/internal/ingestion/component/knowledge_compiler/golden_test.go
index 53b885c999..acbd2b621f 100644
--- a/internal/ingestion/component/knowledge_compiler/golden_test.go
+++ b/internal/ingestion/component/knowledge_compiler/golden_test.go
@@ -56,7 +56,7 @@ func signedVec(str string, dim int) []float32 {
// installSignedProseDeps wires a prose LLM + signed deterministic embedder.
func installSignedProseDeps(t *testing.T) {
t.Helper()
- common.SetDepsResolver(func(tenantID, llmID, embeddingModel string) (common.Deps, error) {
+ common.SetDepsResolver(func(_ context.Context, tenantID, llmID, embeddingModel string) (common.Deps, error) {
return common.Deps{Chat: proseChat{}, Embed: signedEmbedder{dim: 8}, TenantID: tenantID}, nil
})
t.Cleanup(func() { common.SetDepsResolver(nil) })
diff --git a/internal/ingestion/knowledge_compile/consumer.go b/internal/ingestion/knowledge_compile/consumer.go
index 7fd9444541..08810af73d 100644
--- a/internal/ingestion/knowledge_compile/consumer.go
+++ b/internal/ingestion/knowledge_compile/consumer.go
@@ -717,7 +717,7 @@ func (c *Consumer) processBatch(ctx context.Context, tenant, kb, token string, e
c.reportProgress(ctx, tenant, kb, token, taskTypes, 1, "completed", "Document availability changes applied")
return nil
}
- deduper, err := c.factory(tenant)
+ deduper, err := c.factory(ctx, tenant)
if err != nil || deduper == nil {
// A no-op deduper would silently disable dataset-level LLM merging: every
// candidate (including e.g. a "吕布" wiki_page) would be written as its own
@@ -1291,7 +1291,7 @@ func rewriteMergedWikiPages(ctx context.Context, tenant string, pages []kccommon
if len(indexes) == 0 {
return nil
}
- deps, err := kccommon.ResolveDeps(tenant, defaultLLMID, defaultEmbedding)
+ deps, err := kccommon.ResolveDeps(ctx, tenant, defaultLLMID, defaultEmbedding)
if err != nil {
return fmt.Errorf("resolve Wiki page rewrite dependencies: %w", err)
}
@@ -1386,7 +1386,7 @@ func refreshWikiProductVectors(ctx context.Context, tenant string, products []kc
if len(products) == 0 {
return products
}
- deps, err := kccommon.ResolveDeps(tenant, defaultLLMID, defaultEmbedding)
+ deps, err := kccommon.ResolveDeps(ctx, tenant, defaultLLMID, defaultEmbedding)
if err != nil || deps.Embed == nil {
return products
}
diff --git a/internal/ingestion/knowledge_compile/dedup.go b/internal/ingestion/knowledge_compile/dedup.go
index a35c0c5702..0b167c1071 100644
--- a/internal/ingestion/knowledge_compile/dedup.go
+++ b/internal/ingestion/knowledge_compile/dedup.go
@@ -56,7 +56,7 @@ type MergeGroup struct {
// DeduperFactory builds a per-tenant Deduper. It is invoked once per batch so
// the LLM deps can be resolved for the owning tenant.
-type DeduperFactory func(tenant string) (Deduper, error)
+type DeduperFactory func(ctx context.Context, tenant string) (Deduper, error)
// llmDeduper wraps the component's GroupedDeduper (which internally uses
// LLMMergeDecider for duplicate-judging), scoped to the whole KB batch.
diff --git a/internal/ingestion/knowledge_compile/nav_lifecycle_test.go b/internal/ingestion/knowledge_compile/nav_lifecycle_test.go
index fe752cebad..4109665b35 100644
--- a/internal/ingestion/knowledge_compile/nav_lifecycle_test.go
+++ b/internal/ingestion/knowledge_compile/nav_lifecycle_test.go
@@ -123,7 +123,7 @@ func TestProcessBatchReaddsEnabledDocumentToNavigation(t *testing.T) {
Meta: map[string]any{"kind": "root"},
}}}),
WithWriter(&fakeWriter{}),
- WithDeduperFactory(func(string) (Deduper, error) { return NewNoopDeduper(), nil }),
+ WithDeduperFactory(func(context.Context, string) (Deduper, error) { return NewNoopDeduper(), nil }),
withWikiContributionStore(&memoryWikiContributionStore{items: map[string]wikiDocumentContribution{}}),
)
@@ -158,7 +158,7 @@ func TestProcessBatchRemovesNavigationForGraphOnlyDocument(t *testing.T) {
Meta: map[string]any{"kind": "entity"},
}}}),
WithWriter(&fakeWriter{}),
- WithDeduperFactory(func(string) (Deduper, error) { return NewNoopDeduper(), nil }),
+ WithDeduperFactory(func(context.Context, string) (Deduper, error) { return NewNoopDeduper(), nil }),
withWikiContributionStore(&memoryWikiContributionStore{items: map[string]wikiDocumentContribution{}}),
)
diff --git a/internal/ingestion/knowledge_compile/service.go b/internal/ingestion/knowledge_compile/service.go
index 3f181b4d50..086cbe8c84 100644
--- a/internal/ingestion/knowledge_compile/service.go
+++ b/internal/ingestion/knowledge_compile/service.go
@@ -114,8 +114,8 @@ func InitializePublisher(db *gorm.DB, mq engine.MessageQueue) {
// KB-scoped deduper. On any failure it returns an error so the caller falls
// back to the noop deduper (merged products are still written, just without
// cross-document LLM merging).
-func defaultDeduperFactory(tenant string) (Deduper, error) {
- deps, err := kccommon.ResolveDeps(tenant, defaultLLMID, defaultEmbedding)
+func defaultDeduperFactory(ctx context.Context, tenant string) (Deduper, error) {
+ deps, err := kccommon.ResolveDeps(ctx, tenant, defaultLLMID, defaultEmbedding)
if err != nil {
return nil, err
}
diff --git a/internal/ingestion/knowledge_compile/wiki_contribution_test.go b/internal/ingestion/knowledge_compile/wiki_contribution_test.go
index 3a4c942991..ab4db7bc1e 100644
--- a/internal/ingestion/knowledge_compile/wiki_contribution_test.go
+++ b/internal/ingestion/knowledge_compile/wiki_contribution_test.go
@@ -78,7 +78,7 @@ func TestProcessBatchRetractionWithoutWikiContributionSkipsMerge(t *testing.T) {
WithReader(&fakeReader{}),
WithWriter(fw),
withWikiContributionStore(store),
- WithDeduperFactory(func(string) (Deduper, error) {
+ WithDeduperFactory(func(context.Context, string) (Deduper, error) {
factoryCalled = true
return nil, nil
}),
@@ -109,7 +109,7 @@ func TestProcessBatchSkipsUnchangedWikiOnlyEvent(t *testing.T) {
consumer := NewConsumer(NewFakeScheduler(),
WithReader(&fakeReader{products: []kccommon.Product{product}}),
withWikiContributionStore(store),
- WithDeduperFactory(func(string) (Deduper, error) {
+ WithDeduperFactory(func(context.Context, string) (Deduper, error) {
factoryCalled = true
return nil, nil
}),
diff --git a/internal/ingestion/task/embedder.go b/internal/ingestion/task/embedder.go
index 2707130975..520625aa93 100644
--- a/internal/ingestion/task/embedder.go
+++ b/internal/ingestion/task/embedder.go
@@ -35,7 +35,6 @@ import (
"ragflow/internal/common"
"ragflow/internal/dao"
- "ragflow/internal/entity"
"ragflow/internal/entity/models"
componentpkg "ragflow/internal/ingestion/component"
"ragflow/internal/service"
@@ -687,7 +686,7 @@ func newEmbedderResolver(
// so the concrete resolver is injected here - the task package is the
// composition root for ingestion runs.
func init() {
- modelSolver := service.NewModelSolver()
+ modelFactory := service.NewModelFactory()
componentpkg.DefaultEmbedderResolver = newEmbedderResolver(
func(ctx context.Context, kbID string) (string, error) {
kb, err := dao.NewKnowledgebaseDAO().GetByID(ctx, dao.DB, kbID)
@@ -700,11 +699,11 @@ func init() {
return kb.EmbdID, nil
},
func(ctx context.Context, tenantID, embdID string) (*models.EmbeddingModel, error) {
- target, err := modelSolver.ResolveModelConfig(ctx, tenantID, entity.ModelTypeEmbedding, embdID)
+ embeddingModel, err := modelFactory.NewEmbeddingModel(ctx, service.ModelAccess{TenantID: tenantID}, embdID)
if err != nil {
return nil, err
}
- return models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens), nil
+ return embeddingModel, nil
},
)
}
diff --git a/internal/ingestion/task/knowledge_compiler_wiring.go b/internal/ingestion/task/knowledge_compiler_wiring.go
index e9b5c1adac..ddc72e59b2 100644
--- a/internal/ingestion/task/knowledge_compiler_wiring.go
+++ b/internal/ingestion/task/knowledge_compiler_wiring.go
@@ -425,14 +425,13 @@ func putWikiActiveStates(ctx context.Context, docEngine engine.DocEngine, states
// chunk table needs. The document-level compile path holds no embedder, so it
// binds the dataset's — kb.tenant_embd_id, else kb.embd_id — like a compile task.
func wikiMapVectorSizeResolver(tenantID, datasetID string) func(context.Context) (int, error) {
- svc := service.NewModelProviderService()
- modelSolver := service.NewModelSolver()
+ modelFactory := service.NewModelFactory()
return func(ctx context.Context) (int, error) {
kb, err := dao.NewKnowledgebaseDAO().GetByID(ctx, dao.DB, datasetID)
if err != nil {
return 0, fmt.Errorf("Wiki MAP chunk store: load dataset %s: %w", datasetID, err)
}
- embedder := &kcEmbedder{svc: svc, solver: modelSolver, tenantID: tenantID, embdID: datasetEmbeddingID(kb)}
+ embedder := &kcEmbedder{factory: modelFactory, tenantID: tenantID, embdID: datasetEmbeddingID(kb)}
return embedderVectorSize(ctx, embedder)
}
}
@@ -548,9 +547,10 @@ func newKnowledgeCompilerTemplateResolver() kc.TemplateResolver {
// tenant + model ids (captured in the closure), mirroring how the Tokenizer
// component resolves its embedder.
func newKnowledgeCompilerDepsResolver() kc.DepsResolver {
- svc := service.NewModelProviderService()
- modelSolver := service.NewModelSolver()
- return func(tenantID, llmID, embeddingModel string) (kc.Deps, error) {
+ modelFactory := service.NewModelFactory()
+ return func(ctx context.Context, tenantID, llmID, embeddingModel string) (kc.Deps, error) {
+ modelCtx, cancelModelLookup := context.WithTimeout(ctx, 30*time.Second)
+ defer cancelModelLookup()
if strings.TrimSpace(llmID) == "" {
// No explicit chat model was supplied (e.g. the dataset-level deduper
// is seeded with a global default that may be empty). Resolve the
@@ -558,11 +558,11 @@ func newKnowledgeCompilerDepsResolver() kc.DepsResolver {
// actually run instead of failing / falling back to a no-op. Use the
// tenant model ID so later model resolution can use the same persisted
// tenant model directly.
- defaultTarget, derr := modelSolver.ResolveDefaultModelConfig(context.Background(), tenantID, entity.ModelTypeChat)
- if derr != nil || defaultTarget == nil || strings.TrimSpace(defaultTarget.ModelID) == "" {
+ defaultInfo, derr := modelFactory.ResolveDefaultInfo(modelCtx, service.ModelAccess{TenantID: tenantID}, entity.ModelTypeChat)
+ if derr != nil || defaultInfo == nil || strings.TrimSpace(defaultInfo.ID) == "" {
return kc.Deps{}, fmt.Errorf("knowledge_compiler: llm_id is empty and no tenant default chat model available: %w", derr)
}
- llmID = defaultTarget.ModelID
+ llmID = defaultInfo.ID
// Keep the fall-through path below for ModelContextLen resolution so
// both explicit and default model refs share one context-window path.
}
@@ -571,32 +571,29 @@ func newKnowledgeCompilerDepsResolver() kc.DepsResolver {
// ContextLength is the total context window; MaxTokens is only the
// generation cap and must not be used as the input budget.
llmMax := kc.DefaultLLMContextLength
- // Bound the model-config lookup so a stalled provider/instance DB read
- // cannot block document ingestion indefinitely.
- contextLengthCtx, cancelContextLength := context.WithTimeout(context.Background(), 30*time.Second)
- modelTarget, contextLengthErr := modelSolver.ResolveModelConfig(contextLengthCtx, tenantID, entity.ModelTypeChat, llmID)
- cancelContextLength()
- if contextLengthErr == nil && modelTarget != nil && modelTarget.ContextLength > 0 {
- llmMax = modelTarget.ContextLength
+ // Bound the model-config lookup and inherit cancellation from the task.
+ modelInfo, contextLengthErr := modelFactory.ResolveInfo(modelCtx, service.ModelAccess{TenantID: tenantID}, entity.ModelTypeChat, llmID)
+ if contextLengthErr == nil && modelInfo != nil && modelInfo.ContextLength > 0 {
+ llmMax = modelInfo.ContextLength
}
// Resolve the model's generation cap (max_output). Cross-document merge
// judging packs many pairs into one LLM call; the batch must be bounded by
// BOTH the input window and this output cap, so a large candidate set
- // never overflows max_output and yields a truncated/non-JSON reply. This
- // uses max_tokens (the generation cap), NOT content_length — see
- // ModelSolver.ResolveModelConfig's ContextLength and MaxTokens fields.
+ // never overflows max_output and yields a truncated/non-JSON reply. The
+ // legacy persisted max_tokens value is the context window; use the
+ // separate MaxOutput metadata for the API generation cap.
llmMaxOutput := 0
- if contextLengthErr == nil && modelTarget != nil && modelTarget.MaxTokens > 0 {
- llmMaxOutput = modelTarget.MaxTokens
+ if contextLengthErr == nil && modelInfo != nil && modelInfo.MaxOutput > 0 {
+ llmMaxOutput = modelInfo.MaxOutput
}
- embedder := &kcEmbedder{svc: svc, solver: modelSolver, tenantID: tenantID, embdID: embeddingModel}
+ embedder := &kcEmbedder{factory: modelFactory, tenantID: tenantID, embdID: embeddingModel}
mapStore := knowledge_compile.NewWikiMapVersionStoreWithVectorSizeResolver(engine.Get(), func(ctx context.Context) (int, error) {
return embedderVectorSize(ctx, embedder)
})
return kc.Deps{
- Chat: &kcChatInvoker{svc: svc, tenantID: tenantID, llmID: llmID},
+ Chat: &kcChatInvoker{factory: modelFactory, tenantID: tenantID, llmID: llmID},
Embed: embedder,
WikiPages: &kcWikiPageStore{docEngine: engine.Get()},
WikiMapVersions: mapStore,
@@ -609,10 +606,9 @@ func newKnowledgeCompilerDepsResolver() kc.DepsResolver {
}
}
-// kcChatInvoker adapts service.ModelProviderService.Chat to the
-// knowledge_compiler ChatInvoker seam.
+// kcChatInvoker adapts a factory-created ChatModel to the knowledge compiler.
type kcChatInvoker struct {
- svc *service.ModelProviderService
+ factory *service.ModelFactory
tenantID string
llmID string
}
@@ -622,6 +618,10 @@ func (c *kcChatInvoker) Chat(ctx context.Context, req kc.ChatRequest) (*kc.ChatR
if req.LLMID != "" {
llmID = req.LLMID
}
+ chatModel, err := c.factory.NewChatModel(ctx, service.ModelAccess{TenantID: c.tenantID}, llmID)
+ if err != nil {
+ return nil, err
+ }
msgs := []models.Message{
{Role: "system", Content: req.SystemPrompt},
{Role: "user", Content: req.UserPrompt},
@@ -665,7 +665,7 @@ func (c *kcChatInvoker) Chat(ctx context.Context, req kc.ChatRequest) (*kc.ChatR
// providers legitimately need several minutes to return a response.
attemptCtx, cancel := context.WithTimeout(ctx, kcChatAttemptTimeout)
defer cancel()
- r, err := c.svc.Chat(attemptCtx, c.tenantID, llmID, msgs, config)
+ r, err := chatModel.ChatWithMessages(attemptCtx, msgs, config, nil)
if err != nil {
if !req.DisableRetry {
final := !appcommon.IsTransientError(err) || attempt > kcChatRetryMax
@@ -717,8 +717,7 @@ const kcChatRetryDelay = 2 * time.Second
// kcEmbedder adapts model resolution to the knowledge_compiler Embedder seam.
// Vectors are returned as []float32 to match the component's product schema.
type kcEmbedder struct {
- svc *service.ModelProviderService
- solver *service.ModelSolver
+ factory *service.ModelFactory
tenantID string
embdID string
dim atomic.Int64
@@ -799,23 +798,23 @@ func (e *kcEmbedder) Encode(ctx context.Context, texts []string) ([][]float32, e
// loudly instead of silently producing empty vectors.
func (e *kcEmbedder) resolveModel(ctx context.Context) (*models.EmbeddingModel, error) {
if embdID := strings.TrimSpace(e.embdID); embdID != "" {
- target, err := e.solver.ResolveModelConfig(ctx, e.tenantID, entity.ModelTypeEmbedding, embdID)
+ embeddingModel, err := e.factory.NewEmbeddingModel(ctx, service.ModelAccess{TenantID: e.tenantID}, embdID)
if err != nil {
return nil, fmt.Errorf("knowledge_compiler: resolve embedding model: %w", err)
}
- if target == nil || target.Driver == nil || target.ModelName == "" {
+ if embeddingModel == nil {
return nil, fmt.Errorf("knowledge_compiler: embedding model %q is unavailable", embdID)
}
- return models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens), nil
+ return embeddingModel, nil
}
- target, err := e.solver.ResolveDefaultModelConfig(ctx, e.tenantID, entity.ModelTypeEmbedding)
+ embeddingModel, err := e.factory.NewDefaultEmbeddingModel(ctx, service.ModelAccess{TenantID: e.tenantID})
if err != nil {
return nil, fmt.Errorf("knowledge_compiler: embedding_model is required and no tenant default embedding model is set: %w", err)
}
- if target == nil || target.Driver == nil || target.ModelName == "" {
+ if embeddingModel == nil {
return nil, fmt.Errorf("knowledge_compiler: embedding_model is required (tenant default embedding model unavailable)")
}
- return models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens), nil
+ return embeddingModel, nil
}
func (e *kcEmbedder) Dimensions() int { return int(e.dim.Load()) }
diff --git a/internal/rag/agentic-rag/runtime/tool_exploration.go b/internal/rag/agentic-rag/runtime/tool_exploration.go
index 4274f63bfb..ff0a984bdf 100644
--- a/internal/rag/agentic-rag/runtime/tool_exploration.go
+++ b/internal/rag/agentic-rag/runtime/tool_exploration.go
@@ -633,7 +633,7 @@ func defaultSeedEncoder(ctx context.Context, tenantID, text string) []float64 {
if dao.GetDB() == nil {
return nil
}
- embedder := service.NewNavEmbedder(service.NewModelProviderService(), "")
+ embedder := service.NewNavEmbedder(service.NewModelFactory(), "")
// Query-side encoding: the seed is the user's query, not an indexed document.
vecs, err := embedder.EncodeQueries(ctx, tenantID, []string{text})
if err != nil || len(vecs) == 0 || len(vecs[0]) == 0 {
diff --git a/internal/service/agent.go b/internal/service/agent.go
index c301c9bcb0..514c0a6710 100644
--- a/internal/service/agent.go
+++ b/internal/service/agent.go
@@ -1896,7 +1896,7 @@ func validateAgentChatModels(ctx context.Context, userID string, dsl map[string]
if err != nil {
return nil
}
- modelSolver := NewModelSolver()
+ modelFactory := NewModelFactory()
for _, node := range c.Components {
if !strings.EqualFold(node.Obj.ComponentName, "Agent") {
continue
@@ -1905,7 +1905,7 @@ func validateAgentChatModels(ctx context.Context, userID string, dsl map[string]
if !ok {
modelRef, _ = node.Obj.Params["llm_id"].(string)
}
- if _, err := modelSolver.ResolveModelConfig(ctx, userID, entity.ModelTypeChat, modelRef); err != nil {
+ if _, err := modelFactory.ResolveInfo(ctx, ModelAccess{UserID: userID, TenantID: userID}, entity.ModelTypeChat, modelRef); err != nil {
if errors.Is(err, errModelConfigUnavailable) || errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("The configured chat model is missing or unavailable. Please select a valid model.")
}
diff --git a/internal/service/agentic_pipeline.go b/internal/service/agentic_pipeline.go
index 6009ed264b..5aaf3301e0 100644
--- a/internal/service/agentic_pipeline.go
+++ b/internal/service/agentic_pipeline.go
@@ -57,7 +57,7 @@ const defaultAgenticTemplateID = "smart-reasoning"
// (see buildAgenticReference).
func (s *ChatPipelineService) agenticRag(
ctx context.Context,
- _ string,
+ userID string,
chat *entity.Chat,
messages []map[string]interface{},
stream bool,
@@ -97,7 +97,7 @@ func (s *ChatPipelineService) agenticRag(
}
}
- chain, chainErr := s.agenticModelChain(runCtx, chat)
+ chain, chainErr := s.agenticModelChain(runCtx, userID, chat)
if chainErr != nil {
common.ErrorCtx(runCtx, "agentic_rag: resolve chat model", chainErr)
emitResult(AsyncChatResult{Answer: fmt.Sprintf("**ERROR**: %s", chainErr.Error()), Final: true})
@@ -223,8 +223,9 @@ func (s *ChatPipelineService) agenticRag(
// the dialog configures. Agentic RAG must not silently broaden the dialog's
// model choice to every chat model owned by the tenant: a failover chain is
// exactly the list the dialog's author chose, and nothing else.
-func (s *ChatPipelineService) agenticModelChain(ctx context.Context, chat *entity.Chat) ([]*modelModule.ChatModel, error) {
- primary, err := s.agenticPrimaryModel(ctx, chat)
+func (s *ChatPipelineService) agenticModelChain(ctx context.Context, userID string, chat *entity.Chat) ([]*modelModule.ChatModel, error) {
+ access := ModelAccess{UserID: userID, TenantID: chat.TenantID}
+ primary, err := s.agenticPrimaryModel(ctx, access, chat)
if err != nil {
return nil, err
}
@@ -238,14 +239,13 @@ func (s *ChatPipelineService) agenticModelChain(ctx context.Context, chat *entit
if llmID == "" || llmID == chat.LLMID {
continue
}
- target, resolveErr := s.ModelProviderSvc.modelSolver().
- ResolveModelConfig(ctx, chat.TenantID, entity.ModelTypeChat, llmID)
- if resolveErr != nil || target == nil {
+ model, resolveErr := s.ModelFactory.NewChatModel(ctx, access, llmID)
+ if resolveErr != nil || model == nil {
common.WarnCtx(ctx, "agentic_rag: skipping unresolvable failover model",
zap.String("llm_id", llmID), zap.Error(resolveErr))
continue
}
- chain = append(chain, modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig))
+ chain = append(chain, model)
}
common.InfoCtx(ctx, "agentic model chain resolved",
zap.Int("chain", len(chain)), zap.String("primary", chat.LLMID))
@@ -254,23 +254,23 @@ func (s *ChatPipelineService) agenticModelChain(ctx context.Context, chat *entit
// agenticPrimaryModel resolves the dialog's own model, or the tenant default
// when it selected none.
-func (s *ChatPipelineService) agenticPrimaryModel(ctx context.Context, chat *entity.Chat) (*modelModule.ChatModel, error) {
+func (s *ChatPipelineService) agenticPrimaryModel(ctx context.Context, access ModelAccess, chat *entity.Chat) (*modelModule.ChatModel, error) {
var (
- target *ModelTarget
- err error
+ model *modelModule.ChatModel
+ err error
)
if chat.LLMID == "" {
- target, err = s.ModelProviderSvc.modelSolver().ResolveDefaultModelConfig(ctx, chat.TenantID, entity.ModelTypeChat)
+ model, err = s.ModelFactory.NewDefaultChatModel(ctx, access)
} else {
- target, err = s.ModelProviderSvc.modelSolver().ResolveModelConfig(ctx, chat.TenantID, entity.ModelTypeChat, chat.LLMID)
+ model, err = s.ModelFactory.NewChatModel(ctx, access, chat.LLMID)
}
- if err != nil || target == nil {
- if err == nil {
- err = fmt.Errorf("no chat model resolved for tenant %s", chat.TenantID)
- }
+ if err != nil {
return nil, fmt.Errorf("resolve chat model: %w", err)
}
- return modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig), nil
+ if model == nil {
+ return nil, fmt.Errorf("resolve chat model: no chat model resolved for tenant %s", chat.TenantID)
+ }
+ return model, nil
}
// agenticFailoverModelIDs reads the dialog's ordered failover list from
diff --git a/internal/service/chat.go b/internal/service/chat.go
index 1bdd0fe4b5..46d6005a62 100644
--- a/internal/service/chat.go
+++ b/internal/service/chat.go
@@ -443,12 +443,12 @@ func resolveCreateLLMID(ctx context.Context, llmID, tenantID string, llmSetting
}
}
}
- modelSolver := NewModelSolver()
- target, err := modelSolver.ResolveModelConfig(ctx, tenantID, modelType, llmID)
+ modelFactory := NewModelFactory()
+ target, err := modelFactory.ResolveInfo(ctx, ModelAccess{TenantID: tenantID}, modelType, llmID)
if err != nil {
return "", fmt.Errorf("`llm_id` %s doesn't exist", llmID)
}
- return target.ModelID, nil
+ return target.ID, nil
}
func resolveCreateRerankID(ctx context.Context, rerankID, tenantID string) (string, error) {
@@ -459,12 +459,12 @@ func resolveCreateRerankID(ctx context.Context, rerankID, tenantID string) (stri
if _, ok := DefaultRerankModels[llmName]; ok {
return "", nil
}
- modelSolver := NewModelSolver()
- target, err := modelSolver.ResolveModelConfig(ctx, tenantID, entity.ModelTypeRerank, rerankID)
+ modelFactory := NewModelFactory()
+ target, err := modelFactory.ResolveInfo(ctx, ModelAccess{TenantID: tenantID}, entity.ModelTypeRerank, rerankID)
if err != nil {
return "", fmt.Errorf("`rerank_id` %s doesn't exist", rerankID)
}
- return target.ModelID, nil
+ return target.ID, nil
}
func applyCreatePromptDefaults(req map[string]interface{}) {
@@ -1102,12 +1102,12 @@ func (s *ChatService) resolveRESTLLMID(ctx context.Context, llmID, tenantID stri
}
}
}
- modelSolver := NewModelSolver()
- target, err := modelSolver.ResolveModelConfig(ctx, tenantID, modelType, llmID)
+ modelFactory := NewModelFactory()
+ target, err := modelFactory.ResolveInfo(ctx, ModelAccess{TenantID: tenantID}, modelType, llmID)
if err != nil {
return "", fmt.Errorf("`llm_id` %s doesn't exist", llmID)
}
- return target.ModelID, nil
+ return target.ID, nil
}
func (s *ChatService) resolveRESTRerankID(ctx context.Context, rerankID, tenantID string) (string, error) {
@@ -1118,12 +1118,12 @@ func (s *ChatService) resolveRESTRerankID(ctx context.Context, rerankID, tenantI
if _, ok := defaultRerankModels[baseName]; ok {
return "", nil
}
- modelSolver := NewModelSolver()
- target, err := modelSolver.ResolveModelConfig(ctx, tenantID, entity.ModelTypeRerank, rerankID)
+ modelFactory := NewModelFactory()
+ target, err := modelFactory.ResolveInfo(ctx, ModelAccess{TenantID: tenantID}, entity.ModelTypeRerank, rerankID)
if err != nil {
return "", fmt.Errorf("`rerank_id` %s doesn't exist", rerankID)
}
- return target.ModelID, nil
+ return target.ID, nil
}
func filterRESTChatUpdates(req map[string]interface{}) map[string]interface{} {
diff --git a/internal/service/chat_pipeline.go b/internal/service/chat_pipeline.go
index 2f4df182d5..85031f05a3 100644
--- a/internal/service/chat_pipeline.go
+++ b/internal/service/chat_pipeline.go
@@ -55,17 +55,17 @@ var llmMessageFields = [...]string{"role", "content", "name", "tool_calls", "too
// and all their supporting helpers. Callers (OpenAIChatService, ChatSessionService)
// compose it to avoid code duplication.
type ChatPipelineService struct {
- ModelProviderSvc *ModelProviderService
- MetadataSvc *MetadataService
- kbDAO *dao.KnowledgebaseDAO
+ ModelFactory *ModelFactory
+ MetadataSvc *MetadataService
+ kbDAO *dao.KnowledgebaseDAO
}
// NewChatPipelineService creates a new ChatPipelineService with all required dependencies.
func NewChatPipelineService() *ChatPipelineService {
return &ChatPipelineService{
- ModelProviderSvc: NewModelProviderService(),
- MetadataSvc: NewMetadataService(),
- kbDAO: dao.NewKnowledgebaseDAO(),
+ ModelFactory: NewModelFactory(),
+ MetadataSvc: NewMetadataService(),
+ kbDAO: dao.NewKnowledgebaseDAO(),
}
}
@@ -1667,12 +1667,13 @@ func (s *ChatPipelineService) AsyncChatSolo(
}
}
- // 4. Build the chat model wrapper.
- var target *ModelTarget
+ // 4. Construct the selected chat model through the factory.
+ access := ModelAccess{UserID: userID, TenantID: chat.TenantID}
+ var chatModel *modelModule.ChatModel
if strings.TrimSpace(chat.LLMID) == "" {
- target, err = s.ModelProviderSvc.modelSolver().ResolveDefaultModelConfig(ctx, chat.TenantID, entity.ModelTypeChat)
+ chatModel, err = s.ModelFactory.NewDefaultChatModel(ctx, access)
} else {
- target, err = s.ModelProviderSvc.modelSolver().ResolveModelConfig(ctx, chat.TenantID, entity.ModelTypeChat, chat.LLMID)
+ chatModel, err = s.ModelFactory.NewChatModel(ctx, access, chat.LLMID)
}
if err != nil {
out <- AsyncChatResult{
@@ -1681,19 +1682,17 @@ func (s *ChatPipelineService) AsyncChatSolo(
}
return
}
- chatModel := modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
// 5. Resolve TTS model. Best-effort: warn and proceed without TTS on lookup failure.
var ttsModel *modelModule.TTSModel
if promptConfig != nil {
if useTTS, _ := promptConfig["tts"].(bool); useTTS {
- target, ttsErr := s.ModelProviderSvc.modelSolver().ResolveDefaultModelConfig(ctx, chat.TenantID, entity.ModelTypeTTS)
- if ttsErr != nil || target == nil {
+ ttsModel, err = s.ModelFactory.NewDefaultTTSModel(ctx, access)
+ if err != nil || ttsModel == nil {
common.Warn("AsyncChatSolo: TTS lookup failed; proceeding without TTS",
zap.String("tenant_id", chat.TenantID),
- zap.Error(ttsErr))
- } else {
- ttsModel = modelModule.NewTTSModel(target.Driver, &target.ModelName, target.APIConfig)
+ zap.Error(err))
+ ttsModel = nil
}
}
}
@@ -2179,54 +2178,31 @@ func tokenizeText(text string) string {
// models reject them at the provider (e.g. Zhipu GLM error 1210:
// messages.content.type only allows 'text').
func (s *ChatPipelineService) getLLMModelConfig(ctx context.Context, chat *entity.Chat) (map[string]interface{}, string, string, string, error) {
- if chat.LLMID == "" {
- // Branch 3: no explicit LLM → tenant default chat model.
- target, err := s.ModelProviderSvc.modelSolver().ResolveDefaultModelConfig(ctx, chat.TenantID, entity.ModelTypeChat)
- if err != nil || target == nil {
- return nil, "", "", "", err
- }
- cfg, modelName, factoryName, baseURL, err := s.buildLLMModelConfig(
- target.Driver, target.ModelName, target.APIConfig, target.MaxTokens, err,
- )
- if err != nil {
- return nil, "", "", "", err
- }
- // Probe the default model's enrolled types so a vision-capable
- // default dispatches as image2text (same rule as the explicit-LLM
- // branches below), and carry the tool capability the resolution
- // already computed.
- cfg["model_type"] = s.resolveChatModelType(ctx, chat.TenantID, modelTargetRef(target))
- cfg["is_tools"] = target.SupportsTools
- return cfg, modelName, factoryName, baseURL, nil
+ access := ModelAccess{TenantID: chat.TenantID}
+ var info *modelModule.ModelInfo
+ var err error
+ if strings.TrimSpace(chat.LLMID) == "" {
+ info, err = s.ModelFactory.ResolveDefaultInfo(ctx, access, entity.ModelTypeChat)
+ } else {
+ info, err = s.ModelFactory.ResolveInfo(ctx, access, entity.ModelTypeChat, chat.LLMID)
}
-
- // Branches 1/2: explicit LLM. Resolve it as a Chat model first so an
- // image2text-only enrollment is rejected. The enrolled type is resolved
- // separately below only to decide whether image attachments are allowed.
- //
- // This mirrors Python, which resolves chat_mdl once in get_models() and then
- // reads chat_mdl.is_tools off it (dialog_service.py rag_agent): one lookup, and
- // the model that runs is by construction the model that was judged.
- target, err := s.ModelProviderSvc.modelSolver().ResolveModelConfig(ctx, chat.TenantID, entity.ModelTypeChat, chat.LLMID)
if err != nil {
return nil, "", "", "", err
}
- cfg, modelName, factoryName, baseURL, err := s.buildLLMModelConfig(
- target.Driver, target.ModelName, target.APIConfig, target.MaxTokens, nil,
- )
+ cfg, modelName, factoryName, baseURL, err := s.buildLLMModelConfig(info)
if err != nil {
return nil, "", "", "", err
}
- cfg["model_type"] = s.resolveChatModelType(ctx, chat.TenantID, chat.LLMID)
- cfg["is_tools"] = target.SupportsTools
+ cfg["model_type"] = "chat"
+ if entity.ModelTypeFromStrings(info.ModelTypes).Has(entity.ModelTypeImage2Text) {
+ cfg["model_type"] = "image2text"
+ }
+ cfg["is_tools"] = info.SupportsTools
return cfg, modelName, factoryName, baseURL, nil
}
-// reasoningNeedsAgenticGraph collapses Python rag_agent's two guards: reasoning on
-// and a tool-calling chat model. The loop exists so the outer model can call the
-// bound rag tool — with a model that never emits a tool_call the whole research
-// budget goes to turns that retrieve nothing, so Python routes those requests to
-// async_chat, the regular RAG branch below.
+// reasoningNeedsAgenticGraph gates the agentic path on reasoning being enabled
+// and the resolved chat model supporting tool calls.
func reasoningNeedsAgenticGraph(chat *entity.Chat, cfg map[string]interface{}, reasoningLevel int) bool {
if chat == nil || reasoningLevel <= 0 {
return false
@@ -2239,19 +2215,10 @@ func reasoningNeedsAgenticGraph(chat *entity.Chat, cfg map[string]interface{}, r
return false
}
-// chatConfigSupportsTools mirrors Python's `getattr(chat_mdl, "is_tools", False)`.
-// The flag rides on the resolved model config — getLLMModelConfig copies it off
-// the resolution (resolvedModel.supportsTools) — so this is a field read, exactly
-// like Python's, with no second lookup that could resolve a different model than
-// the one the request runs on. A missing flag means the model was never resolved,
-// which counts as unsupported, the same as Python's default.
func chatConfigSupportsTools(cfg map[string]interface{}) bool {
if cfg == nil {
return false
}
- // Read the resolved capability as a boolean. ModelSolver accepts the
- // persisted JSON boolean and the historical string representation before it
- // stores the result on ModelTarget.
switch v := cfg["is_tools"].(type) {
case bool:
return v
@@ -2259,56 +2226,30 @@ func chatConfigSupportsTools(cfg map[string]interface{}) bool {
return strings.EqualFold(strings.TrimSpace(v), "true")
case float64:
return v != 0
+ default:
+ return false
}
- return false
-}
-
-// resolveChatModelType renders the enrolled type of llmRef as the config's
-// model_type value. Probe failures are conservative: they yield "chat", which
-// drops image attachments instead of risking a provider-side rejection.
-func (s *ChatPipelineService) resolveChatModelType(ctx context.Context, tenantID, llmRef string) string {
- return chatModelTypeName(s.ModelProviderSvc.modelSolver().ResolveChatModelType(ctx, tenantID, llmRef))
-}
-
-// chatModelTypeName renders a resolved model type as the model_type value
-// downstream image-attachment dispatch compares against.
-func chatModelTypeName(modelType entity.ModelType) string {
- if modelType.Has(entity.ModelTypeImage2Text) {
- return "image2text"
- }
- return "chat"
}
-// buildLLMModelConfig collapses the (driver, modelName, apiConfig,
-// _, err) tuple from a model-provider lookup into the dict-shaped
-// config the rest of async_chat.go consumes. Default "model_type" is
-// "chat"; callers that resolved a different type overwrite the key
-// before returning.
-func (s *ChatPipelineService) buildLLMModelConfig(
- driver modelModule.ModelDriver,
- modelName string,
- apiConfig *modelModule.APIConfig,
- maxTokens int,
- err error,
-) (map[string]interface{}, string, string, string, error) {
- if err != nil {
- return nil, "", "", "", err
+// buildLLMModelConfig returns only the public metadata needed by RAG's token
+// fitting and attachment dispatch. The persisted legacy max_tokens value is
+// the input/context budget; generated output limits are enforced by ChatModel
+// against ModelInfo.MaxOutput.
+func (s *ChatPipelineService) buildLLMModelConfig(info *modelModule.ModelInfo) (map[string]interface{}, string, string, string, error) {
+ if info == nil {
+ return nil, "", "", "", fmt.Errorf("chat model metadata is unavailable")
}
- // Match Python: llm.max_tokens if llm.max_tokens else 8192.
- if maxTokens == 0 {
- maxTokens = 8192
+ contextLength := info.ContextLength
+ if contextLength <= 0 {
+ contextLength = 8192
}
cfg := map[string]interface{}{
"model_type": "chat",
- "llm_name": modelName,
- "max_tokens": maxTokens,
- "llm_factory": driver.Name(),
+ "llm_name": info.Name,
+ "max_tokens": contextLength,
+ "llm_factory": info.ProviderName,
}
- baseURL := ""
- if apiConfig != nil && apiConfig.BaseURL != nil {
- baseURL = *apiConfig.BaseURL
- }
- return cfg, modelName, driver.Name(), baseURL, nil
+ return cfg, info.Name, info.ProviderName, "", nil
}
// getModels resolves all models needed for the RAG pipeline.
@@ -2349,9 +2290,7 @@ func (s *ChatPipelineService) getModels(ctx context.Context, chat *entity.Chat)
}
if kbs[0].EmbdID != "" {
embdTenantID := kbs[0].TenantID
- target, err := s.ModelProviderSvc.modelSolver().ResolveModelConfig(
- ctx, embdTenantID, entity.ModelTypeEmbedding, kbs[0].EmbdID,
- )
+ model, err := s.ModelFactory.NewEmbeddingModel(ctx, ModelAccess{TenantID: embdTenantID}, kbs[0].EmbdID)
if err != nil {
common.Warn("Failed to get embedding model for chat retrieval",
zap.String("embdID", kbs[0].EmbdID),
@@ -2359,42 +2298,30 @@ func (s *ChatPipelineService) getModels(ctx context.Context, chat *entity.Chat)
zap.Error(err))
return nil, nil, nil, nil, nil, fmt.Errorf("failed to get embedding model: %w", err)
}
- embModel = modelModule.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
+ embModel = model
}
}
// Chat model.
- var target *ModelTarget
- var err error
+ access := ModelAccess{TenantID: chat.TenantID}
+ var chatModel *modelModule.ChatModel
if strings.TrimSpace(chat.LLMID) == "" {
- target, err = s.ModelProviderSvc.modelSolver().ResolveDefaultModelConfig(ctx, chat.TenantID, entity.ModelTypeChat)
+ chatModel, _ = s.ModelFactory.NewDefaultChatModel(ctx, access)
} else {
- target, err = s.ModelProviderSvc.modelSolver().ResolveModelConfig(ctx, chat.TenantID, entity.ModelTypeChat, chat.LLMID)
- }
- var chatModel *modelModule.ChatModel
- if err == nil {
- chatModel = modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
+ chatModel, _ = s.ModelFactory.NewChatModel(ctx, access, chat.LLMID)
}
// Rerank model.
var rerankModel *modelModule.RerankModel
if chat.RerankID != "" {
- target, err := s.ModelProviderSvc.modelSolver().ResolveModelConfig(
- ctx, chat.TenantID, entity.ModelTypeRerank, chat.RerankID,
- )
- if err == nil {
- rerankModel = modelModule.NewRerankModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
- }
+ rerankModel, _ = s.ModelFactory.NewRerankModel(ctx, access, chat.RerankID)
}
// TTS model.
var ttsModel *modelModule.TTSModel
if chat.PromptConfig != nil {
if useTTS, _ := chat.PromptConfig["tts"].(bool); useTTS {
- target, err := s.ModelProviderSvc.modelSolver().ResolveDefaultModelConfig(ctx, chat.TenantID, entity.ModelTypeTTS)
- if err == nil {
- ttsModel = modelModule.NewTTSModel(target.Driver, &target.ModelName, target.APIConfig)
- }
+ ttsModel, _ = s.ModelFactory.NewDefaultTTSModel(ctx, access)
}
}
@@ -2942,17 +2869,19 @@ func (s *ChatPipelineService) buildChatDriver(ctx context.Context, chat *entity.
if chatModel != nil {
return chatModel
}
- var target *ModelTarget
- var err error
+ access := ModelAccess{TenantID: chat.TenantID}
if strings.TrimSpace(chat.LLMID) == "" {
- target, err = s.ModelProviderSvc.modelSolver().ResolveDefaultModelConfig(ctx, chat.TenantID, entity.ModelTypeChat)
- } else {
- target, err = s.ModelProviderSvc.modelSolver().ResolveModelConfig(ctx, chat.TenantID, entity.ModelTypeChat, chat.LLMID)
+ model, err := s.ModelFactory.NewDefaultChatModel(ctx, access)
+ if err != nil {
+ return nil
+ }
+ return model
}
+ model, err := s.ModelFactory.NewChatModel(ctx, access, chat.LLMID)
if err != nil {
return nil
}
- return modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
+ return model
}
// HydrateChunkVectors fills the `vector` field on each chunk in `kbinfos`
diff --git a/internal/service/chat_pipeline_test.go b/internal/service/chat_pipeline_test.go
index 3743561fb3..fa2aa2ff88 100644
--- a/internal/service/chat_pipeline_test.go
+++ b/internal/service/chat_pipeline_test.go
@@ -2482,8 +2482,8 @@ func TestResolveModelConfigRejectsImage2TextOnlyModel(t *testing.T) {
setupChatPipelineToolSupportTestDB(t)
svc := NewChatPipelineService()
- _, err := svc.ModelProviderSvc.modelSolver().ResolveModelConfig(
- t.Context(), "tenant-1", entity.ModelTypeChat, "model-image2text-tools",
+ _, err := svc.ModelFactory.resolveConfig(
+ t.Context(), ModelAccess{TenantID: "tenant-1"}, entity.ModelTypeChat, "model-image2text-tools",
)
if err == nil {
t.Fatal("ResolveModelConfig accepted an image2text-only model as chat")
diff --git a/internal/service/chat_session.go b/internal/service/chat_session.go
index 2ff8c0a84a..df79f80c95 100644
--- a/internal/service/chat_session.go
+++ b/internal/service/chat_session.go
@@ -36,6 +36,7 @@ import (
"ragflow/internal/dao"
"ragflow/internal/entity"
+ modelModule "ragflow/internal/entity/models"
)
// Interfaces for testability — satisfied by the concrete DAO/pipeline types.
@@ -59,10 +60,10 @@ type chatPipelineRunner interface {
AsyncChat(ctx context.Context, userID string, chat *entity.Chat, messages []map[string]interface{}, stream bool, kwargs map[string]interface{}) (<-chan AsyncChatResult, error)
}
-type chatModelConfigResolver interface {
- ResolveModelConfig(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string) (*ModelTarget, error)
- ResolveDefaultModelConfig(ctx context.Context, tenantID string, modelType entity.ModelType) (*ModelTarget, error)
- ResolveModelType(ctx context.Context, tenantID, modelRef string) ([]entity.ModelType, error)
+type chatModelInfoResolver interface {
+ ResolveInfo(ctx context.Context, access ModelAccess, modelType entity.ModelType, modelRef string) (*modelModule.ModelInfo, error)
+ ResolveDefaultInfo(ctx context.Context, access ModelAccess, modelType entity.ModelType) (*modelModule.ModelInfo, error)
+ ResolveModelType(ctx context.Context, access ModelAccess, modelRef string) ([]entity.ModelType, error)
}
// chunkFeedbackApplier is the dispatch seam for chunk-level feedback
@@ -87,7 +88,7 @@ type ChatSessionService struct {
chatSessionDAO chatSessionStore
userTenantDAO userTenantStore
pipeline chatPipelineRunner
- modelProviderSvc chatModelConfigResolver
+ modelFactory chatModelInfoResolver
chunkFeedbackApplier chunkFeedbackApplier
docEngine engine.DocEngine
}
@@ -95,11 +96,11 @@ type ChatSessionService struct {
// NewChatSessionService create chat session service
func NewChatSessionService() *ChatSessionService {
return &ChatSessionService{
- chatSessionDAO: dao.NewChatSessionDAO(),
- userTenantDAO: dao.NewUserTenantDAO(),
- pipeline: NewChatPipelineService(),
- modelProviderSvc: NewModelSolver(),
- docEngine: engine.Get(),
+ chatSessionDAO: dao.NewChatSessionDAO(),
+ userTenantDAO: dao.NewUserTenantDAO(),
+ pipeline: NewChatPipelineService(),
+ modelFactory: NewModelFactory(),
+ docEngine: engine.Get(),
}
}
@@ -1855,16 +1856,17 @@ func (s *ChatSessionService) initializeReference(session *entity.ChatSession) []
}
func (s *ChatSessionService) checkTenantLLMAPIKey(ctx context.Context, tenantID, modelName string) (bool, error) {
- resolver := s.modelProviderSvc
- if resolver == nil {
- resolver = NewModelSolver()
+ modelFactory := s.modelFactory
+ if modelFactory == nil {
+ modelFactory = NewModelFactory()
}
var err error
+ access := ModelAccess{TenantID: tenantID}
if modelName == "" {
- _, err = resolver.ResolveDefaultModelConfig(ctx, tenantID, entity.ModelTypeChat)
+ _, err = modelFactory.ResolveDefaultInfo(ctx, access, entity.ModelTypeChat)
} else {
modelType := entity.ModelTypeChat
- if modelTypes, typeErr := resolver.ResolveModelType(ctx, tenantID, modelName); typeErr == nil {
+ if modelTypes, typeErr := modelFactory.ResolveModelType(ctx, access, modelName); typeErr == nil {
for _, resolvedType := range modelTypes {
if resolvedType.Has(entity.ModelTypeImage2Text) {
modelType = entity.ModelTypeImage2Text
@@ -1872,7 +1874,7 @@ func (s *ChatSessionService) checkTenantLLMAPIKey(ctx context.Context, tenantID,
}
}
}
- _, err = resolver.ResolveModelConfig(ctx, tenantID, modelType, modelName)
+ _, err = modelFactory.ResolveInfo(ctx, access, modelType, modelName)
}
if err != nil {
return false, err
diff --git a/internal/service/chat_session_test.go b/internal/service/chat_session_test.go
index cbd31d42a0..384e4f5ec6 100644
--- a/internal/service/chat_session_test.go
+++ b/internal/service/chat_session_test.go
@@ -243,24 +243,24 @@ type fakeChatModelConfigResolver struct {
err error
}
-func (f *fakeChatModelConfigResolver) ResolveModelConfig(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string) (*ModelTarget, error) {
- f.tenantID = tenantID
+func (f *fakeChatModelConfigResolver) ResolveInfo(_ context.Context, access ModelAccess, _ entity.ModelType, modelRef string) (*modelModule.ModelInfo, error) {
+ f.tenantID = access.TenantID
f.llmID = modelRef
if f.err != nil {
return nil, f.err
}
- return &ModelTarget{ModelName: "resolved-model", APIConfig: &modelModule.APIConfig{}, MaxTokens: 8192}, nil
+ return &modelModule.ModelInfo{ID: "resolved-model-id", Name: "resolved-model"}, nil
}
-func (f *fakeChatModelConfigResolver) ResolveDefaultModelConfig(ctx context.Context, tenantID string, modelType entity.ModelType) (*ModelTarget, error) {
- f.tenantID = tenantID
+func (f *fakeChatModelConfigResolver) ResolveDefaultInfo(_ context.Context, access ModelAccess, _ entity.ModelType) (*modelModule.ModelInfo, error) {
+ f.tenantID = access.TenantID
if f.err != nil {
return nil, f.err
}
- return &ModelTarget{ModelName: "resolved-model", APIConfig: &modelModule.APIConfig{}, MaxTokens: 8192}, nil
+ return &modelModule.ModelInfo{ID: "resolved-model-id", Name: "resolved-model"}, nil
}
-func (f *fakeChatModelConfigResolver) ResolveModelType(ctx context.Context, tenantID, modelRef string) ([]entity.ModelType, error) {
+func (f *fakeChatModelConfigResolver) ResolveModelType(ctx context.Context, access ModelAccess, modelRef string) ([]entity.ModelType, error) {
return []entity.ModelType{entity.ModelTypeChat}, nil
}
@@ -1227,10 +1227,10 @@ func TestChatCompletionsModelIDOverrideUsesModelResolver(t *testing.T) {
modelID := "3d2d824e7e5d11f1a845455b140cef90"
svc := &ChatSessionService{
- chatSessionDAO: store,
- userTenantDAO: &fakeTenantStore{tenantIDs: []string{"tenant-owner"}},
- pipeline: pipeline,
- modelProviderSvc: resolver,
+ chatSessionDAO: store,
+ userTenantDAO: &fakeTenantStore{tenantIDs: []string{"tenant-owner"}},
+ pipeline: pipeline,
+ modelFactory: resolver,
}
_, err := svc.ChatCompletions(
diff --git a/internal/service/chunk/chunk.go b/internal/service/chunk/chunk.go
index 2b832f31e6..44837510e4 100644
--- a/internal/service/chunk/chunk.go
+++ b/internal/service/chunk/chunk.go
@@ -164,7 +164,7 @@ func (s *ChunkService) RetrievalTest(ctx context.Context, req *service.Retrieval
if len(req.Datasets) == 0 {
return nil, fmt.Errorf("dataset_ids is required")
}
- modelSolver := service.NewModelSolver()
+ modelFactory := service.NewModelFactory()
tenants, err := s.userTenantDAO.GetByUserID(ctx, dao.DB, userID)
if err != nil {
@@ -255,40 +255,26 @@ func (s *ChunkService) RetrievalTest(ctx context.Context, req *service.Retrieval
}
// If meta_data_filter method is auto/semi_auto, get chat model
+ var getErr error
if filter != nil {
method, _ := filter["method"].(string)
if method == "auto" || method == "semi_auto" {
+ access := service.ModelAccess{TenantID: tenantIDs[0]}
if chatID != "" {
- // Use chat_id from search_config (it's actually the model name)
- target, getErr := modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeChat, chatID)
+ chatModelForFilter, getErr = modelFactory.NewChatModel(ctx, access, chatID)
if getErr != nil {
common.Warn("Failed to get chat model from search_config chat_id, using tenant default", zap.String("chatID", chatID), zap.Error(getErr))
} else {
- chatModelForFilter = models.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
common.Info("Fetched chat model (from search_config) for metadata filter",
zap.String("chatID", chatID),
zap.String("tenantID", tenantIDs[0]))
}
-
}
- // If no chatID from search_config, or chatModel not found, use tenant default
if chatModelForFilter == nil {
- tenantSvc := service.NewTenantService()
- modelName, err := tenantSvc.GetDefaultModelName(ctx, tenantIDs[0], entity.ModelTypeChat)
- if err != nil || modelName == "" {
- common.Warn("Failed to get tenant default chat model name for meta_data_filter", zap.Error(err))
- } else {
- target, getErr := modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeChat, modelName)
- if getErr != nil {
- common.Warn("Failed to get chat model for meta_data_filter", zap.Error(getErr))
- } else {
- chatModelForFilter = models.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
- common.Info("Fetched chat model (tenant default) for metadata filter",
- zap.String("tenantID", tenantIDs[0]),
- zap.String("modelName", modelName))
- }
-
+ chatModelForFilter, getErr = modelFactory.NewDefaultChatModel(ctx, access)
+ if getErr != nil {
+ common.Warn("Failed to get tenant default chat model for meta_data_filter", zap.Error(getErr))
}
}
}
@@ -324,11 +310,10 @@ func (s *ChunkService) RetrievalTest(ctx context.Context, req *service.Retrieval
if err != nil || llmModelName == "" {
common.Warn("Failed to get default chat model name for LLM transformations", zap.Error(err))
} else {
- target, getErr := modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeChat, llmModelName)
- if getErr != nil {
- common.Warn("Failed to get chat model for LLM transformations", zap.Error(getErr))
+ chatModel, err = modelFactory.NewChatModel(ctx, service.ModelAccess{TenantID: tenantIDs[0]}, llmModelName)
+ if err != nil {
+ common.Warn("Failed to get chat model for LLM transformations", zap.Error(err))
} else {
- chatModel = models.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
common.Info("Fetched chat model (tenant default) for cross_languages/keyword_extraction",
zap.String("tenantID", tenantIDs[0]),
zap.String("modelName", llmModelName))
@@ -370,52 +355,50 @@ func (s *ChunkService) RetrievalTest(ctx context.Context, req *service.Retrieval
labels := metadataSvc.LabelQuestion(ctx, modifiedQuestion, kbRecords)
// Determine embedding model.
+ access := service.ModelAccess{TenantID: tenantIDs[0]}
var embeddingModel *models.EmbeddingModel
var embdID string
- var target *service.ModelTarget
- var getErr error
if kbRecords[0].TenantEmbdID != nil && *kbRecords[0].TenantEmbdID != "" {
- target, getErr = modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeEmbedding, *kbRecords[0].TenantEmbdID)
+ embeddingModel, getErr = modelFactory.NewEmbeddingModel(ctx, access, *kbRecords[0].TenantEmbdID)
if getErr != nil {
return nil, fmt.Errorf("failed to get embedding model by tenant_embd_id: %w", getErr)
}
} else if kbRecords[0].EmbdID != "" {
embdID = kbRecords[0].EmbdID
- target, getErr = modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeEmbedding, embdID)
+ embeddingModel, getErr = modelFactory.NewEmbeddingModel(ctx, access, embdID)
if getErr != nil {
return nil, fmt.Errorf("failed to get embedding model by embd_id: %w", getErr)
}
} else {
- target, getErr = modelSolver.ResolveDefaultModelConfig(ctx, tenantIDs[0], entity.ModelTypeEmbedding)
+ embeddingModel, getErr = modelFactory.NewDefaultEmbeddingModel(ctx, access)
if getErr != nil {
return nil, fmt.Errorf("failed to get tenant default embedding model: %w", getErr)
}
}
- embeddingModel = models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
if embeddingModel == nil {
return nil, fmt.Errorf("no embedding model found for tenant %s", tenantIDs[0])
}
-
+ modelName := ""
+ if info := embeddingModel.Info(); info != nil {
+ modelName = info.Name
+ }
common.Info("Fetched embedding model for retrieval",
zap.String("tenantID", tenantIDs[0]),
- zap.String("modelName", target.ModelName))
+ zap.String("modelName", modelName))
// Get rerank model if RerankID is specified
var rerankModel *models.RerankModel
if tenantRerankID != nil && *tenantRerankID != "" {
- target, getErr := modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeRerank, *tenantRerankID)
+ rerankModel, getErr = modelFactory.NewRerankModel(ctx, access, *tenantRerankID)
if getErr != nil {
return nil, fmt.Errorf("failed to get rerank model by tenant_rerank_id: %w", getErr)
}
- rerankModel = models.NewRerankModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
} else if rerankID != nil && *rerankID != "" {
- rerankCompositeName := *rerankID
- target, getErr := modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeRerank, rerankCompositeName)
+ rerankModel, getErr = modelFactory.NewRerankModel(ctx, access, *rerankID)
if getErr != nil {
return nil, fmt.Errorf("failed to get rerank model by rerank_id: %w", getErr)
}
- rerankModel = models.NewRerankModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
}
retrievalReq := &nlp.RetrievalRequest{
@@ -1683,11 +1666,11 @@ func (s *ChunkService) getEmbeddingModel(ctx context.Context, tenantID, embdID s
if s.getEmbeddingModelFunc != nil {
return s.getEmbeddingModelFunc(tenantID, embdID)
}
- target, err := service.NewModelSolver().ResolveModelConfig(ctx, tenantID, entity.ModelTypeEmbedding, embdID)
+ embeddingModel, err := service.NewModelFactory().NewEmbeddingModel(ctx, service.ModelAccess{TenantID: tenantID}, embdID)
if err != nil {
return nil, err
}
- return models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens), nil
+ return embeddingModel, nil
}
func (s *ChunkService) incrementChunkStats(docID, kbID string, tokenNum, chunkNum int64, duration float64) error {
diff --git a/internal/service/dataset/crud.go b/internal/service/dataset/crud.go
index 9e85b583c5..60551f9e00 100644
--- a/internal/service/dataset/crud.go
+++ b/internal/service/dataset/crud.go
@@ -175,9 +175,9 @@ func (d *DatasetService) CreateDataset(ctx context.Context, req *service.CreateD
tenantEmbdID = ""
}
if embdID != "" && tenantEmbdID == "" {
- target, err := service.NewModelSolver().ResolveModelConfig(ctx, tenantID, entity.ModelTypeEmbedding, embdID)
+ target, err := service.NewModelFactory().ResolveInfo(ctx, service.ModelAccess{TenantID: tenantID}, entity.ModelTypeEmbedding, embdID)
if err == nil {
- tenantEmbdID = target.ModelID
+ tenantEmbdID = target.ID
} else {
return nil, common.CodeDataError, err
}
diff --git a/internal/service/dataset/embedding.go b/internal/service/dataset/embedding.go
index 3ffac7502b..396067863e 100644
--- a/internal/service/dataset/embedding.go
+++ b/internal/service/dataset/embedding.go
@@ -11,7 +11,6 @@ import (
"ragflow/internal/common"
"ragflow/internal/dao"
"ragflow/internal/entity"
- "ragflow/internal/entity/models"
"ragflow/internal/service"
enginetypes "ragflow/internal/engine/types"
@@ -60,11 +59,10 @@ func (d *DatasetService) CheckEmbedding(ctx context.Context, userID, datasetID s
return nil, common.CodeServerError, errors.New("doc engine not initialized")
}
- target, err := service.NewModelSolver().ResolveModelConfig(ctx, kb.TenantID, entity.ModelTypeEmbedding, embeddingID)
+ embeddingModel, err := service.NewModelFactory().NewEmbeddingModel(ctx, service.ModelAccess{TenantID: kb.TenantID}, embeddingID)
if err != nil {
return nil, common.CodeDataError, err
}
- embeddingModel := models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
checkNum := defaultEmbeddingCheckNum
if req.CheckNum != nil {
@@ -281,7 +279,7 @@ func (d *DatasetService) sampleRandomChunksWithVectors(ctx context.Context, tena
}
func (d *DatasetService) verifyEmbeddingAvailability(ctx context.Context, embdID string, tenantID string) (bool, string) {
- _, err := service.NewModelSolver().ResolveModelConfig(ctx, tenantID, entity.ModelTypeEmbedding, embdID)
+ _, err := service.NewModelFactory().ResolveInfo(ctx, service.ModelAccess{TenantID: tenantID}, entity.ModelTypeEmbedding, embdID)
if err != nil {
return false, err.Error()
}
diff --git a/internal/service/dataset/search.go b/internal/service/dataset/search.go
index 5d7e6fcfd5..255ce32ecc 100644
--- a/internal/service/dataset/search.go
+++ b/internal/service/dataset/search.go
@@ -105,7 +105,7 @@ func (d *DatasetService) SearchDatasets(ctx context.Context, req *service.Search
documentIDs = req.DocIDs
}
- modelSolver := service.NewModelSolver()
+ modelFactory := service.NewModelFactory()
// Access check for all datasets
var tenantIDs []string
@@ -208,24 +208,22 @@ func (d *DatasetService) SearchDatasets(ctx context.Context, req *service.Search
// If meta_data_filter method is auto/semi_auto, get chat model
var chatModelForFilter *modelModule.ChatModel
+ var err error
if metadataFilter != nil {
method, _ := metadataFilter["method"].(string)
if method == "auto" || method == "semi_auto" {
+ access := service.ModelAccess{TenantID: tenantIDs[0]}
if chatID != "" {
- target, err := modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeChat, chatID)
+ chatModelForFilter, err = modelFactory.NewChatModel(ctx, access, chatID)
if err != nil {
common.Warn("Failed to get chat model config from search_config chat_id, using tenant default", zap.String("chatID", chatID), zap.Error(err))
- } else {
- chatModelForFilter = modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
}
}
if chatModelForFilter == nil {
- target, err := modelSolver.ResolveDefaultModelConfig(ctx, tenantIDs[0], entity.ModelTypeChat)
+ chatModelForFilter, err = modelFactory.NewDefaultChatModel(ctx, access)
if err != nil {
common.Warn("Failed to get tenant default chat model for meta_data_filter", zap.Error(err))
- } else {
- chatModelForFilter = modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
}
}
}
@@ -256,11 +254,10 @@ func (d *DatasetService) SearchDatasets(ctx context.Context, req *service.Search
}
}
if keyword {
- target, err := modelSolver.ResolveDefaultModelConfig(ctx, tenantIDs[0], entity.ModelTypeChat)
+ chatModel, err := modelFactory.NewDefaultChatModel(ctx, service.ModelAccess{TenantID: tenantIDs[0]})
if err != nil {
common.Warn("Failed to get default chat model for LLM transformations", zap.Error(err))
} else {
- chatModel := modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
extractedKeywords, err := service.KeywordExtraction(ctx, chatModel, modifiedQuestion, 3)
if err != nil {
common.Warn("Failed to extract keywords from question", zap.Error(err))
@@ -277,21 +274,19 @@ func (d *DatasetService) SearchDatasets(ctx context.Context, req *service.Search
// Determine embedding model
var embeddingModel *modelModule.EmbeddingModel
if kbRecords[0].EmbdID != "" {
- target, embErr := modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeEmbedding, kbRecords[0].EmbdID)
- if embErr != nil {
- return nil, fmt.Errorf("failed to get embedding model by embd_id: %w", embErr)
+ embeddingModel, err = modelFactory.NewEmbeddingModel(ctx, service.ModelAccess{TenantID: tenantIDs[0]}, kbRecords[0].EmbdID)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get embedding model by embd_id: %w", err)
}
- embeddingModel = modelModule.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
}
// Get rerank model if rerankID is specified
var rerankModel *modelModule.RerankModel
if rerankID != "" {
- target, rErr := modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeRerank, rerankID)
- if rErr != nil {
- return nil, fmt.Errorf("failed to get rerank model by rerank_id: %w", rErr)
+ rerankModel, err = modelFactory.NewRerankModel(ctx, service.ModelAccess{TenantID: tenantIDs[0]}, rerankID)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get rerank model by rerank_id: %w", err)
}
- rerankModel = modelModule.NewRerankModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
}
retrievalReq := &nlp.RetrievalRequest{
diff --git a/internal/service/dataset/update.go b/internal/service/dataset/update.go
index effe09485b..2181dca98c 100644
--- a/internal/service/dataset/update.go
+++ b/internal/service/dataset/update.go
@@ -228,9 +228,9 @@ func (d *DatasetService) UpdateDataset(ctx context.Context, datasetID, tenantID
return errors.New(message)
}
if effectiveEmbdID != "" && tenantEmbdID == "" {
- target, err := service.NewModelSolver().ResolveModelConfig(ctx, tenantID, entity.ModelTypeEmbedding, effectiveEmbdID)
+ target, err := service.NewModelFactory().ResolveInfo(ctx, service.ModelAccess{TenantID: tenantID}, entity.ModelTypeEmbedding, effectiveEmbdID)
if err == nil {
- tenantEmbdID = target.ModelID
+ tenantEmbdID = target.ID
}
}
updates["embd_id"] = effectiveEmbdID
diff --git a/internal/service/generator.go b/internal/service/generator.go
index 5eee580b7f..4480d56d1c 100644
--- a/internal/service/generator.go
+++ b/internal/service/generator.go
@@ -26,7 +26,6 @@ import (
"time"
"ragflow/internal/common"
- "ragflow/internal/entity"
modelModule "ragflow/internal/entity/models"
"go.uber.org/zap"
@@ -122,33 +121,21 @@ func CrossLanguages(ctx context.Context, tenantID string, llmID string, query st
zap.String("llmID", llmID),
zap.Strings("languages", languages))
- modelSolver := NewModelSolver()
+ modelFactory := NewModelFactory()
var chatModel *modelModule.ChatModel
var err error
+ access := ModelAccess{TenantID: tenantID}
if llmID != "" {
- modelTypes, err := modelSolver.ResolveModelType(ctx, tenantID, llmID)
- if err != nil {
- return query, fmt.Errorf("failed to get model type: %w", err)
- }
- resolvedType := entity.ModelTypeChat
- for _, mt := range modelTypes {
- if mt == entity.ModelTypeImage2Text {
- resolvedType = entity.ModelTypeImage2Text
- break
- }
- }
- target, err := modelSolver.ResolveModelConfig(ctx, tenantID, resolvedType, llmID)
+ chatModel, err = modelFactory.NewChatModel(ctx, access, llmID)
if err != nil {
return query, fmt.Errorf("failed to get chat model: %w", err)
}
- chatModel = modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
} else {
- target, err := modelSolver.ResolveDefaultModelConfig(ctx, tenantID, entity.ModelTypeChat)
+ chatModel, err = modelFactory.NewDefaultChatModel(ctx, access)
if err != nil {
return query, fmt.Errorf("failed to get default chat model: %w", err)
}
- chatModel = modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
}
if chatModel == nil {
return query, fmt.Errorf("failed to get chat model: nil chat model")
diff --git a/internal/service/memory.go b/internal/service/memory.go
index b6a0fb6570..cca1f1955b 100644
--- a/internal/service/memory.go
+++ b/internal/service/memory.go
@@ -464,24 +464,24 @@ func (s *MemoryService) CreateMemory(ctx context.Context, tenantID string, req *
// Resolve tenant model IDs, mirroring Python's ensure_tenant_model_ids_for_params.
// Resolution failure is non-fatal (e.g. Builtin models that have no
// tenant_model row) — we leave the tenant_*_id fields nil and proceed.
- modelSolver := NewModelSolver()
+ modelFactory := NewModelFactory()
if req.LLMID != "" && req.TenantLLMID == nil {
- target, err := modelSolver.ResolveModelConfig(ctx, tenantID, entity.ModelTypeChat, req.LLMID)
+ info, err := modelFactory.ResolveInfo(ctx, ModelAccess{TenantID: tenantID}, entity.ModelTypeChat, req.LLMID)
if err != nil {
common.Warn("CreateMemory: failed to resolve tenant LLM id",
zap.String("tenant_id", tenantID), zap.String("llm_id", req.LLMID), zap.Error(err))
- } else if target != nil && target.ModelID != "" {
- tenantLLMID := target.ModelID
+ } else if info != nil && info.ID != "" {
+ tenantLLMID := info.ID
req.TenantLLMID = &tenantLLMID
}
}
if req.EmbdID != "" && req.TenantEmbdID == nil {
- target, err := modelSolver.ResolveModelConfig(ctx, tenantID, entity.ModelTypeEmbedding, req.EmbdID)
+ info, err := modelFactory.ResolveInfo(ctx, ModelAccess{TenantID: tenantID}, entity.ModelTypeEmbedding, req.EmbdID)
if err != nil {
common.Warn("CreateMemory: failed to resolve tenant embedding id",
zap.String("tenant_id", tenantID), zap.String("embd_id", req.EmbdID), zap.Error(err))
- } else if target != nil && target.ModelID != "" {
- tenantEmbdID := target.ModelID
+ } else if info != nil && info.ID != "" {
+ tenantEmbdID := info.ID
req.TenantEmbdID = &tenantEmbdID
}
}
@@ -618,16 +618,16 @@ func (s *MemoryService) UpdateMemory(ctx context.Context, tenantID string, memor
// tenant_model row IDs so downstream code that depends on
// tenant_llm_id / tenant_embd_id stays consistent after an update.
// Resolution failure is non-fatal (e.g. Builtin models).
- modelSolver := NewModelSolver()
+ modelFactory := NewModelFactory()
if req.LLMID != nil {
updateDict["llm_id"] = *req.LLMID
if req.TenantLLMID == nil && *req.LLMID != "" {
- target, err := modelSolver.ResolveModelConfig(ctx, ownerTenantID, entity.ModelTypeChat, *req.LLMID)
+ info, err := modelFactory.ResolveInfo(ctx, ModelAccess{TenantID: ownerTenantID}, entity.ModelTypeChat, *req.LLMID)
if err != nil {
common.Warn("UpdateMemory: failed to resolve tenant LLM id",
zap.String("tenant_id", ownerTenantID), zap.String("llm_id", *req.LLMID), zap.Error(err))
- } else if target != nil && target.ModelID != "" {
- updateDict["tenant_llm_id"] = target.ModelID
+ } else if info != nil && info.ID != "" {
+ updateDict["tenant_llm_id"] = info.ID
}
}
}
@@ -635,12 +635,12 @@ func (s *MemoryService) UpdateMemory(ctx context.Context, tenantID string, memor
if req.EmbdID != nil {
updateDict["embd_id"] = *req.EmbdID
if req.TenantEmbdID == nil && *req.EmbdID != "" {
- target, err := modelSolver.ResolveModelConfig(ctx, ownerTenantID, entity.ModelTypeEmbedding, *req.EmbdID)
+ info, err := modelFactory.ResolveInfo(ctx, ModelAccess{TenantID: ownerTenantID}, entity.ModelTypeEmbedding, *req.EmbdID)
if err != nil {
common.Warn("UpdateMemory: failed to resolve tenant embedding id",
zap.String("tenant_id", ownerTenantID), zap.String("embd_id", *req.EmbdID), zap.Error(err))
- } else if target != nil && target.ModelID != "" {
- updateDict["tenant_embd_id"] = target.ModelID
+ } else if info != nil && info.ID != "" {
+ updateDict["tenant_embd_id"] = info.ID
}
}
}
@@ -1494,11 +1494,10 @@ func memoryFusionWeights(keywordsSimilarityWeight float64) string {
}
func (s *MemoryService) memoryMessageDenseExpr(ctx context.Context, question string, memory *entity.Memory, topN int, similarityThreshold float64) (*enginetypes.MatchDenseExpr, error) {
- target, err := NewModelSolver().ResolveModelConfig(ctx, memory.TenantID, entity.ModelTypeEmbedding, memory.EmbdID)
+ embeddingModel, err := NewModelFactory().NewEmbeddingModel(ctx, ModelAccess{TenantID: memory.TenantID}, memory.EmbdID)
if err != nil {
return nil, err
}
- embeddingModel := models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
// Query: true — the memory store is searched by question (Python
// memory/services/query.py uses emb_mdl.encode_queries).
embeddings, err := embeddingModel.Embed(ctx, models.EmbedRequest{Texts: []string{question}, Query: true}, &models.EmbeddingConfig{Dimension: 0}, nil)
diff --git a/internal/service/memory_extractor.go b/internal/service/memory_extractor.go
index 8253e644a0..d3ba7bdd04 100644
--- a/internal/service/memory_extractor.go
+++ b/internal/service/memory_extractor.go
@@ -490,17 +490,15 @@ func (s *MemoryMessageService) extractByLLM(ctx context.Context, mem *CreateMemo
messages = append(messages, models.Message{Role: "user", Content: PromptAssembler{}.AssembleUserPrompt(conversation, now, now)})
}
- // Python prefers tenant_llm_id and falls back to llm_id;
- // ResolveModelConfig accepts both tenant-model ids and model names.
+ // Python prefers tenant_llm_id and falls back to llm_id.
llmRef := mem.LLMID
if mem.TenantLLMID != nil && *mem.TenantLLMID != "" {
llmRef = *mem.TenantLLMID
}
- target, err := NewModelSolver().ResolveModelConfig(ctx, mem.TenantID, entity.ModelTypeChat, llmRef)
+ chatModel, err := NewModelFactory().NewChatModel(ctx, ModelAccess{TenantID: mem.TenantID}, llmRef)
if err != nil {
return nil, fmt.Errorf("resolve chat model: %w", classifyMemoryTaskDependencyError(err))
}
- chatModel := models.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
_ = s.updateTaskProgress(ctx, taskID, 0.15, "Prepared prompts and LLM.")
temperature := mem.Temperature
diff --git a/internal/service/memory_message_service.go b/internal/service/memory_message_service.go
index 2d034fc36e..b7bf5d455c 100644
--- a/internal/service/memory_message_service.go
+++ b/internal/service/memory_message_service.go
@@ -324,11 +324,10 @@ func (s *MemoryMessageService) embedAndSaveMessages(ctx context.Context, mem *Cr
for i, message := range messages {
contents[i], _ = message["content"].(string)
}
- target, err := NewModelSolver().ResolveModelConfig(ctx, mem.TenantID, entity.ModelTypeEmbedding, mem.EmbdID)
+ embeddingModel, err := NewModelFactory().NewEmbeddingModel(ctx, ModelAccess{TenantID: mem.TenantID}, mem.EmbdID)
if err != nil {
return err
}
- embeddingModel := models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
// Embed inside the model's window: memory contents are caller-supplied and
// unbounded, and the provider answers 400/20015 instead of truncating them.
embeddings, err := embeddingModel.Embed(ctx, models.EmbedRequest{Texts: contents}, &models.EmbeddingConfig{Dimension: 0}, nil)
diff --git a/internal/service/model_call.go b/internal/service/model_call.go
index 080c44e848..c3e0c960ff 100644
--- a/internal/service/model_call.go
+++ b/internal/service/model_call.go
@@ -26,7 +26,6 @@ import (
"ragflow/internal/common"
"ragflow/internal/dao"
- "ragflow/internal/entity"
modelModule "ragflow/internal/entity/models"
)
@@ -34,51 +33,48 @@ import (
// It accepts only the caller identity, model reference, request data, and
// runtime configuration. Provider, instance, API configuration, and driver
// resolution are handled internally.
-//
-// The legacy methods on ModelProviderService remain untouched so this new API
-// can be introduced without changing existing callers.
type ModelCallService struct {
providerService *ModelProviderService
- modelSolver *ModelSolver
+ modelFactory *ModelFactory
}
// NewModelCallService creates a model-call service with the standard model
// provider and model resolver.
func NewModelCallService() *ModelCallService {
- return NewModelCallServiceWithProviderService(NewModelProviderService())
+ return NewModelCallServiceWithProviderService(NewModelProviderService(), NewModelFactory())
}
// NewModelCallServiceWithProviderService creates a model-call service using
-// an existing provider service and its DAO configuration.
-func NewModelCallServiceWithProviderService(providerService *ModelProviderService) *ModelCallService {
+// an existing provider service for provider metadata and balance operations.
+func NewModelCallServiceWithProviderService(providerService *ModelProviderService, modelFactory *ModelFactory) *ModelCallService {
if providerService == nil {
providerService = NewModelProviderService()
}
+ if modelFactory == nil {
+ modelFactory = NewModelFactory()
+ }
return &ModelCallService{
providerService: providerService,
- modelSolver: &ModelSolver{service: providerService},
+ modelFactory: modelFactory,
}
}
// ChatToModelWithMessages sends messages to the model selected by modelRef.
func (s *ModelCallService) ChatToModelWithMessages(ctx context.Context, modelRef, userID string, messages []modelModule.Message, config *modelModule.ChatConfig, usage *common.ModelUsage) (*modelModule.ChatResponse, common.ErrorCode, error) {
- target, tenantID, code, err := s.resolveTarget(ctx, modelRef, userID, entity.ModelTypeChat)
+ access, tenantID, code, err := s.modelAccessForUser(ctx, userID)
if err != nil {
return nil, code, err
}
+ chatModel, err := s.modelFactory.NewChatModel(ctx, access, modelRef)
+ if err != nil {
+ return nil, common.CodeNotFound, err
+ }
if config == nil {
config = &modelModule.ChatConfig{}
}
- if target.ModelInfo != nil {
- config.ModelClass = target.ModelInfo.Class
- if config.Thinking == nil && target.ModelInfo.Thinking != nil {
- thinking := target.ModelInfo.Thinking.DefaultValue
- config.Thinking = &thinking
- }
- }
- populateModelUsage(usage, target, tenantID, userID)
+ info := chatModel.Info()
+ populateModelUsage(usage, info, chatModel.APIConfig, tenantID, userID)
- chatModel := modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
response, err := chatModel.ChatWithMessages(ctx, messages, config, usage)
if err != nil {
return nil, common.CodeServerError, err
@@ -88,47 +84,45 @@ func (s *ModelCallService) ChatToModelWithMessages(ctx context.Context, modelRef
}
return response, common.CodeSuccess, nil
}
-
-// ChatToModelStreamWithSender streams the response from the model selected by
-// modelRef through sender.
func (s *ModelCallService) ChatToModelStreamWithSender(ctx context.Context, modelRef, userID string, messages []modelModule.Message, config *modelModule.ChatConfig, usage *common.ModelUsage, sender func(*string, *string) error) (common.ErrorCode, error) {
- target, tenantID, code, err := s.resolveTarget(ctx, modelRef, userID, entity.ModelTypeChat)
+ access, tenantID, code, err := s.modelAccessForUser(ctx, userID)
if err != nil {
return code, err
}
+ chatModel, err := s.modelFactory.NewChatModel(ctx, access, modelRef)
+ if err != nil {
+ return common.CodeNotFound, err
+ }
if config == nil {
config = &modelModule.ChatConfig{}
}
- if target.ModelInfo != nil {
- config.ModelClass = target.ModelInfo.Class
- if config.Thinking == nil && target.ModelInfo.Thinking != nil {
- thinking := target.ModelInfo.Thinking.DefaultValue
- config.Thinking = &thinking
- }
- }
- populateModelUsage(usage, target, tenantID, userID)
+ populateModelUsage(usage, chatModel.Info(), chatModel.APIConfig, tenantID, userID)
- chatModel := modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
if err := chatModel.ChatStreamlyWithSender(ctx, messages, config, usage, sender); err != nil {
return common.CodeServerError, err
}
return common.CodeSuccess, nil
}
-
-// EmbedText embeds texts with the model selected by modelRef.
func (s *ModelCallService) EmbedText(ctx context.Context, modelRef, userID string, texts []string, config *modelModule.EmbeddingConfig) ([]modelModule.EmbeddingData, common.ErrorCode, error) {
- target, _, code, err := s.resolveTarget(ctx, modelRef, userID, entity.ModelTypeEmbedding)
+ access, _, code, err := s.modelAccessForUser(ctx, userID)
if err != nil {
return nil, code, err
}
+ embeddingModel, err := s.modelFactory.NewEmbeddingModel(ctx, access, modelRef)
+ if err != nil {
+ return nil, common.CodeNotFound, err
+ }
if config == nil {
config = &modelModule.EmbeddingConfig{}
}
- if err := validateEmbeddingModel(target.ModelInfo, config.Dimension, len(texts)); err != nil {
+ info := embeddingModel.Info()
+ if info == nil || info.Catalog == nil {
+ return nil, common.CodeBadRequest, errors.New("embedding model metadata is unavailable")
+ }
+ if err := validateEmbeddingModel(info.Catalog, config.Dimension, len(texts)); err != nil {
return nil, common.CodeBadRequest, err
}
- embeddingModel := modelModule.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
embeddings, err := embeddingModel.Embed(ctx, modelModule.EmbedRequest{Texts: texts}, config, nil)
if err != nil {
return nil, common.CodeServerError, err
@@ -138,20 +132,20 @@ func (s *ModelCallService) EmbedText(ctx context.Context, modelRef, userID strin
}
return embeddings, common.CodeSuccess, nil
}
-
-// RerankDocument reranks documents with the model selected by modelRef.
func (s *ModelCallService) RerankDocument(ctx context.Context, modelRef, userID, query string, documents []string, config *modelModule.RerankConfig) (*modelModule.RerankResponse, common.ErrorCode, error) {
- target, _, code, err := s.resolveTarget(ctx, modelRef, userID, entity.ModelTypeRerank)
+ access, _, code, err := s.modelAccessForUser(ctx, userID)
if err != nil {
return nil, code, err
}
+ rerankModel, err := s.modelFactory.NewRerankModel(ctx, access, modelRef)
+ if err != nil {
+ return nil, common.CodeNotFound, err
+ }
if config == nil {
config = &modelModule.RerankConfig{}
}
- modelName := target.ModelName
- rerankModel := modelModule.NewRerankModel(target.Driver, &modelName, target.APIConfig, target.MaxTokens)
- response, err := rerankModel.Rerank(ctx, modelModule.RerankRequest{Query: query, Documents: documents}, target.APIConfig, config, nil)
+ response, err := rerankModel.Rerank(ctx, modelModule.RerankRequest{Query: query, Documents: documents}, config, nil)
if err != nil {
return nil, common.CodeServerError, err
}
@@ -160,20 +154,19 @@ func (s *ModelCallService) RerankDocument(ctx context.Context, modelRef, userID,
}
return response, common.CodeSuccess, nil
}
-
-// TranscribeAudio converts audioFile to text with the model selected by
-// modelRef.
func (s *ModelCallService) TranscribeAudio(ctx context.Context, modelRef, userID string, audioFile *string, config *modelModule.ASRConfig) (*modelModule.ASRResponse, common.ErrorCode, error) {
- target, _, code, err := s.resolveTarget(ctx, modelRef, userID, entity.ModelTypeSpeech2Text)
+ access, _, code, err := s.modelAccessForUser(ctx, userID)
if err != nil {
return nil, code, err
}
+ asrModel, err := s.modelFactory.NewASRModel(ctx, access, modelRef)
+ if err != nil {
+ return nil, common.CodeNotFound, err
+ }
if config == nil {
config = &modelModule.ASRConfig{}
}
- modelName := target.ModelName
- asrModel := modelModule.NewASRModel(target.Driver, &modelName, target.APIConfig)
response, err := asrModel.Transcribe(ctx, audioFile, config, nil)
if err != nil {
return nil, common.CodeServerError, err
@@ -183,57 +176,53 @@ func (s *ModelCallService) TranscribeAudio(ctx context.Context, modelRef, userID
}
return response, common.CodeSuccess, nil
}
-
-// TranscribeAudioStream streams the transcription from the model selected by
-// modelRef through sender.
func (s *ModelCallService) TranscribeAudioStream(ctx context.Context, modelRef, userID string, audioFile *string, config *modelModule.ASRConfig, sender func(*string, *string) error) (common.ErrorCode, error) {
- target, _, code, err := s.resolveTarget(ctx, modelRef, userID, entity.ModelTypeSpeech2Text)
+ access, _, code, err := s.modelAccessForUser(ctx, userID)
if err != nil {
return code, err
}
+ asrModel, err := s.modelFactory.NewASRModel(ctx, access, modelRef)
+ if err != nil {
+ return common.CodeNotFound, err
+ }
if config == nil {
config = &modelModule.ASRConfig{}
}
-
- modelName := target.ModelName
- asrModel := modelModule.NewASRModel(target.Driver, &modelName, target.APIConfig)
if err := asrModel.TranscribeWithSender(ctx, audioFile, config, nil, sender); err != nil {
return common.CodeServerError, err
}
return common.CodeSuccess, nil
}
-
-// AudioSpeech converts audioContent to speech with the model selected by
-// modelRef.
func (s *ModelCallService) AudioSpeech(ctx context.Context, modelRef, userID string, audioContent *string, config *modelModule.TTSConfig) (*modelModule.TTSResponse, common.ErrorCode, error) {
- var target *ModelTarget
- var code common.ErrorCode
- var err error
- if strings.TrimSpace(modelRef) == "" {
- tenantID, tenantErr := s.ownerTenantID(ctx, userID)
- if tenantErr != nil {
- // Audio synthesis supplies the tenant ID directly, while HTTP
- // model calls supply a user ID. Fall back to the former when no
- // owner tenant can be resolved from the latter.
- tenantID = userID
- }
- code = common.CodeNotFound
- target, err = s.modelSolver.ResolveDefaultModelConfig(ctx, tenantID, entity.ModelTypeTTS)
- if err == nil {
- code = common.CodeSuccess
+ if s == nil || s.modelFactory == nil {
+ return nil, common.CodeServerError, errors.New("model call service is not initialized")
+ }
+ tenantID, tenantErr := s.ownerTenantID(ctx, userID)
+ access := ModelAccess{UserID: userID, TenantID: tenantID}
+ if tenantErr != nil {
+ if strings.TrimSpace(modelRef) != "" {
+ return nil, common.CodeNotFound, tenantErr
}
+ // Some internal audio dispatchers pass a tenant ID in userID.
+ access = ModelAccess{TenantID: userID}
+ tenantID = userID
+ }
+ var (
+ ttsModel *modelModule.TTSModel
+ err error
+ )
+ if strings.TrimSpace(modelRef) == "" {
+ ttsModel, err = s.modelFactory.NewDefaultTTSModel(ctx, access)
} else {
- target, _, code, err = s.resolveTarget(ctx, modelRef, userID, entity.ModelTypeTTS)
+ ttsModel, err = s.modelFactory.NewTTSModel(ctx, access, modelRef)
}
if err != nil {
- return nil, code, err
+ return nil, common.CodeNotFound, err
}
if config == nil {
config = &modelModule.TTSConfig{}
}
- modelName := target.ModelName
- ttsModel := modelModule.NewTTSModel(target.Driver, &modelName, target.APIConfig)
response, err := ttsModel.Speech(ctx, audioContent, config, nil)
if err != nil {
return nil, common.CodeServerError, err
@@ -243,30 +232,27 @@ func (s *ModelCallService) AudioSpeech(ctx context.Context, modelRef, userID str
}
return response, common.CodeSuccess, nil
}
-
-// AudioSpeechForTenant synthesizes audio using a tenant ID supplied by the audio dispatcher.
func (s *ModelCallService) AudioSpeechForTenant(ctx context.Context, modelRef, tenantID string, audioContent *string, config *modelModule.TTSConfig) (*modelModule.TTSResponse, common.ErrorCode, error) {
- var target *ModelTarget
- var code common.ErrorCode
- var err error
+ if s == nil || s.modelFactory == nil {
+ return nil, common.CodeServerError, errors.New("model call service is not initialized")
+ }
+ access := ModelAccess{TenantID: tenantID}
+ var (
+ ttsModel *modelModule.TTSModel
+ err error
+ )
if strings.TrimSpace(modelRef) == "" {
- code = common.CodeNotFound
- target, err = s.modelSolver.ResolveDefaultModelConfig(ctx, tenantID, entity.ModelTypeTTS)
- if err == nil {
- code = common.CodeSuccess
- }
+ ttsModel, err = s.modelFactory.NewDefaultTTSModel(ctx, access)
} else {
- target, code, err = s.resolveTargetByTenant(ctx, modelRef, tenantID, entity.ModelTypeTTS)
+ ttsModel, err = s.modelFactory.NewTTSModel(ctx, access, modelRef)
}
if err != nil {
- return nil, code, err
+ return nil, common.CodeNotFound, err
}
if config == nil {
config = &modelModule.TTSConfig{}
}
- modelName := target.ModelName
- ttsModel := modelModule.NewTTSModel(target.Driver, &modelName, target.APIConfig)
response, err := ttsModel.Speech(ctx, audioContent, config, nil)
if err != nil {
return nil, common.CodeServerError, err
@@ -276,39 +262,37 @@ func (s *ModelCallService) AudioSpeechForTenant(ctx context.Context, modelRef, t
}
return response, common.CodeSuccess, nil
}
-
-// AudioSpeechStream streams synthesized audio from the model selected by
-// modelRef through sender.
func (s *ModelCallService) AudioSpeechStream(ctx context.Context, modelRef, userID string, audioContent *string, config *modelModule.TTSConfig, sender func(*string, *string) error) (common.ErrorCode, error) {
- target, _, code, err := s.resolveTarget(ctx, modelRef, userID, entity.ModelTypeTTS)
+ access, _, code, err := s.modelAccessForUser(ctx, userID)
if err != nil {
return code, err
}
+ ttsModel, err := s.modelFactory.NewTTSModel(ctx, access, modelRef)
+ if err != nil {
+ return common.CodeNotFound, err
+ }
if config == nil {
config = &modelModule.TTSConfig{}
}
-
- modelName := target.ModelName
- ttsModel := modelModule.NewTTSModel(target.Driver, &modelName, target.APIConfig)
if err := ttsModel.SpeechWithSender(ctx, audioContent, config, nil, sender); err != nil {
return common.CodeServerError, err
}
return common.CodeSuccess, nil
}
-
-// OCRFile extracts text from content or url with the model selected by
-// modelRef.
func (s *ModelCallService) OCRFile(ctx context.Context, modelRef, userID string, content []byte, url *string, config *modelModule.OCRConfig) (*modelModule.OCRFileResponse, common.ErrorCode, error) {
- target, _, code, err := s.resolveTarget(ctx, modelRef, userID, entity.ModelTypeOCR)
+ access, _, code, err := s.modelAccessForUser(ctx, userID)
if err != nil {
return nil, code, err
}
+ ocrModel, err := s.modelFactory.NewOCRModel(ctx, access, modelRef)
+ if err != nil {
+ return nil, common.CodeNotFound, err
+ }
if config == nil {
config = &modelModule.OCRConfig{}
}
- modelName := target.ModelName
- response, err := target.Driver.OCRFile(ctx, &modelName, content, url, target.APIConfig, config, nil)
+ response, err := ocrModel.OCRFile(ctx, content, url, config, nil)
if err != nil {
return nil, common.CodeServerError, err
}
@@ -368,30 +352,29 @@ func (s *ModelCallService) ParseFile(ctx context.Context, modelRef, userID strin
return response, common.CodeSuccess, nil
}
-func (s *ModelCallService) resolveTargetByTenant(ctx context.Context, modelRef, tenantID string, modelType entity.ModelType) (*ModelTarget, common.ErrorCode, error) {
- if s == nil || s.providerService == nil || s.modelSolver == nil {
- return nil, common.CodeServerError, errors.New("model call service is not initialized")
+func (s *ModelCallService) modelAccessForUser(ctx context.Context, userID string) (ModelAccess, string, common.ErrorCode, error) {
+ if s == nil || s.providerService == nil || s.modelFactory == nil {
+ return ModelAccess{}, "", common.CodeServerError, errors.New("model call service is not initialized")
}
- target, err := s.modelSolver.ResolveModelConfig(ctx, tenantID, modelType, modelRef)
+ tenantID, err := s.ownerTenantID(ctx, userID)
if err != nil {
- return nil, common.CodeNotFound, err
+ return ModelAccess{}, "", common.CodeNotFound, err
}
- return target, common.CodeSuccess, nil
+ return ModelAccess{UserID: userID, TenantID: tenantID}, tenantID, common.CodeSuccess, nil
}
-func (s *ModelCallService) resolveTarget(ctx context.Context, modelRef, userID string, modelType entity.ModelType) (*ModelTarget, string, common.ErrorCode, error) {
- if s == nil || s.providerService == nil || s.modelSolver == nil {
- return nil, "", common.CodeServerError, errors.New("model call service is not initialized")
- }
- tenantID, err := s.ownerTenantID(ctx, userID)
- if err != nil {
- return nil, "", common.CodeNotFound, err
+func populateModelUsage(usage *common.ModelUsage, info *modelModule.ModelInfo, apiConfig *modelModule.APIConfig, tenantID, userID string) {
+ if usage == nil || info == nil {
+ return
}
- target, err := s.modelSolver.ResolveModelConfig(ctx, tenantID, modelType, modelRef)
- if err != nil {
- return nil, "", common.CodeNotFound, err
+ usage.UserID = userID
+ usage.TenantID = tenantID
+ usage.ProviderName = info.ProviderName
+ usage.InstanceID = info.InstanceID
+ usage.ModelName = info.Name
+ if apiConfig != nil && apiConfig.ApiKey != nil {
+ usage.APIKey = *apiConfig.ApiKey
}
- return target, tenantID, common.CodeSuccess, nil
}
func (s *ModelCallService) ownerTenantID(ctx context.Context, userID string) (string, error) {
@@ -411,20 +394,6 @@ func (s *ModelCallService) ownerTenantID(ctx context.Context, userID string) (st
return tenants[0].TenantID, nil
}
-func populateModelUsage(usage *common.ModelUsage, target *ModelTarget, tenantID, userID string) {
- if usage == nil {
- return
- }
- usage.UserID = userID
- usage.TenantID = tenantID
- usage.ProviderName = target.ProviderName
- usage.InstanceID = target.InstanceID
- usage.ModelName = target.ModelName
- if target.APIConfig != nil && target.APIConfig.ApiKey != nil {
- usage.APIKey = *target.APIConfig.ApiKey
- }
-}
-
func (s *ModelCallService) resolveModelInfo(ctx context.Context, modelRef, userID string) (*ModelInstanceAndProviderInfo, error) {
if s == nil || s.providerService == nil {
return nil, errors.New("model call service is not initialized")
diff --git a/internal/service/model_chat.go b/internal/service/model_chat.go
index 298f63fa22..896c7dfd3a 100644
--- a/internal/service/model_chat.go
+++ b/internal/service/model_chat.go
@@ -24,7 +24,6 @@ import (
"go.uber.org/zap"
"ragflow/internal/common"
- "ragflow/internal/entity"
modelModule "ragflow/internal/entity/models"
)
@@ -35,25 +34,6 @@ const streamDoneSentinel = "[DONE]"
// errStreamDone aborts the driver loop once the terminal sentinel arrives.
var errStreamDone = errors.New("chat stream done")
-func (m *ModelProviderService) Chat(ctx context.Context, tenantID, modelID string, messages []modelModule.Message, config *modelModule.ChatConfig) (*modelModule.ChatResponse, error) {
- target, err := m.modelSolver().ResolveModelConfig(ctx, tenantID, entity.ModelTypeChat, modelID)
- if err != nil {
- return nil, err
- }
- chatModel := modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
- return chatModel.ChatWithMessages(ctx, messages, config, nil)
-}
-
-func (m *ModelProviderService) ChatStream(ctx context.Context, tenantID, modelID string, messages []modelModule.Message, config *modelModule.ChatConfig) (<-chan string, <-chan error, error) {
- target, err := m.modelSolver().ResolveModelConfig(ctx, tenantID, entity.ModelTypeChat, modelID)
- if err != nil {
- return nil, nil, err
- }
- chatModel := modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
- ch, errCh := chatStreamWithContext(ctx, chatModel, messages, config)
- return ch, errCh, nil
-}
-
func chatStreamWithContext(ctx context.Context, chatModel *modelModule.ChatModel, messages []modelModule.Message, config *modelModule.ChatConfig) (<-chan string, <-chan error) {
ch := make(chan string, 256)
errCh := make(chan error, 1)
@@ -85,16 +65,22 @@ func chatStreamWithContext(ctx context.Context, chatModel *modelModule.ChatModel
return ch, errCh
}
-// TenantStreamAdapter adapts tenant/model-aware chat streaming to AskService.
+// TenantStreamAdapter adapts a factory-created chat model to AskService's
+// channel-based streaming interface.
type TenantStreamAdapter struct {
- LLM *ModelProviderService
+ Factory *ModelFactory
TenantID string
ModelID string
}
func (a *TenantStreamAdapter) ChatStream(ctx context.Context, messages []modelModule.Message, config *modelModule.ChatConfig) (<-chan string, <-chan error, error) {
- if a.LLM == nil {
- return nil, nil, fmt.Errorf("streaming LLM not configured")
+ if a.Factory == nil {
+ return nil, nil, fmt.Errorf("model factory not configured")
+ }
+ chatModel, err := a.Factory.NewChatModel(ctx, ModelAccess{TenantID: a.TenantID}, a.ModelID)
+ if err != nil {
+ return nil, nil, err
}
- return a.LLM.ChatStream(ctx, a.TenantID, a.ModelID, messages, config)
+ ch, errCh := chatStreamWithContext(ctx, chatModel, messages, config)
+ return ch, errCh, nil
}
diff --git a/internal/service/model_factory.go b/internal/service/model_factory.go
new file mode 100644
index 0000000000..c470b24742
--- /dev/null
+++ b/internal/service/model_factory.go
@@ -0,0 +1,1093 @@
+//
+// 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.
+//
+
+package service
+
+import (
+ "context"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "strings"
+
+ "gorm.io/gorm"
+
+ "ragflow/internal/common"
+ "ragflow/internal/dao"
+ "ragflow/internal/entity"
+ modelModule "ragflow/internal/entity/models"
+)
+
+// modelTarget is the private result of resolving a model reference. Callers
+// should use ModelFactory to construct a typed model or request public metadata.
+type modelTarget struct {
+ ModelID string
+ ModelName string
+ ModelType entity.ModelType
+ ProviderName string
+ InstanceID string
+ InstanceName string
+ Driver modelModule.ModelDriver
+ APIConfig *modelModule.APIConfig
+ ModelInfo *modelModule.Model
+ ContextLength int
+ MaxOutput int
+ SupportsTools bool
+}
+
+// ModelAccess identifies the user and active tenant requesting a model.
+// UserID may be empty for trusted background work scoped to TenantID.
+type ModelAccess struct {
+ UserID string
+ TenantID string
+}
+
+// ModelFactory resolves model references, checks access, and constructs typed
+// model instances. Provider and instance details stay inside this boundary.
+type ModelFactory struct {
+ tenantDAO *dao.TenantDAO
+ modelProviderDAO *dao.TenantModelProviderDAO
+ modelInstanceDAO *dao.TenantModelInstanceDAO
+ modelDAO *dao.TenantModelDAO
+ userTenantDAO *dao.UserTenantDAO
+}
+
+// NewModelFactory creates a factory backed by the standard model DAOs.
+func NewModelFactory() *ModelFactory {
+ return &ModelFactory{
+ tenantDAO: dao.NewTenantDAO(),
+ modelProviderDAO: dao.NewTenantModelProviderDAO(),
+ modelInstanceDAO: dao.NewTenantModelInstanceDAO(),
+ modelDAO: dao.NewTenantModelDAO(),
+ userTenantDAO: dao.NewUserTenantDAO(),
+ }
+}
+
+// NewChatModel resolves and constructs a chat model for the given access scope.
+func (f *ModelFactory) NewChatModel(ctx context.Context, access ModelAccess, modelRef string) (*modelModule.ChatModel, error) {
+ target, err := f.resolveConfig(ctx, access, entity.ModelTypeChat, modelRef)
+ if err != nil {
+ return nil, err
+ }
+ return modelModule.NewChatModelWithInfo(target.Driver, &target.ModelName, target.APIConfig, modelInfoFromTarget(target)), nil
+}
+
+// NewDefaultChatModel constructs the tenant's configured default chat model.
+func (f *ModelFactory) NewDefaultChatModel(ctx context.Context, access ModelAccess) (*modelModule.ChatModel, error) {
+ target, err := f.resolveDefaultConfig(ctx, access, entity.ModelTypeChat)
+ if err != nil {
+ return nil, err
+ }
+ return modelModule.NewChatModelWithInfo(target.Driver, &target.ModelName, target.APIConfig, modelInfoFromTarget(target)), nil
+}
+
+// NewEmbeddingModel resolves and constructs an embedding model.
+func (f *ModelFactory) NewEmbeddingModel(ctx context.Context, access ModelAccess, modelRef string) (*modelModule.EmbeddingModel, error) {
+ target, err := f.resolveConfig(ctx, access, entity.ModelTypeEmbedding, modelRef)
+ if err != nil {
+ return nil, err
+ }
+ return modelModule.NewEmbeddingModelWithInfo(target.Driver, &target.ModelName, target.APIConfig, inputTokenLimit(target), modelInfoFromTarget(target)), nil
+}
+
+// NewDefaultEmbeddingModel constructs the tenant's configured default embedding model.
+func (f *ModelFactory) NewDefaultEmbeddingModel(ctx context.Context, access ModelAccess) (*modelModule.EmbeddingModel, error) {
+ target, err := f.resolveDefaultConfig(ctx, access, entity.ModelTypeEmbedding)
+ if err != nil {
+ return nil, err
+ }
+ return modelModule.NewEmbeddingModelWithInfo(target.Driver, &target.ModelName, target.APIConfig, inputTokenLimit(target), modelInfoFromTarget(target)), nil
+}
+
+// NewRerankModel resolves and constructs a rerank model.
+func (f *ModelFactory) NewRerankModel(ctx context.Context, access ModelAccess, modelRef string) (*modelModule.RerankModel, error) {
+ target, err := f.resolveConfig(ctx, access, entity.ModelTypeRerank, modelRef)
+ if err != nil {
+ return nil, err
+ }
+ return modelModule.NewRerankModelWithInfo(target.Driver, &target.ModelName, target.APIConfig, inputTokenLimit(target), modelInfoFromTarget(target)), nil
+}
+
+// NewDefaultRerankModel constructs the tenant's configured default rerank model.
+func (f *ModelFactory) NewDefaultRerankModel(ctx context.Context, access ModelAccess) (*modelModule.RerankModel, error) {
+ target, err := f.resolveDefaultConfig(ctx, access, entity.ModelTypeRerank)
+ if err != nil {
+ return nil, err
+ }
+ return modelModule.NewRerankModelWithInfo(target.Driver, &target.ModelName, target.APIConfig, inputTokenLimit(target), modelInfoFromTarget(target)), nil
+}
+
+// NewOCRModel resolves and constructs an OCR model.
+func (f *ModelFactory) NewOCRModel(ctx context.Context, access ModelAccess, modelRef string) (*modelModule.OCRModel, error) {
+ target, err := f.resolveConfig(ctx, access, entity.ModelTypeOCR, modelRef)
+ if err != nil {
+ return nil, err
+ }
+ return modelModule.NewOCRModelWithInfo(target.Driver, &target.ModelName, target.APIConfig, modelInfoFromTarget(target)), nil
+}
+
+// NewASRModel resolves and constructs a speech-to-text model.
+func (f *ModelFactory) NewASRModel(ctx context.Context, access ModelAccess, modelRef string) (*modelModule.ASRModel, error) {
+ target, err := f.resolveConfig(ctx, access, entity.ModelTypeSpeech2Text, modelRef)
+ if err != nil {
+ return nil, err
+ }
+ return modelModule.NewASRModelWithInfo(target.Driver, &target.ModelName, target.APIConfig, modelInfoFromTarget(target)), nil
+}
+
+// NewDefaultASRModel constructs the tenant's configured default speech-to-text model.
+func (f *ModelFactory) NewDefaultASRModel(ctx context.Context, access ModelAccess) (*modelModule.ASRModel, error) {
+ target, err := f.resolveDefaultConfig(ctx, access, entity.ModelTypeSpeech2Text)
+ if err != nil {
+ return nil, err
+ }
+ return modelModule.NewASRModelWithInfo(target.Driver, &target.ModelName, target.APIConfig, modelInfoFromTarget(target)), nil
+}
+
+// NewTTSModel resolves and constructs a text-to-speech model.
+func (f *ModelFactory) NewTTSModel(ctx context.Context, access ModelAccess, modelRef string) (*modelModule.TTSModel, error) {
+ target, err := f.resolveConfig(ctx, access, entity.ModelTypeTTS, modelRef)
+ if err != nil {
+ return nil, err
+ }
+ return modelModule.NewTTSModelWithInfo(target.Driver, &target.ModelName, target.APIConfig, modelInfoFromTarget(target)), nil
+}
+
+// NewDefaultTTSModel constructs the tenant's configured default text-to-speech model.
+func (f *ModelFactory) NewDefaultTTSModel(ctx context.Context, access ModelAccess) (*modelModule.TTSModel, error) {
+ target, err := f.resolveDefaultConfig(ctx, access, entity.ModelTypeTTS)
+ if err != nil {
+ return nil, err
+ }
+ return modelModule.NewTTSModelWithInfo(target.Driver, &target.ModelName, target.APIConfig, modelInfoFromTarget(target)), nil
+}
+
+// ResolveInfo returns model metadata without exposing API credentials or a driver.
+func (f *ModelFactory) ResolveInfo(ctx context.Context, access ModelAccess, modelType entity.ModelType, modelRef string) (*modelModule.ModelInfo, error) {
+ target, err := f.resolveConfig(ctx, access, modelType, modelRef)
+ if err != nil {
+ return nil, err
+ }
+ return modelInfoFromTarget(target), nil
+}
+
+// ResolveDefaultInfo returns metadata for the tenant's default model without
+// exposing its provider driver or API credentials.
+func (f *ModelFactory) ResolveDefaultInfo(ctx context.Context, access ModelAccess, modelType entity.ModelType) (*modelModule.ModelInfo, error) {
+ target, err := f.resolveDefaultConfig(ctx, access, modelType)
+ if err != nil {
+ return nil, err
+ }
+ return modelInfoFromTarget(target), nil
+}
+
+func modelInfoFromTarget(target *modelTarget) *modelModule.ModelInfo {
+ if target == nil {
+ return nil
+ }
+ modelTypes := []string{target.ModelType.String()}
+ if target.ModelInfo != nil && len(target.ModelInfo.ModelTypes) > 0 {
+ modelTypes = append([]string(nil), target.ModelInfo.ModelTypes...)
+ }
+ info := &modelModule.ModelInfo{
+ ID: target.ModelID,
+ Name: target.ModelName,
+ ProviderName: target.ProviderName,
+ InstanceID: target.InstanceID,
+ InstanceName: target.InstanceName,
+ ModelTypes: modelTypes,
+ ContextLength: target.ContextLength,
+ MaxOutput: target.MaxOutput,
+ SupportsTools: target.SupportsTools,
+ Catalog: target.ModelInfo,
+ }
+ if target.ModelInfo != nil {
+ if target.ModelInfo.Class != nil {
+ info.ModelClass = *target.ModelInfo.Class
+ }
+ if target.ModelInfo.Thinking != nil {
+ thinking := *target.ModelInfo.Thinking
+ info.Thinking = &thinking
+ }
+ }
+ return info
+}
+
+func inputTokenLimit(target *modelTarget) int {
+ if target == nil {
+ return 0
+ }
+ if target.ContextLength > 0 {
+ return target.ContextLength
+ }
+ if target.ModelInfo != nil && target.ModelInfo.MaxTokens != nil {
+ return *target.ModelInfo.MaxTokens
+ }
+ return 0
+}
+
+// modelInstanceExtra contains the instance fields consumed during model
+// resolution. Other provider-specific fields remain valid and are ignored.
+type modelInstanceExtra struct {
+ Region string `json:"region"`
+ BaseURL string `json:"base_url"`
+}
+
+// decodeModelInstanceExtra reads only the endpoint fields used for model
+// resolution, allowing existing rows to retain provider-specific JSON values.
+func decodeModelInstanceExtra(raw string) (modelInstanceExtra, error) {
+ if strings.TrimSpace(raw) == "" {
+ return modelInstanceExtra{}, nil
+ }
+
+ var extra modelInstanceExtra
+ if err := json.Unmarshal([]byte(raw), &extra); err != nil {
+ return modelInstanceExtra{}, err
+ }
+ return extra, nil
+}
+
+// parseModelName parses a composite model name in format "model@instance@provider" or "model@provider"
+// Returns modelName, instanceName, providerName separately.
+//
+// The composite key is right-anchored: providerName is always the *last*
+// '@'-separated field, instanceName is the second-to-last (when present),
+// and everything to the left is the bare model name. Some model names
+// legitimately contain '@' characters themselves (e.g. LM Studio embedding
+// model IDs such as `text-embedding-nomic-embed-text-v1.5@q8_0`), which
+// produces composite keys like
+// `text-embedding-nomic-embed-text-v1.5@q8_0@lmstudio@LM-Studio`. When the
+// split yields more than 3 fields we rejoin the leading fields back into the
+// modelName so any embedded '@' characters are preserved verbatim.
+func parseModelName(compositeName string) (modelName, instanceName, providerName string, err error) {
+ parts := strings.Split(compositeName, "@")
+ switch len(parts) {
+ case 3:
+ // Format: model@instance@provider
+ return parts[0], parts[1], parts[2], nil
+ case 2:
+ // Format: model@provider -> instance defaults to "default"
+ return parts[0], "default", parts[1], nil
+ case 1:
+ return parts[0], "", "", fmt.Errorf("provider name missing in model name: %s", compositeName)
+ }
+ // len(parts) > 3: any '@' characters embedded in the leftmost modelName
+ // component must be preserved in that component instead of being dropped
+ // or assigned to the instance/provider fields.
+ n := len(parts)
+ return strings.Join(parts[:n-2], "@"), parts[n-2], parts[n-1], nil
+}
+
+// splitRightAnchoredModelName is a bare-name-tolerant variant of
+// parseModelName used by the Builtin / TEI short-circuit branches in
+// model resolution.
+//
+// Those branches must accept a bare model name (no provider suffix) where
+// parseModelName would return an error, while still preserving any '@'
+// characters embedded in the modelName portion of a multi-segment key.
+// Returns the modelName, instanceName ("default" for the 2-segment form),
+// and providerName ("" for the 1-segment form).
+func splitRightAnchoredModelName(compositeName string) (modelName, instanceName, providerName string) {
+ parts := strings.Split(compositeName, "@")
+ switch len(parts) {
+ case 3:
+ return parts[0], parts[1], parts[2]
+ case 2:
+ // The 2-segment form "model@X" is ambiguous: X could be a provider
+ // suffix (only "Builtin" is recognised by the TEI / Builtin
+ // short-circuits that consume this helper) or part of the model
+ // name itself (e.g. a quantization tag like "q8_0" in
+ // "text-embedding-nomic-embed-text-v1.5@q8_0"). Treat the last
+ // token as a provider only when it actually is one; otherwise
+ // the whole string is the bare model name and the caller falls
+ // through to its non-short-circuit path. The TEI short-circuit's
+ // `modelName == teiModel` exact-match fast path already covers
+ // the bare-default case where the embedded '@' happens to match
+ // the TEI model identifier verbatim.
+ if parts[1] == "Builtin" {
+ return parts[0], "default", parts[1]
+ }
+ return compositeName, "", ""
+ case 1:
+ return parts[0], "", ""
+ }
+ n := len(parts)
+ return strings.Join(parts[:n-2], "@"), parts[n-2], parts[n-1]
+}
+
+type tenantModelExtra struct {
+ MaxTokens *int `json:"max_tokens"`
+ ModelTypes []string `json:"model_types"`
+ MaxDimension *int `json:"max_dimension"`
+ MaxBatchSize *int `json:"max_batch_size"`
+ Dimensions []int `json:"dimensions"`
+ Thinking *bool `json:"thinking"`
+}
+
+func modelInfoWithTenantExtra(modelInfo *modelModule.Model, modelEntity *entity.TenantModel) (*modelModule.Model, error) {
+ if modelEntity == nil {
+ return modelInfo, nil
+ }
+
+ model := modelModule.Model{Name: modelEntity.ModelName}
+ if modelInfo != nil {
+ model = *modelInfo
+ model.ModelTypes = append([]string(nil), modelInfo.ModelTypes...)
+ model.Dimensions = append([]int(nil), modelInfo.Dimensions...)
+ model.Alias = append([]string(nil), modelInfo.Alias...)
+ if modelInfo.ModelTypeMap != nil {
+ model.ModelTypeMap = make(map[string]bool, len(modelInfo.ModelTypeMap))
+ for modelType, enabled := range modelInfo.ModelTypeMap {
+ model.ModelTypeMap[modelType] = enabled
+ }
+ }
+ if modelInfo.Thinking != nil {
+ thinking := *modelInfo.Thinking
+ model.Thinking = &thinking
+ }
+ }
+
+ if modelEntity.ModelType != 0 {
+ setModelInfoTypes(&model, entity.ModelType(modelEntity.ModelType))
+ }
+
+ if strings.TrimSpace(modelEntity.Extra) == "" {
+ return &model, nil
+ }
+ var extra tenantModelExtra
+ if err := json.Unmarshal([]byte(modelEntity.Extra), &extra); err != nil {
+ return nil, err
+ }
+
+ if extra.MaxTokens != nil && *extra.MaxTokens > 0 {
+ contextLength := *extra.MaxTokens
+ model.ContextLength = &contextLength
+ }
+ if modelEntity.ModelType == 0 && len(extra.ModelTypes) > 0 {
+ model.ModelTypes = append([]string(nil), extra.ModelTypes...)
+ model.ModelTypeMap = make(map[string]bool, len(extra.ModelTypes))
+ for _, modelType := range extra.ModelTypes {
+ model.ModelTypeMap[modelType] = true
+ }
+ }
+ if extra.MaxDimension != nil && *extra.MaxDimension > 0 {
+ model.MaxDimension = extra.MaxDimension
+ }
+ if extra.MaxBatchSize != nil && *extra.MaxBatchSize > 0 {
+ model.MaxBatchSize = extra.MaxBatchSize
+ }
+ if len(extra.Dimensions) > 0 {
+ model.Dimensions = append([]int(nil), extra.Dimensions...)
+ }
+ if extra.Thinking != nil {
+ if model.Thinking == nil {
+ model.Thinking = &modelModule.ModelThinking{}
+ }
+ model.Thinking.DefaultValue = *extra.Thinking
+ }
+
+ return &model, nil
+}
+
+func setModelInfoTypes(modelInfo *modelModule.Model, modelTypes entity.ModelType) {
+ if modelInfo == nil {
+ return
+ }
+ modelInfo.ModelTypes = modelTypes.HumanReadable()
+ modelInfo.ModelTypeMap = make(map[string]bool, len(modelInfo.ModelTypes))
+ for _, modelType := range modelInfo.ModelTypes {
+ modelInfo.ModelTypeMap[modelType] = true
+ }
+}
+
+func contextLengthFromModelInfo(modelInfo *modelModule.Model) int {
+ if modelInfo == nil {
+ return 0
+ }
+ if modelInfo.ContextLength != nil && *modelInfo.ContextLength > 0 {
+ return *modelInfo.ContextLength
+ }
+ // max_tokens on persisted tenant/catalog model rows predates the split
+ // between context_length and max_output. It represented the model's
+ // context/input window, so never treat it as an output-generation cap.
+ if modelInfo.MaxTokens != nil && *modelInfo.MaxTokens > 0 {
+ return *modelInfo.MaxTokens
+ }
+ return 0
+}
+
+func maxOutputFromModelInfo(modelInfo *modelModule.Model) int {
+ if modelInfo == nil || modelInfo.MaxOutput == nil || *modelInfo.MaxOutput <= 0 {
+ return 0
+ }
+ return *modelInfo.MaxOutput
+}
+
+// tenantCanReachProviderTenant reports whether userID owns the provider's tenant
+// or is a joined member of it. Mirrors Python's tenant_model_service
+// get_model_config_by_id tenant check (:342-347).
+func (s *ModelFactory) tenantCanReachProviderTenant(ctx context.Context, userID, ownerTenantID string) (bool, error) {
+ if userID == ownerTenantID {
+ return true, nil
+ }
+ if s == nil || s.userTenantDAO == nil {
+ return false, fmt.Errorf("%w: user tenant DAO is not initialized", errModelConfigUnavailable)
+ }
+ userTenants, err := s.userTenantDAO.GetByUserID(ctx, dao.DB, userID)
+ if err != nil {
+ return false, err
+ }
+ for _, rel := range userTenants {
+ if rel != nil && rel.TenantID == ownerTenantID {
+ return true, nil
+ }
+ }
+ return false, nil
+}
+
+func (f *ModelFactory) resolveConfig(ctx context.Context, access ModelAccess, modelType entity.ModelType, modelRef string) (*modelTarget, error) {
+ access = normalizeModelAccess(access)
+ if err := f.authorize(ctx, access); err != nil {
+ return nil, err
+ }
+ return f.resolveConfigAuthorized(ctx, access, modelType, modelRef)
+}
+
+func (f *ModelFactory) resolveConfigAuthorized(ctx context.Context, access ModelAccess, modelType entity.ModelType, modelRef string) (*modelTarget, error) {
+ modelRef = strings.TrimSpace(modelRef)
+ if modelRef == "" {
+ return nil, fmt.Errorf("%w: model ref is required", errModelConfigUnavailable)
+ }
+ if modelType == 0 {
+ return nil, fmt.Errorf("%w: model type is required", errModelConfigUnavailable)
+ }
+
+ return f.resolveModel(ctx, access, modelType, modelRef)
+}
+
+func normalizeModelAccess(access ModelAccess) ModelAccess {
+ access.TenantID = strings.TrimSpace(access.TenantID)
+ access.UserID = strings.TrimSpace(access.UserID)
+ return access
+}
+
+func (f *ModelFactory) authorize(ctx context.Context, access ModelAccess) error {
+ if f == nil {
+ return fmt.Errorf("%w: model factory is not initialized", errModelConfigUnavailable)
+ }
+ if access.TenantID == "" {
+ return fmt.Errorf("%w: tenant id is required", errModelConfigUnavailable)
+ }
+ // A user's personal tenant uses the user ID as its tenant ID. The owner
+ // does not need a user_tenant membership row for that tenant; modelIdentity
+ // still checks whether the requested provider belongs to a reachable tenant.
+ if access.UserID == "" || access.UserID == access.TenantID {
+ return nil
+ }
+ if f.userTenantDAO == nil {
+ return fmt.Errorf("%w: user tenant DAO is not initialized", errModelConfigUnavailable)
+ }
+ if _, err := f.userTenantDAO.FilterByUserIDAndTenantID(ctx, dao.DB, access.UserID, access.TenantID); err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return fmt.Errorf("%w: user %s has no access to tenant %s", errModelConfigUnavailable, access.UserID, access.TenantID)
+ }
+ return fmt.Errorf("check model access: %w", err)
+ }
+ return nil
+}
+
+func (f *ModelFactory) resolveDefaultConfig(ctx context.Context, access ModelAccess, modelType entity.ModelType) (*modelTarget, error) {
+ access = normalizeModelAccess(access)
+ if err := f.authorize(ctx, access); err != nil {
+ return nil, err
+ }
+ if modelType == 0 {
+ return nil, fmt.Errorf("%w: model type is required", errModelConfigUnavailable)
+ }
+ if modelType == entity.ModelTypeOCR {
+ return nil, fmt.Errorf("OCR model name is required")
+ }
+ if f.tenantDAO == nil {
+ return nil, fmt.Errorf("%w: tenant DAO is not initialized", errModelConfigUnavailable)
+ }
+
+ tenant, err := f.tenantDAO.GetByID(ctx, dao.DB, access.TenantID)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get tenant: %s type %s: %w", access.TenantID, modelType, err)
+ }
+ modelName, modelID := defaultModelRefs(tenant, modelType)
+ if modelID != "" {
+ return f.resolveConfigAuthorized(ctx, access, modelType, modelID)
+ }
+ if strings.TrimSpace(modelName) == "" {
+ return nil, fmt.Errorf("no default %s model is set", modelType)
+ }
+ return f.resolveConfigAuthorized(ctx, access, modelType, modelName)
+}
+
+func defaultModelRefs(tenant *entity.Tenant, modelType entity.ModelType) (string, string) {
+ if tenant == nil {
+ return "", ""
+ }
+ switch modelType {
+ case entity.ModelTypeChat:
+ return tenant.LLMID, ptrStringValue(tenant.TenantLLMID)
+ case entity.ModelTypeEmbedding:
+ return tenant.EmbdID, ptrStringValue(tenant.TenantEmbdID)
+ case entity.ModelTypeRerank:
+ return tenant.RerankID, ptrStringValue(tenant.TenantRerankID)
+ case entity.ModelTypeSpeech2Text:
+ return tenant.ASRID, ptrStringValue(tenant.TenantASRID)
+ case entity.ModelTypeImage2Text:
+ return tenant.Img2TxtID, ptrStringValue(tenant.TenantImg2TxtID)
+ case entity.ModelTypeTTS:
+ return ptrStringValue(tenant.TTSID), ptrStringValue(tenant.TenantTTSID)
+ case entity.ModelTypeOCR:
+ return ptrStringValue(tenant.OCRID), ptrStringValue(tenant.TenantOCRID)
+ default:
+ return "", ""
+ }
+}
+
+// ResolveModelType returns every model category supported by modelRef. A
+// model may expose multiple categories, such as chat and vision.
+func (s *ModelFactory) ResolveModelType(ctx context.Context, access ModelAccess, modelRef string) ([]entity.ModelType, error) {
+ access = normalizeModelAccess(access)
+ if err := s.authorize(ctx, access); err != nil {
+ return nil, err
+ }
+ modelRef = strings.TrimSpace(modelRef)
+ if modelRef == "" {
+ return nil, fmt.Errorf("%w: model ref is required", errModelConfigUnavailable)
+ }
+
+ model, err := s.lookupTenantModel(ctx, access.TenantID, modelRef)
+ if err == nil {
+ identity, identityErr := s.modelIdentity(ctx, access.TenantID, access.UserID, model, modelRef)
+ if identityErr != nil {
+ return nil, identityErr
+ }
+ return modelTypesFromBitmask(identity.modelType), nil
+ }
+ if !errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, err
+ }
+
+ modelType, err := s.resolveCompositeModelType(ctx, access.TenantID, modelRef)
+ if err != nil {
+ return nil, err
+ }
+ return modelTypesFromBitmask(modelType), nil
+}
+
+type modelIdentity struct {
+ modelEntity *entity.TenantModel
+ providerEntity *entity.TenantModelProvider
+ instanceEntity *entity.TenantModelInstance
+ modelType entity.ModelType
+}
+
+func toolSupportFromEnrollment(extra, instanceAPIKey, providerName, modelName string) bool {
+ if supported, ok := extraToolSupport(extra); ok {
+ return supported
+ }
+ if supported, ok := extraToolSupport(instanceAPIKey); ok {
+ return supported
+ }
+ return catalogToolSupport(providerName, modelName)
+}
+
+func extraToolSupport(extra string) (bool, bool) {
+ if strings.TrimSpace(extra) == "" {
+ return false, false
+ }
+ var fields map[string]any
+ if err := json.Unmarshal([]byte(extra), &fields); err != nil {
+ return false, false
+ }
+ value, ok := fields["is_tools"]
+ if !ok {
+ return false, false
+ }
+ switch value := value.(type) {
+ case bool:
+ return value, true
+ case string:
+ return strings.EqualFold(strings.TrimSpace(value), "true"), true
+ case float64:
+ return value != 0, true
+ default:
+ return false, false
+ }
+}
+
+func catalogToolSupport(providerName, modelName string) bool {
+ providerManager := dao.GetModelProviderManager()
+ provider := providerManager.FindProvider(providerName)
+ if provider == nil {
+ return false
+ }
+ model := providerManager.FindModel(provider, modelName)
+ return model != nil && model.Tools != nil && model.Tools.Support
+}
+
+func (s *ModelFactory) lookupTenantModel(ctx context.Context, tenantID, modelRef string) (*entity.TenantModel, error) {
+ if s == nil {
+ return nil, fmt.Errorf("%w: model factory is not initialized", errModelConfigUnavailable)
+ }
+ if tenantID == "" {
+ return nil, fmt.Errorf("%w: tenant id is required", errModelConfigUnavailable)
+ }
+ if modelRef == "" {
+ return nil, fmt.Errorf("%w: model ref is required", errModelConfigUnavailable)
+ }
+ if s.modelDAO == nil {
+ return nil, fmt.Errorf("%w: model factory is not initialized", errModelConfigUnavailable)
+ }
+
+ return s.modelDAO.GetByID(ctx, dao.DB, modelRef)
+}
+
+func (s *ModelFactory) modelIdentity(ctx context.Context, tenantID, userID string, modelEntity *entity.TenantModel, modelRef string) (*modelIdentity, error) {
+ if modelEntity == nil {
+ return nil, fmt.Errorf("%w: tenant model %q not found", errModelConfigUnavailable, modelRef)
+ }
+ if !strings.EqualFold(modelEntity.Status, "active") {
+ return nil, fmt.Errorf("%w: tenant model %q is disabled", errModelConfigUnavailable, modelRef)
+ }
+
+ modelType := entity.ModelType(modelEntity.ModelType)
+ if modelType == 0 {
+ return nil, fmt.Errorf("%w: tenant model %q has no model type", errModelConfigUnavailable, modelRef)
+ }
+ if s.modelProviderDAO == nil || s.modelInstanceDAO == nil {
+ return nil, fmt.Errorf("%w: model factory is not initialized", errModelConfigUnavailable)
+ }
+
+ providerEntity, err := s.modelProviderDAO.GetByID(ctx, dao.DB, modelEntity.ProviderID)
+ if err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, fmt.Errorf("%w: provider id=%s not found for model %q", errModelConfigUnavailable, modelEntity.ProviderID, modelRef)
+ }
+ return nil, err
+ }
+ if providerEntity == nil {
+ return nil, fmt.Errorf("%w: provider id=%s not found for model %q", errModelConfigUnavailable, modelEntity.ProviderID, modelRef)
+ }
+ allowed := providerEntity.TenantID == tenantID
+ if !allowed && userID != "" {
+ var err error
+ allowed, err = s.tenantCanReachProviderTenant(ctx, userID, providerEntity.TenantID)
+ if err != nil {
+ return nil, err
+ }
+ }
+ if !allowed {
+ return nil, fmt.Errorf(
+ "%w: tenant %s has no access to provider owned by tenant %s",
+ errModelConfigUnavailable,
+ tenantID,
+ providerEntity.TenantID,
+ )
+ }
+ instanceEntity, err := s.modelInstanceDAO.GetByID(ctx, dao.DB, modelEntity.InstanceID)
+ if err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, fmt.Errorf("%w: instance id=%s not found for model %q", errModelConfigUnavailable, modelEntity.InstanceID, modelRef)
+ }
+ return nil, err
+ }
+ if instanceEntity == nil || instanceEntity.ProviderID != providerEntity.ID {
+ return nil, fmt.Errorf("%w: instance id=%s does not belong to provider id=%s", errModelConfigUnavailable, modelEntity.InstanceID, providerEntity.ID)
+ }
+ if !strings.EqualFold(instanceEntity.Status, "active") {
+ return nil, fmt.Errorf("%w: model instance %q is disabled", errModelConfigUnavailable, instanceEntity.InstanceName)
+ }
+
+ return &modelIdentity{
+ modelEntity: modelEntity,
+ providerEntity: providerEntity,
+ instanceEntity: instanceEntity,
+ modelType: modelType,
+ }, nil
+}
+
+func (s *ModelFactory) resolveModel(ctx context.Context, access ModelAccess, modelType entity.ModelType, modelRef string) (*modelTarget, error) {
+ modelEntity, err := s.lookupTenantModel(ctx, access.TenantID, modelRef)
+ if err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ // A bare ref that is BOTH unknown as a tenant model id AND rejected as
+ // a composite name is almost always a DANGLING REFERENCE — a knowledge
+ // base or chat pointing at a tenant_model row that was deleted. Say so
+ // explicitly: the underlying "provider name missing in model name:
+ // <uuid>" reads like a naming-format mistake and sends the operator to
+ // look at the model's name instead of at the row that no longer exists.
+ composite, compositeErr := s.resolveProviderInstanceModel(ctx, access.TenantID, modelType, modelRef)
+ if compositeErr != nil && !strings.Contains(modelRef, "@") {
+ return nil, fmt.Errorf("model %q is neither a tenant model id (no tenant_model row) nor a valid composite name — the reference is dangling: %w", modelRef, compositeErr)
+ }
+ return composite, compositeErr
+ }
+ return nil, err
+ }
+ identity, err := s.modelIdentity(ctx, access.TenantID, access.UserID, modelEntity, modelRef)
+ if err != nil {
+ return nil, err
+ }
+ if !identity.modelType.Has(modelType) {
+ return nil, fmt.Errorf("%w: tenant model %q cannot be used as %s model", errModelConfigUnavailable, modelRef, modelType.String())
+ }
+ return s.resolveTenantModel(ctx, modelType, modelRef, identity)
+}
+
+func (s *ModelFactory) resolveTenantModel(ctx context.Context, modelType entity.ModelType, modelRef string, identity *modelIdentity) (*modelTarget, error) {
+ modelEntity := identity.modelEntity
+ providerEntity := identity.providerEntity
+ instanceEntity := identity.instanceEntity
+
+ providerInfo := dao.GetModelProviderManager().FindProvider(providerEntity.ProviderName)
+ if providerInfo == nil {
+ return nil, fmt.Errorf("%w: provider %q driver not found", errModelConfigUnavailable, providerEntity.ProviderName)
+ }
+
+ modelInfo, _ := dao.GetModelProviderManager().GetModelByName(providerEntity.ProviderName, modelEntity.ModelName)
+ modelInfo, err := modelInfoWithTenantExtra(modelInfo, modelEntity)
+ if err != nil {
+ return nil, fmt.Errorf("%w: read model metadata: %v", errModelConfigUnavailable, err)
+ }
+
+ extra, err := decodeModelInstanceExtra(instanceEntity.Extra)
+ if err != nil {
+ return nil, fmt.Errorf("%w: decode model instance configuration: %v", errModelConfigUnavailable, err)
+ }
+ apiKey := instanceEntity.APIKey
+ region := extra.Region
+ baseURL := extra.BaseURL
+ driver, err := newModelDriverForBaseURL(providerInfo.ModelDriver, providerEntity.ProviderName, region, baseURL)
+ if err != nil {
+ return nil, fmt.Errorf("%w: create model driver: %v", errModelConfigUnavailable, err)
+ }
+
+ return &modelTarget{
+ ModelID: modelEntity.ID,
+ ModelName: modelEntity.ModelName,
+ ModelType: modelType,
+ ProviderName: providerEntity.ProviderName,
+ InstanceID: instanceEntity.ID,
+ InstanceName: instanceEntity.InstanceName,
+ Driver: driver,
+ APIConfig: &modelModule.APIConfig{ApiKey: &apiKey, Region: &region, BaseURL: &baseURL},
+ ModelInfo: modelInfo,
+ ContextLength: contextLengthFromModelInfo(modelInfo),
+ MaxOutput: maxOutputFromModelInfo(modelInfo),
+ SupportsTools: toolSupportFromEnrollment(modelEntity.Extra, instanceEntity.APIKey, providerEntity.ProviderName, modelEntity.ModelName),
+ }, nil
+}
+
+func (s *ModelFactory) resolveProviderInstanceModel(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string) (*modelTarget, error) {
+ // TEI builtin embedding short-circuit.
+ if modelType == entity.ModelTypeEmbedding && strings.Contains(common.GetEnv(common.EnvComposeProfiles), "tei-") {
+ teiModel := common.GetEnv(common.EnvTEIModel)
+ teiBaseURL := common.GetEnv(common.EnvTEIBaseURL)
+ if modelRef == teiModel {
+ driver := modelModule.GetBuiltinEmbeddingModel(modelRef)
+ if driver == nil {
+ return nil, fmt.Errorf("%w: builtin (TEI) embedding model %q not found", errModelConfigUnavailable, modelRef)
+ }
+ modelInfo, _ := dao.GetModelProviderManager().GetModelByName("Builtin", modelRef)
+ return builtinModelTarget(modelType, modelRef, driver, &modelModule.APIConfig{BaseURL: &teiBaseURL}, modelInfo), nil
+ }
+ teiPure, _, teiProvider := splitRightAnchoredModelName(modelRef)
+ if teiPure == teiModel && (teiProvider == "Builtin" || teiProvider == "") {
+ driver := modelModule.GetBuiltinEmbeddingModel(teiPure)
+ if driver == nil {
+ return nil, fmt.Errorf("%w: builtin (TEI) embedding model %q not found", errModelConfigUnavailable, teiPure)
+ }
+ modelInfo, _ := dao.GetModelProviderManager().GetModelByName("Builtin", teiPure)
+ return builtinModelTarget(modelType, teiPure, driver, &modelModule.APIConfig{BaseURL: &teiBaseURL}, modelInfo), nil
+ }
+ }
+ if s == nil || s.modelProviderDAO == nil || s.modelInstanceDAO == nil || s.modelDAO == nil {
+ return nil, fmt.Errorf("%w: model factory is not initialized", errModelConfigUnavailable)
+ }
+
+ pureModelName, instanceName, providerName, err := parseModelName(modelRef)
+ if err != nil {
+ return nil, fmt.Errorf("%w: %v", errModelConfigUnavailable, err)
+ }
+ if modelType == entity.ModelTypeEmbedding {
+ var builtinName string
+ switch {
+ case strings.HasSuffix(modelRef, "@default@Builtin"):
+ builtinName = strings.TrimSuffix(modelRef, "@default@Builtin")
+ case strings.HasSuffix(modelRef, "@Builtin"):
+ builtinName = strings.TrimSuffix(modelRef, "@Builtin")
+ }
+ if builtinName != "" {
+ driver := modelModule.GetBuiltinEmbeddingModel(builtinName)
+ if driver == nil {
+ return nil, fmt.Errorf("%w: builtin embedding model %q not found", errModelConfigUnavailable, builtinName)
+ }
+ apiKey, region := "", ""
+ modelInfo, _ := dao.GetModelProviderManager().GetModelByName("Builtin", builtinName)
+ return builtinModelTarget(modelType, builtinName, driver, &modelModule.APIConfig{ApiKey: &apiKey, Region: &region}, modelInfo), nil
+ }
+ }
+
+ provider, err := s.modelProviderDAO.GetByTenantIDAndProviderName(ctx, dao.DB, tenantID, providerName)
+ if err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, fmt.Errorf("%w: provider %q lookup failed: %w", errModelConfigUnavailable, providerName, err)
+ }
+ return nil, fmt.Errorf("provider %q lookup failed: %w", providerName, err)
+ }
+ if provider == nil {
+ return nil, fmt.Errorf("%w: provider %q not found for model %q", errModelConfigUnavailable, providerName, modelRef)
+ }
+ instance, err := s.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, instanceName)
+ if err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, fmt.Errorf("%w: instance %q lookup failed: %w", errModelConfigUnavailable, instanceName, err)
+ }
+ return nil, fmt.Errorf("instance %q lookup failed: %w", instanceName, err)
+ }
+ if instance == nil {
+ return nil, fmt.Errorf("%w: instance %q not found for model %q", errModelConfigUnavailable, instanceName, modelRef)
+ }
+ if !strings.EqualFold(instance.Status, "active") {
+ return nil, fmt.Errorf("%w: model instance %q is disabled", errModelConfigUnavailable, instanceName)
+ }
+ extra, err := decodeModelInstanceExtra(instance.Extra)
+ if err != nil {
+ return nil, fmt.Errorf("%w: decode model instance configuration: %v", errModelConfigUnavailable, err)
+ }
+ region, baseURL, apiKey := extra.Region, extra.BaseURL, instance.APIKey
+ modelEntities, err := s.modelDAO.GetModelsByProviderIDAndInstanceIDAndModelName(ctx, dao.DB, provider.ID, instance.ID, pureModelName)
+ if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, fmt.Errorf("model %q lookup failed: %w", modelRef, err)
+ }
+ var availableTypes entity.ModelType
+ var modelEntity *entity.TenantModel
+ var disabledForRequestedType bool
+ for _, candidate := range modelEntities {
+ if candidate == nil {
+ continue
+ }
+ candidateTypes := entity.ModelType(candidate.ModelType)
+ if strings.EqualFold(candidate.Status, "active") {
+ availableTypes |= candidateTypes
+ if candidateTypes.Has(modelType) && modelEntity == nil {
+ modelEntity = candidate
+ }
+ } else if candidateTypes.Has(modelType) {
+ disabledForRequestedType = true
+ }
+ }
+ if availableTypes != 0 && !availableTypes.Has(modelType) {
+ return nil, fmt.Errorf("%w: model %q cannot be used as %s model", errModelConfigUnavailable, modelRef, modelType.String())
+ }
+ if modelEntity == nil && availableTypes == 0 && disabledForRequestedType {
+ return nil, fmt.Errorf("%w: model %q is disabled", errModelConfigUnavailable, modelRef)
+ }
+
+ providerInfo := dao.GetModelProviderManager().FindProvider(providerName)
+ if availableTypes != 0 {
+ if providerInfo == nil {
+ return nil, fmt.Errorf("%w: provider %q driver not found", errModelConfigUnavailable, providerName)
+ }
+ driver, driverErr := newModelDriverForBaseURL(providerInfo.ModelDriver, providerName, region, baseURL)
+ if driverErr != nil {
+ return nil, fmt.Errorf("%w: create model driver: %v", errModelConfigUnavailable, driverErr)
+ }
+ modelInfo, _ := dao.GetModelProviderManager().GetModelByName(providerName, pureModelName)
+ modelInfo, err = modelInfoWithTenantExtra(modelInfo, modelEntity)
+ if err != nil {
+ return nil, fmt.Errorf("%w: read model metadata: %v", errModelConfigUnavailable, err)
+ }
+ setModelInfoTypes(modelInfo, availableTypes)
+ return &modelTarget{
+ ModelID: modelEntity.ID,
+ ModelName: modelEntity.ModelName,
+ ModelType: modelType,
+ ProviderName: provider.ProviderName,
+ InstanceID: instance.ID,
+ InstanceName: instance.InstanceName,
+ Driver: driver,
+ APIConfig: &modelModule.APIConfig{ApiKey: &apiKey, Region: &region, BaseURL: &baseURL},
+ ModelInfo: modelInfo,
+ ContextLength: contextLengthFromModelInfo(modelInfo),
+ MaxOutput: maxOutputFromModelInfo(modelInfo),
+ SupportsTools: toolSupportFromEnrollment(modelEntity.Extra, apiKey, provider.ProviderName, modelEntity.ModelName),
+ }, nil
+ }
+ if providerInfo == nil {
+ return nil, fmt.Errorf("%w: model provider config not found: %s", errModelConfigUnavailable, providerName)
+ }
+ targetFactoryName := providerName
+ if region == "intl" && strings.EqualFold(providerName, "siliconflow") {
+ targetFactoryName = "siliconflow_intl"
+ }
+ targetProvider := dao.GetModelProviderManager().FindProvider(targetFactoryName)
+ if targetProvider == nil {
+ return nil, fmt.Errorf("%w: model provider config not found: %s", errModelConfigUnavailable, providerName)
+ }
+ var modelInfo *modelModule.Model
+ for _, candidate := range targetProvider.Models {
+ if strings.EqualFold(candidate.Name, pureModelName) {
+ modelInfo = candidate
+ break
+ }
+ }
+ if modelInfo == nil {
+ return nil, fmt.Errorf("%w: model config not found: %s", errModelConfigUnavailable, modelRef)
+ }
+ availableTypes = entity.ModelTypeFromStrings(modelInfo.ModelTypes)
+ if !availableTypes.Has(modelType) {
+ return nil, fmt.Errorf("%w: model %q cannot be used as %s model", errModelConfigUnavailable, modelRef, modelType.String())
+ }
+ driver, err := newModelDriverForBaseURL(targetProvider.ModelDriver, providerName, region, baseURL)
+ if err != nil {
+ return nil, fmt.Errorf("%w: create model driver: %v", errModelConfigUnavailable, err)
+ }
+ return &modelTarget{
+ ModelName: modelInfo.Name,
+ ModelType: modelType,
+ ProviderName: provider.ProviderName,
+ InstanceID: instance.ID,
+ InstanceName: instance.InstanceName,
+ Driver: driver,
+ APIConfig: &modelModule.APIConfig{ApiKey: &apiKey, Region: &region, BaseURL: &baseURL},
+ ModelInfo: modelInfo,
+ ContextLength: contextLengthFromModelInfo(modelInfo),
+ MaxOutput: maxOutputFromModelInfo(modelInfo),
+ SupportsTools: toolSupportFromEnrollment("", apiKey, provider.ProviderName, modelInfo.Name),
+ }, nil
+}
+
+func builtinModelTarget(modelType entity.ModelType, modelName string, driver modelModule.ModelDriver, apiConfig *modelModule.APIConfig, modelInfo *modelModule.Model) *modelTarget {
+ var apiKey string
+ if apiConfig != nil && apiConfig.ApiKey != nil {
+ apiKey = *apiConfig.ApiKey
+ }
+ return &modelTarget{
+ ModelName: modelName,
+ ModelType: modelType,
+ ProviderName: "Builtin",
+ Driver: driver,
+ APIConfig: apiConfig,
+ ModelInfo: modelInfo,
+ ContextLength: contextLengthFromModelInfo(modelInfo),
+ MaxOutput: maxOutputFromModelInfo(modelInfo),
+ SupportsTools: toolSupportFromEnrollment("", apiKey, "Builtin", modelName),
+ }
+}
+
+func (s *ModelFactory) resolveCompositeModelType(ctx context.Context, tenantID, modelRef string) (entity.ModelType, error) {
+ if strings.Contains(common.GetEnv(common.EnvComposeProfiles), "tei-") {
+ teiModel := common.GetEnv(common.EnvTEIModel)
+ if modelRef == teiModel {
+ if modelModule.GetBuiltinEmbeddingModel(teiModel) == nil {
+ return 0, fmt.Errorf("%w: builtin (TEI) embedding model %q not found", errModelConfigUnavailable, teiModel)
+ }
+ return entity.ModelTypeEmbedding, nil
+ }
+ }
+ pureModelName, instanceName, providerName, err := parseModelName(modelRef)
+ if err != nil {
+ return 0, fmt.Errorf("%w: %v", errModelConfigUnavailable, err)
+ }
+
+ if strings.EqualFold(providerName, "Builtin") {
+ if modelModule.GetBuiltinEmbeddingModel(pureModelName) == nil {
+ return 0, fmt.Errorf("%w: builtin model %q not found", errModelConfigUnavailable, pureModelName)
+ }
+ return entity.ModelTypeEmbedding, nil
+ }
+ if s == nil || s.modelProviderDAO == nil || s.modelInstanceDAO == nil || s.modelDAO == nil {
+ return 0, fmt.Errorf("%w: model factory is not initialized", errModelConfigUnavailable)
+ }
+
+ provider, err := s.modelProviderDAO.GetByTenantIDAndProviderName(ctx, dao.DB, tenantID, providerName)
+ if err != nil {
+ return 0, fmt.Errorf("%w: provider %q lookup failed: %w", errModelConfigUnavailable, providerName, err)
+ }
+ if provider == nil {
+ return 0, fmt.Errorf("%w: provider %q not found for model %q", errModelConfigUnavailable, providerName, modelRef)
+ }
+ instance, err := s.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, instanceName)
+ if err != nil {
+ return 0, fmt.Errorf("%w: instance %q lookup failed: %w", errModelConfigUnavailable, instanceName, err)
+ }
+ if instance == nil {
+ return 0, fmt.Errorf("%w: instance %q not found for model %q", errModelConfigUnavailable, instanceName, modelRef)
+ }
+ if !strings.EqualFold(instance.Status, "active") {
+ return 0, fmt.Errorf("%w: model instance %q is disabled", errModelConfigUnavailable, instanceName)
+ }
+
+ models, err := s.modelDAO.GetModelsByProviderIDAndInstanceIDAndModelName(ctx, dao.DB, provider.ID, instance.ID, pureModelName)
+ if err != nil {
+ return 0, fmt.Errorf("%w: model %q lookup failed: %v", errModelConfigUnavailable, modelRef, err)
+ }
+ var activeTypes, inactiveTypes entity.ModelType
+ for _, model := range models {
+ if model == nil {
+ continue
+ }
+ if strings.EqualFold(model.Status, "active") {
+ activeTypes |= entity.ModelType(model.ModelType)
+ } else {
+ inactiveTypes |= entity.ModelType(model.ModelType)
+ }
+ }
+ if activeTypes != 0 {
+ return activeTypes, nil
+ }
+
+ providerInfo := dao.GetModelProviderManager().FindProvider(providerName)
+ if providerInfo == nil {
+ return 0, fmt.Errorf("%w: model provider config not found: %s", errModelConfigUnavailable, providerName)
+ }
+ for _, model := range providerInfo.Models {
+ if model != nil && strings.EqualFold(model.Name, pureModelName) {
+ catalogTypes := entity.ModelTypeFromStrings(model.ModelTypes)
+ availableTypes := catalogTypes &^ inactiveTypes
+ if availableTypes != 0 {
+ return availableTypes, nil
+ }
+ break
+ }
+ }
+ return 0, fmt.Errorf("%w: model %q not found for provider %q", errModelConfigUnavailable, pureModelName, providerName)
+}
+
+func modelTypesFromBitmask(modelType entity.ModelType) []entity.ModelType {
+ modelTypes := make([]entity.ModelType, 0, 7)
+ for _, candidate := range []entity.ModelType{
+ entity.ModelTypeChat,
+ entity.ModelTypeEmbedding,
+ entity.ModelTypeSpeech2Text,
+ entity.ModelTypeImage2Text,
+ entity.ModelTypeRerank,
+ entity.ModelTypeTTS,
+ entity.ModelTypeOCR,
+ } {
+ if modelType.Has(candidate) {
+ modelTypes = append(modelTypes, candidate)
+ }
+ }
+ return modelTypes
+}
diff --git a/internal/service/model_service.go b/internal/service/model_service.go
index 0241773ce1..54e3eb49b2 100644
--- a/internal/service/model_service.go
+++ b/internal/service/model_service.go
@@ -443,16 +443,17 @@ func (m *ModelProviderService) addModelsToNewInstance(ctx context.Context, tenan
if llm.Thinking != nil {
extraMap["thinking"] = llm.Thinking.DefaultValue
}
+ contextLength := 0
+ if llm.ContextLength != nil {
+ contextLength = *llm.ContextLength
+ } else if llm.MaxTokens != nil {
+ contextLength = *llm.MaxTokens
+ }
if err := m.addModelToInstance(ctx, tenantID, providerName, instanceName, CreateInstanceModelInfo{
ModelName: llm.Name,
ModelTypes: llm.ModelTypes,
- MaxTokens: func() int {
- if llm.MaxOutput != nil {
- return *llm.MaxOutput
- }
- return 8192
- }(),
- Extra: extraMap,
+ MaxTokens: contextLength,
+ Extra: extraMap,
}); err != nil {
return err
}
@@ -972,7 +973,7 @@ func verifyProviderModel(ctx context.Context, driver modelModule.ModelDriver, pr
Documents: []string{"test"},
}
rerankModel := modelModule.NewRerankModel(driver, &modelName, apiConfig, 0)
- _, err = rerankModel.Rerank(ctx, rerankRequest, apiConfig, &modelModule.RerankConfig{}, nil)
+ _, err = rerankModel.Rerank(ctx, rerankRequest, &modelModule.RerankConfig{}, nil)
case "tts":
content := "hello"
ttsModel := modelModule.NewTTSModel(driver, &modelName, apiConfig)
@@ -2454,7 +2455,7 @@ type AddModelRequest struct {
}
// The tool-calling verdict is no longer memoized: it is computed while the model
-// is resolved (see resolvedModel.supportsTools) and travels with the resolution,
+// is resolved by ModelFactory and travels with the model metadata,
// so there is no second lookup to amortize.
type AddCustomModelRequest struct {
@@ -2598,64 +2599,3 @@ func (m *ModelProviderService) ListAllModels(pageIndex, pageSize int) ([]map[str
func (m *ModelProviderService) ShowModel(modelName string) (*modelModule.Model, error) {
return dao.GetModelProviderManager().GetModelByNameOrAlias(modelName), nil
}
-
-// ChatModelRef identifies one chat-capable tenant model together with its
-// human-readable coordinates (provider instance), so callers can log and
-// reason about failover chains. Ref is the tenant_model.id that
-// ResolveModelConfig / GetChatModelConfig accepts verbatim.
-type ChatModelRef struct {
- Ref string
- ModelName string
- InstanceName string
- ProviderName string
-}
-
-// ListTenantChatModelRefs enumerates every ACTIVE chat-capable model the
-// tenant owns across all provider instances. Resolution of each ref is the
-// caller's business — a single broken entry here is not an error for the
-// whole enumeration.
-func (m *ModelProviderService) ListTenantChatModelRefs(ctx context.Context, tenantID string) ([]ChatModelRef, error) {
- providers, err := m.modelProviderDAO.GetByTenantID(ctx, dao.DB, tenantID)
- if err != nil {
- return nil, err
- }
- if len(providers) == 0 {
- return nil, nil
- }
- providerIDs := make([]string, 0, len(providers))
- providerInfoByID := make(map[string]*entity.TenantModelProvider, len(providers))
- for _, p := range providers {
- providerIDs = append(providerIDs, p.ID)
- providerInfoByID[p.ID] = p
- }
- instances, err := m.modelInstanceDAO.GetByProviderIDs(ctx, dao.DB, providerIDs)
- if err != nil {
- return nil, err
- }
- if len(instances) == 0 {
- return nil, nil
- }
- instanceIDs := make([]string, 0, len(instances))
- instanceInfoByID := make(map[string]*entity.TenantModelInstance, len(instances))
- for _, inst := range instances {
- instanceIDs = append(instanceIDs, inst.ID)
- instanceInfoByID[inst.ID] = inst
- }
- models, err := m.modelDAO.GetActiveModelsByProviderAndInstanceIDsAndType(
- ctx, dao.DB, providerIDs, instanceIDs, int(entity.ModelTypeChat))
- if err != nil {
- return nil, err
- }
- refs := make([]ChatModelRef, 0, len(models))
- for _, rec := range models {
- ref := ChatModelRef{Ref: rec.ID, ModelName: rec.ModelName}
- if inst := instanceInfoByID[rec.InstanceID]; inst != nil {
- ref.InstanceName = inst.InstanceName
- }
- if prov := providerInfoByID[rec.ProviderID]; prov != nil {
- ref.ProviderName = prov.ProviderName
- }
- refs = append(refs, ref)
- }
- return refs, nil
-}
diff --git a/internal/service/model_service_test.go b/internal/service/model_service_test.go
index bc6a0bc96b..1a2580c07c 100644
--- a/internal/service/model_service_test.go
+++ b/internal/service/model_service_test.go
@@ -204,16 +204,20 @@ func TestVerifyProviderModelValidatesRemoteEmbeddingMetadata(t *testing.T) {
func TestModelInfoWithTenantExtraAppliesEmbeddingConstraints(t *testing.T) {
factoryMaxDimension := 2048
factoryBatchSize := 128
+ factoryContextLength := 8192
+ factoryMaxOutput := 2048
modelInfo := &modelModule.Model{
- Name: "embedding-3",
- MaxDimension: &factoryMaxDimension,
- MaxBatchSize: &factoryBatchSize,
- Dimensions: []int{1024, 2048},
- ModelTypes: []string{"embedding"},
- ModelTypeMap: map[string]bool{"embedding": true},
+ Name: "embedding-3",
+ ContextLength: &factoryContextLength,
+ MaxOutput: &factoryMaxOutput,
+ MaxDimension: &factoryMaxDimension,
+ MaxBatchSize: &factoryBatchSize,
+ Dimensions: []int{1024, 2048},
+ ModelTypes: []string{"embedding"},
+ ModelTypeMap: map[string]bool{"embedding": true},
}
modelEntity := &entity.TenantModel{
- Extra: `{"max_dimension":768,"max_batch_size":16,"dimensions":[384,768],"model_types":["embedding"]}`,
+ Extra: `{"max_tokens":4096,"max_dimension":768,"max_batch_size":16,"dimensions":[384,768],"model_types":["embedding"]}`,
}
merged, err := modelInfoWithTenantExtra(modelInfo, modelEntity)
@@ -229,6 +233,12 @@ func TestModelInfoWithTenantExtraAppliesEmbeddingConstraints(t *testing.T) {
if merged.MaxBatchSize == nil || *merged.MaxBatchSize != 16 {
t.Fatalf("MaxBatchSize = %v, want 16", merged.MaxBatchSize)
}
+ if merged.ContextLength == nil || *merged.ContextLength != 4096 {
+ t.Fatalf("ContextLength = %v, want legacy max_tokens value 4096", merged.ContextLength)
+ }
+ if merged.MaxOutput == nil || *merged.MaxOutput != factoryMaxOutput {
+ t.Fatalf("MaxOutput = %v, want unchanged output cap %d", merged.MaxOutput, factoryMaxOutput)
+ }
if len(merged.Dimensions) != 2 || merged.Dimensions[0] != 384 || merged.Dimensions[1] != 768 {
t.Fatalf("Dimensions = %v, want [384 768]", merged.Dimensions)
}
@@ -438,18 +448,18 @@ func TestModelProviderServiceAlterModelStatusByID(t *testing.T) {
}
}
-func TestModelSolverResolveModelConfigByID(t *testing.T) {
+func TestModelFactoryResolveModelConfigByID(t *testing.T) {
db := setupModelProviderServiceTestDB(t)
useModelProviderServiceTestDB(t, db)
seedModelProviderServiceScope(t, db)
ctx := t.Context()
- target, err := NewModelSolver().ResolveModelConfig(ctx, "user-1", entity.ModelTypeChat, "model-1")
+ target, err := NewModelFactory().resolveConfig(ctx, ModelAccess{TenantID: "tenant-1", UserID: "user-1"}, entity.ModelTypeChat, "model-1")
if err != nil {
- t.Fatalf("ResolveModelConfig() error = %v", err)
+ t.Fatalf("resolveConfig() error = %v", err)
}
if target == nil || target.Driver == nil {
- t.Fatal("ResolveModelConfig() returned nil target or driver")
+ t.Fatal("resolveConfig() returned nil target or driver")
}
if target.ModelName != "gpt-test" {
t.Fatalf("modelName = %q, want %q", target.ModelName, "gpt-test")
@@ -475,14 +485,14 @@ func TestModelProviderServiceMissingProviderAndInstancePreserveLookupError(t *te
"unknown@default@OpenAI",
} {
t.Run(modelRef, func(t *testing.T) {
- _, err := NewModelSolver().ResolveModelConfig(
- t.Context(), "tenant-1", entity.ModelTypeEmbedding, modelRef,
+ _, err := NewModelFactory().resolveConfig(
+ t.Context(), ModelAccess{TenantID: "tenant-1"}, entity.ModelTypeEmbedding, modelRef,
)
if !errors.Is(err, errModelConfigUnavailable) || !errors.Is(err, gorm.ErrRecordNotFound) {
- t.Fatalf("ResolveModelConfig() error = %v, want unavailable record-not-found error", err)
+ t.Fatalf("resolveConfig() error = %v, want unavailable record-not-found error", err)
}
if !strings.Contains(err.Error(), "lookup failed: record not found") {
- t.Fatalf("ResolveModelConfig() error = %q, want lookup failure contract", err)
+ t.Fatalf("resolveConfig() error = %q, want lookup failure contract", err)
}
})
}
@@ -495,21 +505,21 @@ func TestModelProviderServiceDecodesCompatibleInstanceExtra(t *testing.T) {
useModelProviderServiceTestDB(t, db)
seedModelProviderServiceScope(t, db)
- solver := NewModelSolver()
+ solver := NewModelFactory()
resolvers := []struct {
name string
- resolve func() (*ModelTarget, error)
+ resolve func() (*modelTarget, error)
}{
{
name: "model ID",
- resolve: func() (*ModelTarget, error) {
- return solver.ResolveModelConfig(t.Context(), "user-1", entity.ModelTypeChat, "model-1")
+ resolve: func() (*modelTarget, error) {
+ return solver.resolveConfig(t.Context(), ModelAccess{TenantID: "tenant-1", UserID: "user-1"}, entity.ModelTypeChat, "model-1")
},
},
{
name: "provider instance",
- resolve: func() (*ModelTarget, error) {
- return solver.ResolveModelConfig(t.Context(), "tenant-1", entity.ModelTypeChat, "gpt-test@default@OpenAI")
+ resolve: func() (*modelTarget, error) {
+ return solver.resolveConfig(t.Context(), ModelAccess{TenantID: "tenant-1"}, entity.ModelTypeChat, "gpt-test@default@OpenAI")
},
},
}
@@ -552,18 +562,17 @@ func TestModelProviderServiceDecodesCompatibleInstanceExtra(t *testing.T) {
}
}
-func TestMaxTokensFromModelInfo(t *testing.T) {
- maxTokens := 4096
+func TestModelInfoSeparatesContextLengthAndMaxOutput(t *testing.T) {
+ legacyMaxTokens := 4096
maxOutput := 1024
- modelInfo := &modelModule.Model{MaxTokens: &maxTokens, MaxOutput: &maxOutput}
- if got := maxTokensFromModelInfo(modelInfo, entity.ModelTypeRerank); got != maxTokens {
- t.Fatalf("rerank max tokens = %d, want %d", got, maxTokens)
- }
- if got := maxTokensFromModelInfo(modelInfo, entity.ModelTypeEmbedding); got != maxTokens {
- t.Fatalf("embedding max tokens = %d, want %d", got, maxTokens)
+ modelInfo := &modelModule.Model{MaxTokens: &legacyMaxTokens, MaxOutput: &maxOutput}
+ for _, modelType := range []entity.ModelType{entity.ModelTypeChat, entity.ModelTypeEmbedding, entity.ModelTypeRerank} {
+ if got := contextLengthFromModelInfo(modelInfo); got != legacyMaxTokens {
+ t.Errorf("context length for %s = %d, want legacy max_tokens %d", modelType, got, legacyMaxTokens)
+ }
}
- if got := maxTokensFromModelInfo(modelInfo, entity.ModelTypeChat); got != maxOutput {
- t.Fatalf("chat max tokens = %d, want max output %d", got, maxOutput)
+ if got := maxOutputFromModelInfo(modelInfo); got != maxOutput {
+ t.Fatalf("max output = %d, want %d", got, maxOutput)
}
}
@@ -757,10 +766,10 @@ func TestSplitRightAnchoredModelName(t *testing.T) {
}
}
-// TestModelSolverResolveModelConfigReportsToolSupport verifies that the
+// TestModelFactoryResolveModelConfigReportsToolSupport verifies that the
// resolved target carries tool support and invalid references fail during the
// same resolution.
-func TestModelSolverResolveModelConfigReportsToolSupport(t *testing.T) {
+func TestModelFactoryResolveModelConfigReportsToolSupport(t *testing.T) {
db := setupModelProviderServiceTestDB(t)
useModelProviderServiceTestDB(t, db)
activeStatus := "1"
@@ -781,12 +790,11 @@ func TestModelSolverResolveModelConfigReportsToolSupport(t *testing.T) {
}
}
- svc := NewModelProviderService()
- solver := svc.modelSolver()
+ solver := NewModelFactory()
ctx := t.Context()
// A reference that passes validation still reads the persisted flag.
- target, err := solver.ResolveModelConfig(ctx, "tenant-1", entity.ModelTypeChat, "model-active")
+ target, err := solver.resolveConfig(ctx, ModelAccess{TenantID: "tenant-1"}, entity.ModelTypeChat, "model-active")
if err != nil || target == nil || !target.SupportsTools {
t.Fatalf("active chat model = (%v, %v), want tool support", target, err)
}
@@ -799,7 +807,7 @@ func TestModelSolverResolveModelConfigReportsToolSupport(t *testing.T) {
{"not enrolled as chat", "model-embedding"},
{"provider owned by another tenant", "model-foreign"},
} {
- target, err := solver.ResolveModelConfig(ctx, "tenant-1", entity.ModelTypeChat, tc.modelID)
+ target, err := solver.resolveConfig(ctx, ModelAccess{TenantID: "tenant-1"}, entity.ModelTypeChat, tc.modelID)
if err == nil {
t.Errorf("%s: err = nil, want a validation error", tc.name)
}
@@ -809,13 +817,13 @@ func TestModelSolverResolveModelConfigReportsToolSupport(t *testing.T) {
}
}
-// TestModelSolverResolveModelConfigPrefersTenantToolFlag covers the
+// TestModelFactoryResolveModelConfigPrefersTenantToolFlag covers the
// composite "<model>@<instance>@<provider>" reference shape (chat.llm_id and the
// harness ModelID accept both a UUID and a composite ref): the flag persisted on
// the tenant_model row must beat the provider catalog in both directions,
// mirroring Python's model_extra.get("is_tools", is_tool), and a disabled row
// must be rejected instead of falling back to the catalog.
-func TestModelSolverResolveModelConfigPrefersTenantToolFlag(t *testing.T) {
+func TestModelFactoryResolveModelConfigPrefersTenantToolFlag(t *testing.T) {
catalog := dao.GetModelProviderManager().FindProvider("OpenAI")
if catalog == nil {
t.Skip("OpenAI catalog is unavailable")
@@ -857,11 +865,10 @@ func TestModelSolverResolveModelConfigPrefersTenantToolFlag(t *testing.T) {
}
}
- svc := NewModelProviderService()
- solver := svc.modelSolver()
+ solver := NewModelFactory()
ctx := t.Context()
- target, err := solver.ResolveModelConfig(ctx, "tenant-1", entity.ModelTypeChat, toolsOn+"@default@OpenAI")
+ target, err := solver.resolveConfig(ctx, ModelAccess{TenantID: "tenant-1"}, entity.ModelTypeChat, toolsOn+"@default@OpenAI")
if err != nil {
t.Fatalf("tool-capable model: err = %v", err)
}
@@ -869,7 +876,7 @@ func TestModelSolverResolveModelConfigPrefersTenantToolFlag(t *testing.T) {
t.Errorf("tool support = true, want false: the tenant_model flag must win over the catalog")
}
- target, err = solver.ResolveModelConfig(ctx, "tenant-1", entity.ModelTypeChat, toolsOff+"@default@OpenAI")
+ target, err = solver.resolveConfig(ctx, ModelAccess{TenantID: "tenant-1"}, entity.ModelTypeChat, toolsOff+"@default@OpenAI")
if err != nil {
t.Fatalf("tool-incapable model: err = %v", err)
}
@@ -877,15 +884,15 @@ func TestModelSolverResolveModelConfigPrefersTenantToolFlag(t *testing.T) {
t.Errorf("tool support = false, want true: the tenant_model flag must win over the catalog")
}
- target, err = solver.ResolveModelConfig(ctx, "tenant-1", entity.ModelTypeChat, toolsOn+"-disabled@default@OpenAI")
+ target, err = solver.resolveConfig(ctx, ModelAccess{TenantID: "tenant-1"}, entity.ModelTypeChat, toolsOn+"-disabled@default@OpenAI")
if err == nil || (target != nil && target.SupportsTools) {
t.Errorf("disabled model = (%v, %v), want (false, error)", target, err)
}
}
-// TestModelSolverResolveModelConfigPropagatesLookupFailure verifies that model
+// TestModelFactoryResolveModelConfigPropagatesLookupFailure verifies that model
// resolution surfaces database failures instead of returning a partial target.
-func TestModelSolverResolveModelConfigPropagatesLookupFailure(t *testing.T) {
+func TestModelFactoryResolveModelConfigPropagatesLookupFailure(t *testing.T) {
db := setupModelProviderServiceTestDB(t)
useModelProviderServiceTestDB(t, db)
activeStatus := "1"
@@ -901,10 +908,9 @@ func TestModelSolverResolveModelConfigPropagatesLookupFailure(t *testing.T) {
}
}
- svc := NewModelProviderService()
- solver := svc.modelSolver()
+ solver := NewModelFactory()
ctx := t.Context()
- if target, err := solver.ResolveModelConfig(ctx, "tenant-1", entity.ModelTypeChat, "model-1"); err != nil || target == nil || !target.SupportsTools {
+ if target, err := solver.resolveConfig(ctx, ModelAccess{TenantID: "tenant-1"}, entity.ModelTypeChat, "model-1"); err != nil || target == nil || !target.SupportsTools {
t.Fatalf("baseline = (%v, %v), want tool support", target, err)
}
@@ -915,11 +921,11 @@ func TestModelSolverResolveModelConfigPropagatesLookupFailure(t *testing.T) {
t.Fatalf("failed to drop provider table: %v", err)
}
// Composite refs resolve the provider row directly.
- if target, err := solver.ResolveModelConfig(ctx, "tenant-1", entity.ModelTypeChat, "gpt-test@default@OpenAI"); err == nil {
+ if target, err := solver.resolveConfig(ctx, ModelAccess{TenantID: "tenant-1"}, entity.ModelTypeChat, "gpt-test@default@OpenAI"); err == nil {
t.Errorf("composite provider lookup failure = (%v, nil), want a propagated error", target)
}
// The UUID path too.
- if target, err := solver.ResolveModelConfig(ctx, "tenant-1", entity.ModelTypeChat, "model-1"); err == nil {
+ if target, err := solver.resolveConfig(ctx, ModelAccess{TenantID: "tenant-1"}, entity.ModelTypeChat, "model-1"); err == nil {
t.Errorf("uuid provider lookup failure = (%v, nil), want a propagated error", target)
}
@@ -927,7 +933,7 @@ func TestModelSolverResolveModelConfigPropagatesLookupFailure(t *testing.T) {
if err := db.Migrator().DropTable(&entity.TenantModel{}); err != nil {
t.Fatalf("failed to drop model table: %v", err)
}
- if target, err := solver.ResolveModelConfig(ctx, "tenant-1", entity.ModelTypeChat, "model-1"); err == nil {
+ if target, err := solver.resolveConfig(ctx, ModelAccess{TenantID: "tenant-1"}, entity.ModelTypeChat, "model-1"); err == nil {
t.Errorf("model lookup failure = (%v, nil), want a propagated error", target)
}
}
diff --git a/internal/service/model_service_tts_test.go b/internal/service/model_service_tts_test.go
index 9f7a2526ae..17cc57c79f 100644
--- a/internal/service/model_service_tts_test.go
+++ b/internal/service/model_service_tts_test.go
@@ -78,7 +78,7 @@ func TestResolveDefaultModelConfig_NilTTSPointer(t *testing.T) {
pushServiceDB(t, testDB)
insertTTSTestTenant(t, "tenant-2", nil)
- _, err := NewModelSolver().ResolveDefaultModelConfig(t.Context(), "tenant-2", entity.ModelTypeTTS)
+ _, err := NewModelFactory().resolveDefaultConfig(t.Context(), ModelAccess{TenantID: "tenant-2"}, entity.ModelTypeTTS)
if err == nil {
t.Fatal("expected error for nil tts_id, got nil")
}
diff --git a/internal/service/model_solver.go b/internal/service/model_solver.go
deleted file mode 100644
index 9e539d51cc..0000000000
--- a/internal/service/model_solver.go
+++ /dev/null
@@ -1,907 +0,0 @@
-//
-// 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.
-//
-
-package service
-
-import (
- "context"
- "encoding/json"
- "errors"
- "fmt"
- "strings"
-
- "gorm.io/gorm"
-
- "ragflow/internal/common"
- "ragflow/internal/dao"
- "ragflow/internal/entity"
- modelModule "ragflow/internal/entity/models"
-)
-
-// ModelTarget contains the resolved model configuration.
-// It is intentionally separate from the runtime ChatConfig, EmbeddingConfig,
-// and RerankConfig types. ModelTarget is selected by modelRef and carries the
-// provider-side objects needed to make a model call.
-type ModelTarget struct {
- ModelID string
- ModelName string
- ModelType entity.ModelType
- ProviderName string
- InstanceID string
- InstanceName string
- Driver modelModule.ModelDriver
- APIConfig *modelModule.APIConfig
- ModelInfo *modelModule.Model
- ContextLength int
- MaxTokens int
- SupportsTools bool
-}
-
-// ModelSolver is the new model-resolution entry point. The existing
-// ModelProviderService API remains untouched so callers can migrate to this
-// resolver independently.
-type ModelSolver struct {
- service *ModelProviderService
-}
-
-// NewModelSolver creates a model resolver backed by the standard model
-// provider service.
-func NewModelSolver() *ModelSolver {
- return &ModelSolver{service: NewModelProviderService()}
-}
-
-// modelInstanceExtra contains the instance fields consumed during model
-// resolution. Other provider-specific fields remain valid and are ignored.
-type modelInstanceExtra struct {
- Region string `json:"region"`
- BaseURL string `json:"base_url"`
-}
-
-// decodeModelInstanceExtra reads only the endpoint fields used for model
-// resolution, allowing existing rows to retain provider-specific JSON values.
-func decodeModelInstanceExtra(raw string) (modelInstanceExtra, error) {
- if strings.TrimSpace(raw) == "" {
- return modelInstanceExtra{}, nil
- }
-
- var extra modelInstanceExtra
- if err := json.Unmarshal([]byte(raw), &extra); err != nil {
- return modelInstanceExtra{}, err
- }
- return extra, nil
-}
-
-// parseModelName parses a composite model name in format "model@instance@provider" or "model@provider"
-// Returns modelName, instanceName, providerName separately.
-//
-// The composite key is right-anchored: providerName is always the *last*
-// '@'-separated field, instanceName is the second-to-last (when present),
-// and everything to the left is the bare model name. Some model names
-// legitimately contain '@' characters themselves (e.g. LM Studio embedding
-// model IDs such as `text-embedding-nomic-embed-text-v1.5@q8_0`), which
-// produces composite keys like
-// `text-embedding-nomic-embed-text-v1.5@q8_0@lmstudio@LM-Studio`. When the
-// split yields more than 3 fields we rejoin the leading fields back into the
-// modelName so any embedded '@' characters are preserved verbatim.
-func parseModelName(compositeName string) (modelName, instanceName, providerName string, err error) {
- parts := strings.Split(compositeName, "@")
- switch len(parts) {
- case 3:
- // Format: model@instance@provider
- return parts[0], parts[1], parts[2], nil
- case 2:
- // Format: model@provider -> instance defaults to "default"
- return parts[0], "default", parts[1], nil
- case 1:
- return parts[0], "", "", fmt.Errorf("provider name missing in model name: %s", compositeName)
- }
- // len(parts) > 3: any '@' characters embedded in the leftmost modelName
- // component must be preserved in that component instead of being dropped
- // or assigned to the instance/provider fields.
- n := len(parts)
- return strings.Join(parts[:n-2], "@"), parts[n-2], parts[n-1], nil
-}
-
-// splitRightAnchoredModelName is a bare-name-tolerant variant of
-// parseModelName used by the Builtin / TEI short-circuit branches in
-// model resolution.
-//
-// Those branches must accept a bare model name (no provider suffix) where
-// parseModelName would return an error, while still preserving any '@'
-// characters embedded in the modelName portion of a multi-segment key.
-// Returns the modelName, instanceName ("default" for the 2-segment form),
-// and providerName ("" for the 1-segment form).
-func splitRightAnchoredModelName(compositeName string) (modelName, instanceName, providerName string) {
- parts := strings.Split(compositeName, "@")
- switch len(parts) {
- case 3:
- return parts[0], parts[1], parts[2]
- case 2:
- // The 2-segment form "model@X" is ambiguous: X could be a provider
- // suffix (only "Builtin" is recognised by the TEI / Builtin
- // short-circuits that consume this helper) or part of the model
- // name itself (e.g. a quantization tag like "q8_0" in
- // "text-embedding-nomic-embed-text-v1.5@q8_0"). Treat the last
- // token as a provider only when it actually is one; otherwise
- // the whole string is the bare model name and the caller falls
- // through to its non-short-circuit path. The TEI short-circuit's
- // `modelName == teiModel` exact-match fast path already covers
- // the bare-default case where the embedded '@' happens to match
- // the TEI model identifier verbatim.
- if parts[1] == "Builtin" {
- return parts[0], "default", parts[1]
- }
- return compositeName, "", ""
- case 1:
- return parts[0], "", ""
- }
- n := len(parts)
- return strings.Join(parts[:n-2], "@"), parts[n-2], parts[n-1]
-}
-
-type tenantModelExtra struct {
- MaxTokens *int `json:"max_tokens"`
- ModelTypes []string `json:"model_types"`
- MaxDimension *int `json:"max_dimension"`
- MaxBatchSize *int `json:"max_batch_size"`
- Dimensions []int `json:"dimensions"`
- Thinking *bool `json:"thinking"`
-}
-
-func modelInfoWithTenantExtra(modelInfo *modelModule.Model, modelEntity *entity.TenantModel) (*modelModule.Model, error) {
- if modelInfo == nil || modelEntity == nil || strings.TrimSpace(modelEntity.Extra) == "" {
- return modelInfo, nil
- }
-
- var extra tenantModelExtra
- if err := json.Unmarshal([]byte(modelEntity.Extra), &extra); err != nil {
- return nil, err
- }
-
- model := *modelInfo
- model.ModelTypes = append([]string(nil), modelInfo.ModelTypes...)
- model.Dimensions = append([]int(nil), modelInfo.Dimensions...)
- model.Alias = append([]string(nil), modelInfo.Alias...)
- if modelInfo.ModelTypeMap != nil {
- model.ModelTypeMap = make(map[string]bool, len(modelInfo.ModelTypeMap))
- for modelType, enabled := range modelInfo.ModelTypeMap {
- model.ModelTypeMap[modelType] = enabled
- }
- }
- if modelInfo.Thinking != nil {
- thinking := *modelInfo.Thinking
- model.Thinking = &thinking
- }
-
- if extra.MaxTokens != nil && *extra.MaxTokens > 0 {
- model.MaxOutput = extra.MaxTokens
- model.MaxTokens = extra.MaxTokens
- }
- if len(extra.ModelTypes) > 0 {
- model.ModelTypes = append([]string(nil), extra.ModelTypes...)
- model.ModelTypeMap = make(map[string]bool, len(extra.ModelTypes))
- for _, modelType := range extra.ModelTypes {
- model.ModelTypeMap[modelType] = true
- }
- }
- if extra.MaxDimension != nil && *extra.MaxDimension > 0 {
- model.MaxDimension = extra.MaxDimension
- }
- if extra.MaxBatchSize != nil && *extra.MaxBatchSize > 0 {
- model.MaxBatchSize = extra.MaxBatchSize
- }
- if len(extra.Dimensions) > 0 {
- model.Dimensions = append([]int(nil), extra.Dimensions...)
- }
- if extra.Thinking != nil {
- if model.Thinking == nil {
- model.Thinking = &modelModule.ModelThinking{}
- }
- model.Thinking.DefaultValue = *extra.Thinking
- }
-
- return &model, nil
-}
-
-func maxTokensFromTenantModelExtra(modelEntity *entity.TenantModel, fallback int) (int, error) {
- if modelEntity == nil || strings.TrimSpace(modelEntity.Extra) == "" {
- return fallback, nil
- }
- var extra tenantModelExtra
- if err := json.Unmarshal([]byte(modelEntity.Extra), &extra); err != nil {
- return 0, err
- }
- if extra.MaxTokens != nil && *extra.MaxTokens > 0 {
- return *extra.MaxTokens, nil
- }
- return fallback, nil
-}
-
-func maxTokensFromModelInfo(modelInfo *modelModule.Model, modelType entity.ModelType) int {
- if modelInfo == nil {
- return 0
- }
- if (modelType == entity.ModelTypeEmbedding || modelType == entity.ModelTypeRerank) && modelInfo.MaxTokens != nil {
- return *modelInfo.MaxTokens
- }
- if modelInfo.MaxOutput != nil {
- return *modelInfo.MaxOutput
- }
- return 0
-}
-
-// modelTargetRef renders a resolved model as the lookups' reference: its
-// tenant_model id, or the composite "model@instance@provider" form.
-func modelTargetRef(target *ModelTarget) string {
- if target == nil {
- return ""
- }
- if target.ModelID != "" {
- return target.ModelID
- }
- return fmt.Sprintf("%s@%s@%s", target.ModelName, target.InstanceName, target.ProviderName)
-}
-
-// tenantCanReachProviderTenant reports whether userID owns the provider's tenant
-// or is a joined member of it. Mirrors Python's tenant_model_service
-// get_model_config_by_id tenant check (:342-347).
-func (s *ModelSolver) tenantCanReachProviderTenant(ctx context.Context, userID, ownerTenantID string) (bool, error) {
- if userID == ownerTenantID {
- return true, nil
- }
- userTenants, err := NewUserTenantService().GetUserTenantRelationByUserIDWithContext(ctx, userID)
- if err != nil {
- return false, err
- }
- for _, rel := range userTenants {
- if rel != nil && rel.TenantID == ownerTenantID {
- return true, nil
- }
- }
- return false, nil
-}
-
-func (m *ModelProviderService) modelSolver() *ModelSolver {
- return &ModelSolver{service: m}
-}
-
-// ResolveModelConfig resolves a model by modelRef for the requested modelType.
-// modelRef accepts either a tenant model ID or a composite reference in the
-// form "model@instance@provider" ("model@provider" also uses the default
-// instance).
-func (s *ModelSolver) ResolveModelConfig(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string) (*ModelTarget, error) {
- modelRef = strings.TrimSpace(modelRef)
- if modelRef == "" {
- return nil, fmt.Errorf("%w: model ref is required", errModelConfigUnavailable)
- }
- if modelType == 0 {
- return nil, fmt.Errorf("%w: model type is required", errModelConfigUnavailable)
- }
-
- model, err := s.resolveModel(ctx, tenantID, modelType, modelRef)
- if err != nil {
- return nil, err
- }
-
- maxTokens := model.maxTokens
- if model.modelEntity != nil {
- maxTokens = maxTokensFromModelInfo(model.modelInfo, modelType)
- maxTokens, err = maxTokensFromTenantModelExtra(model.modelEntity, maxTokens)
- if err != nil {
- return nil, fmt.Errorf("%w: read model limits: %v", errModelConfigUnavailable, err)
- }
- }
-
- contextLength := 0
- if model.modelInfo != nil && model.modelInfo.ContextLength != nil {
- contextLength = *model.modelInfo.ContextLength
- }
- if resolved := dao.ResolveModelContentLength(ctx, dao.DB, tenantID, modelRef, "", ""); resolved > 0 {
- contextLength = resolved
- }
-
- return &ModelTarget{
- ModelID: model.modelID,
- ModelName: model.modelName,
- ModelType: modelType,
- ProviderName: model.providerEntity.ProviderName,
- InstanceID: model.instanceID,
- InstanceName: model.instanceName,
- Driver: model.driver,
- APIConfig: model.apiConfig,
- ModelInfo: model.modelInfo,
- ContextLength: contextLength,
- MaxTokens: maxTokens,
- SupportsTools: model.supportsTools(),
- }, nil
-}
-
-// ResolveChatModelType returns the output type used by the chat pipeline for
-// attachment dispatch. A model enrolled as both chat and image2text is rendered
-// as image2text so image content can be passed to it; a chat-only model remains
-// chat. An image2text-only enrollment remains chat here so ResolveModelConfig
-// can reject it as an invalid chat model before this display type is used.
-//
-// Probe failures are conservative and yield chat: that is the type a plain chat
-// model is enrolled as, and it keeps image attachments out of a model whose
-// vision support could not be established.
-func (s *ModelSolver) ResolveChatModelType(ctx context.Context, tenantID, modelRef string) entity.ModelType {
- if s == nil || strings.TrimSpace(modelRef) == "" {
- return entity.ModelTypeChat
- }
- modelTypes, err := s.ResolveModelType(ctx, tenantID, modelRef)
- if err != nil {
- return entity.ModelTypeChat
- }
- hasChat := false
- hasImage2Text := false
- for _, mt := range modelTypes {
- hasChat = hasChat || mt.Has(entity.ModelTypeChat)
- hasImage2Text = hasImage2Text || mt.Has(entity.ModelTypeImage2Text)
- }
- if hasChat && hasImage2Text {
- return entity.ModelTypeImage2Text
- }
- return entity.ModelTypeChat
-}
-
-// ResolveDefaultModelConfig resolves the tenant's configured default model
-// for modelType. It first uses the tenant model ID when present and falls back
-// to the stored model reference if that ID is unavailable.
-func (s *ModelSolver) ResolveDefaultModelConfig(ctx context.Context, tenantID string, modelType entity.ModelType) (*ModelTarget, error) {
- if s == nil || s.service == nil {
- return nil, fmt.Errorf("%w: model solver is not initialized", errModelConfigUnavailable)
- }
- tenantID = strings.TrimSpace(tenantID)
- if tenantID == "" {
- return nil, fmt.Errorf("%w: tenant id is required", errModelConfigUnavailable)
- }
- if modelType == 0 {
- return nil, fmt.Errorf("%w: model type is required", errModelConfigUnavailable)
- }
- if modelType == entity.ModelTypeOCR {
- return nil, fmt.Errorf("OCR model name is required")
- }
- if s.service.tenantDAO == nil {
- return nil, fmt.Errorf("%w: tenant service is not initialized", errModelConfigUnavailable)
- }
-
- tenant, err := s.service.tenantDAO.GetByID(ctx, dao.DB, tenantID)
- if err != nil {
- return nil, fmt.Errorf("failed to get tenant: %s type %s: %w", tenantID, modelType, err)
- }
- modelName, modelID := defaultModelRefs(tenant, modelType)
- if modelID != "" {
- if target, idErr := s.ResolveModelConfig(ctx, tenantID, modelType, modelID); idErr == nil {
- return target, nil
- }
- }
- if strings.TrimSpace(modelName) == "" {
- return nil, fmt.Errorf("no default %s model is set", modelType)
- }
- return s.ResolveModelConfig(ctx, tenantID, modelType, modelName)
-}
-
-func defaultModelRefs(tenant *entity.Tenant, modelType entity.ModelType) (string, string) {
- if tenant == nil {
- return "", ""
- }
- switch modelType {
- case entity.ModelTypeChat:
- return tenant.LLMID, ptrStringValue(tenant.TenantLLMID)
- case entity.ModelTypeEmbedding:
- return tenant.EmbdID, ptrStringValue(tenant.TenantEmbdID)
- case entity.ModelTypeRerank:
- return tenant.RerankID, ptrStringValue(tenant.TenantRerankID)
- case entity.ModelTypeSpeech2Text:
- return tenant.ASRID, ptrStringValue(tenant.TenantASRID)
- case entity.ModelTypeImage2Text:
- return tenant.Img2TxtID, ptrStringValue(tenant.TenantImg2TxtID)
- case entity.ModelTypeTTS:
- return ptrStringValue(tenant.TTSID), ptrStringValue(tenant.TenantTTSID)
- case entity.ModelTypeOCR:
- return ptrStringValue(tenant.OCRID), ptrStringValue(tenant.TenantOCRID)
- default:
- return "", ""
- }
-}
-
-// ResolveModelType returns every model category supported by modelRef. A
-// model may expose multiple categories, such as chat and vision.
-func (s *ModelSolver) ResolveModelType(ctx context.Context, tenantID, modelRef string) ([]entity.ModelType, error) {
- modelRef = strings.TrimSpace(modelRef)
- if modelRef == "" {
- return nil, fmt.Errorf("%w: model ref is required", errModelConfigUnavailable)
- }
-
- model, err := s.lookupTenantModel(ctx, tenantID, modelRef)
- if err == nil {
- identity, identityErr := s.modelIdentity(ctx, tenantID, model, modelRef)
- if identityErr != nil {
- return nil, identityErr
- }
- return modelTypesFromBitmask(identity.modelType), nil
- }
- if !errors.Is(err, gorm.ErrRecordNotFound) {
- return nil, err
- }
-
- modelType, err := s.resolveCompositeModelType(ctx, tenantID, modelRef)
- if err != nil {
- return nil, err
- }
- return modelTypesFromBitmask(modelType), nil
-}
-
-type modelIdentity struct {
- modelEntity *entity.TenantModel
- providerEntity *entity.TenantModelProvider
- modelType entity.ModelType
-}
-
-type resolvedModel struct {
- modelEntity *entity.TenantModel
- providerEntity *entity.TenantModelProvider
- modelInfo *modelModule.Model
- modelType entity.ModelType
- modelID string
- modelName string
- instanceID string
- instanceName string
- driver modelModule.ModelDriver
- apiConfig *modelModule.APIConfig
- maxTokens int
-}
-
-// supportsTools reports whether the resolved model can emit tool calls. The
-// enrollment flag takes precedence over the instance credential and provider
-// catalog defaults.
-//
-// It is a method on the resolution rather than a separate lookup so that the
-// capability is answered by the row that was just loaded, instead of by a second
-// lookup the caller has to key on a type it may get wrong (see
-// ResolveChatModelType).
-func (m *resolvedModel) supportsTools() bool {
- if m == nil {
- return false
- }
- var extra, providerName, modelName, instanceAPIKey string
- if m.modelEntity != nil {
- extra = m.modelEntity.Extra
- modelName = m.modelEntity.ModelName
- }
- if m.providerEntity != nil {
- providerName = m.providerEntity.ProviderName
- }
- if modelName == "" {
- modelName = m.modelName
- }
- if m.apiConfig != nil && m.apiConfig.ApiKey != nil {
- instanceAPIKey = *m.apiConfig.ApiKey
- }
- return toolSupportFromEnrollment(extra, instanceAPIKey, providerName, modelName)
-}
-
-func toolSupportFromEnrollment(extra, instanceAPIKey, providerName, modelName string) bool {
- if supported, ok := extraToolSupport(extra); ok {
- return supported
- }
- if supported, ok := extraToolSupport(instanceAPIKey); ok {
- return supported
- }
- return catalogToolSupport(providerName, modelName)
-}
-
-func extraToolSupport(extra string) (bool, bool) {
- if strings.TrimSpace(extra) == "" {
- return false, false
- }
- var fields map[string]any
- if err := json.Unmarshal([]byte(extra), &fields); err != nil {
- return false, false
- }
- value, ok := fields["is_tools"]
- if !ok {
- return false, false
- }
- switch value := value.(type) {
- case bool:
- return value, true
- case string:
- return strings.EqualFold(strings.TrimSpace(value), "true"), true
- case float64:
- return value != 0, true
- default:
- return false, false
- }
-}
-
-func catalogToolSupport(providerName, modelName string) bool {
- providerManager := dao.GetModelProviderManager()
- provider := providerManager.FindProvider(providerName)
- if provider == nil {
- return false
- }
- model := providerManager.FindModel(provider, modelName)
- return model != nil && model.Tools != nil && model.Tools.Support
-}
-
-func (s *ModelSolver) lookupTenantModel(ctx context.Context, tenantID, modelRef string) (*entity.TenantModel, error) {
- if s == nil || s.service == nil {
- return nil, fmt.Errorf("%w: model solver is not initialized", errModelConfigUnavailable)
- }
- tenantID = strings.TrimSpace(tenantID)
- if tenantID == "" {
- return nil, fmt.Errorf("%w: tenant id is required", errModelConfigUnavailable)
- }
- if modelRef == "" {
- return nil, fmt.Errorf("%w: model ref is required", errModelConfigUnavailable)
- }
- if s.service.modelDAO == nil {
- return nil, fmt.Errorf("%w: model service is not initialized", errModelConfigUnavailable)
- }
-
- return s.service.modelDAO.GetByID(ctx, dao.DB, modelRef)
-}
-
-func (s *ModelSolver) modelIdentity(ctx context.Context, tenantID string, modelEntity *entity.TenantModel, modelRef string) (*modelIdentity, error) {
- if modelEntity == nil {
- return nil, fmt.Errorf("%w: tenant model %q not found", errModelConfigUnavailable, modelRef)
- }
- if modelEntity.Status != "active" {
- return nil, fmt.Errorf("%w: tenant model %q is disabled", errModelConfigUnavailable, modelRef)
- }
-
- modelType := entity.ModelType(modelEntity.ModelType)
- if modelType == 0 {
- return nil, fmt.Errorf("%w: tenant model %q has no model type", errModelConfigUnavailable, modelRef)
- }
- if s.service.modelProviderDAO == nil || s.service.modelInstanceDAO == nil {
- return nil, fmt.Errorf("%w: model service is not initialized", errModelConfigUnavailable)
- }
-
- providerEntity, err := s.service.modelProviderDAO.GetByID(ctx, dao.DB, modelEntity.ProviderID)
- if err != nil {
- if errors.Is(err, gorm.ErrRecordNotFound) {
- return nil, fmt.Errorf("%w: provider id=%s not found for model %q", errModelConfigUnavailable, modelEntity.ProviderID, modelRef)
- }
- return nil, err
- }
- if providerEntity == nil {
- return nil, fmt.Errorf("%w: provider id=%s not found for model %q", errModelConfigUnavailable, modelEntity.ProviderID, modelRef)
- }
-
- allowed, err := s.tenantCanReachProviderTenant(ctx, tenantID, providerEntity.TenantID)
- if err != nil {
- return nil, err
- }
- if !allowed {
- return nil, fmt.Errorf(
- "%w: tenant %s has no access to provider owned by tenant %s",
- errModelConfigUnavailable,
- tenantID,
- providerEntity.TenantID,
- )
- }
-
- return &modelIdentity{
- modelEntity: modelEntity,
- providerEntity: providerEntity,
- modelType: modelType,
- }, nil
-}
-
-func (s *ModelSolver) resolveModel(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string) (*resolvedModel, error) {
- modelEntity, err := s.lookupTenantModel(ctx, tenantID, modelRef)
- if err != nil {
- if errors.Is(err, gorm.ErrRecordNotFound) {
- // A bare ref that is BOTH unknown as a tenant model id AND rejected as
- // a composite name is almost always a DANGLING REFERENCE — a knowledge
- // base or chat pointing at a tenant_model row that was deleted. Say so
- // explicitly: the underlying "provider name missing in model name:
- // <uuid>" reads like a naming-format mistake and sends the operator to
- // look at the model's name instead of at the row that no longer exists.
- composite, compositeErr := s.resolveCompositeModel(ctx, tenantID, modelType, modelRef)
- if compositeErr != nil && !strings.Contains(modelRef, "@") {
- return nil, fmt.Errorf("model %q is neither a tenant model id (no tenant_model row) nor a valid composite name — the reference is dangling: %w", modelRef, compositeErr)
- }
- return composite, compositeErr
- }
- return nil, err
- }
- identity, err := s.modelIdentity(ctx, tenantID, modelEntity, modelRef)
- if err != nil {
- return nil, err
- }
- if !identity.modelType.Has(modelType) {
- return nil, fmt.Errorf("%w: tenant model %q cannot be used as %s model", errModelConfigUnavailable, modelRef, modelType.String())
- }
- return s.resolveTenantModel(ctx, tenantID, modelType, modelRef, identity)
-}
-
-func (s *ModelSolver) resolveTenantModel(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string, identity *modelIdentity) (*resolvedModel, error) {
- modelEntity := identity.modelEntity
- providerEntity := identity.providerEntity
-
- instanceEntity, err := s.service.modelInstanceDAO.GetByID(ctx, dao.DB, modelEntity.InstanceID)
- if err != nil {
- if errors.Is(err, gorm.ErrRecordNotFound) {
- return nil, fmt.Errorf("%w: instance id=%s not found for model %q", errModelConfigUnavailable, modelEntity.InstanceID, modelRef)
- }
- return nil, err
- }
- if instanceEntity == nil {
- return nil, fmt.Errorf("%w: instance id=%s not found for model %q", errModelConfigUnavailable, modelEntity.InstanceID, modelRef)
- }
-
- providerInfo := dao.GetModelProviderManager().FindProvider(providerEntity.ProviderName)
- if providerInfo == nil {
- return nil, fmt.Errorf("%w: provider %q driver not found", errModelConfigUnavailable, providerEntity.ProviderName)
- }
-
- modelInfo, _ := dao.GetModelProviderManager().GetModelByName(providerEntity.ProviderName, modelEntity.ModelName)
- if modelInfo != nil {
- modelInfo, err = modelInfoWithTenantExtra(modelInfo, modelEntity)
- if err != nil {
- return nil, fmt.Errorf("%w: read model metadata: %v", errModelConfigUnavailable, err)
- }
- }
-
- extra, err := decodeModelInstanceExtra(instanceEntity.Extra)
- if err != nil {
- return nil, fmt.Errorf("%w: decode model instance configuration: %v", errModelConfigUnavailable, err)
- }
- apiKey := instanceEntity.APIKey
- region := extra.Region
- baseURL := extra.BaseURL
- driver, err := newModelDriverForBaseURL(providerInfo.ModelDriver, providerEntity.ProviderName, region, baseURL)
- if err != nil {
- return nil, fmt.Errorf("%w: create model driver: %v", errModelConfigUnavailable, err)
- }
-
- return &resolvedModel{
- modelEntity: modelEntity,
- providerEntity: providerEntity,
- modelInfo: modelInfo,
- modelType: modelType,
- modelID: modelEntity.ID,
- modelName: modelEntity.ModelName,
- instanceID: instanceEntity.ID,
- instanceName: instanceEntity.InstanceName,
- driver: driver,
- apiConfig: &modelModule.APIConfig{ApiKey: &apiKey, Region: &region, BaseURL: &baseURL},
- }, nil
-}
-
-func (s *ModelSolver) resolveCompositeModel(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string) (*resolvedModel, error) {
- availableTypes, err := s.resolveCompositeModelType(ctx, tenantID, modelRef)
- if err != nil {
- return nil, err
- }
- if !availableTypes.Has(modelType) {
- return nil, fmt.Errorf("%w: model %q cannot be used as %s model", errModelConfigUnavailable, modelRef, modelType.String())
- }
- resolved, err := s.resolveProviderInstanceModel(ctx, tenantID, modelType, modelRef)
- if err != nil {
- return nil, err
- }
- return resolved, nil
-}
-
-func (s *ModelSolver) resolveProviderInstanceModel(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string) (*resolvedModel, error) {
- // TEI builtin embedding short-circuit.
- if modelType == entity.ModelTypeEmbedding && strings.Contains(common.GetEnv(common.EnvComposeProfiles), "tei-") {
- teiModel := common.GetEnv(common.EnvTEIModel)
- teiBaseURL := common.GetEnv(common.EnvTEIBaseURL)
- if modelRef == teiModel {
- driver := modelModule.GetBuiltinEmbeddingModel(modelRef)
- if driver == nil {
- return nil, fmt.Errorf("%w: builtin (TEI) embedding model %q not found", errModelConfigUnavailable, modelRef)
- }
- return &resolvedModel{providerEntity: &entity.TenantModelProvider{ProviderName: "Builtin"}, modelType: modelType, modelName: modelRef, driver: driver, apiConfig: &modelModule.APIConfig{BaseURL: &teiBaseURL}}, nil
- }
- teiPure, _, teiProvider := splitRightAnchoredModelName(modelRef)
- if teiPure == teiModel && (teiProvider == "Builtin" || teiProvider == "") {
- driver := modelModule.GetBuiltinEmbeddingModel(teiPure)
- if driver == nil {
- return nil, fmt.Errorf("%w: builtin (TEI) embedding model %q not found", errModelConfigUnavailable, teiPure)
- }
- return &resolvedModel{providerEntity: &entity.TenantModelProvider{ProviderName: "Builtin"}, modelType: modelType, modelName: teiPure, driver: driver, apiConfig: &modelModule.APIConfig{BaseURL: &teiBaseURL}}, nil
- }
- }
-
- pureModelName, instanceName, providerName, err := parseModelName(modelRef)
- if err != nil {
- return nil, fmt.Errorf("%w: %v", errModelConfigUnavailable, err)
- }
- if modelType == entity.ModelTypeEmbedding {
- var builtinName string
- switch {
- case strings.HasSuffix(modelRef, "@default@Builtin"):
- builtinName = strings.TrimSuffix(modelRef, "@default@Builtin")
- case strings.HasSuffix(modelRef, "@Builtin"):
- builtinName = strings.TrimSuffix(modelRef, "@Builtin")
- }
- if builtinName != "" {
- driver := modelModule.GetBuiltinEmbeddingModel(builtinName)
- if driver == nil {
- return nil, fmt.Errorf("%w: builtin embedding model %q not found", errModelConfigUnavailable, builtinName)
- }
- apiKey, region := "", ""
- maxTokens := 0
- modelInfo, _ := dao.GetModelProviderManager().GetModelByName("Builtin", builtinName)
- if modelInfo != nil {
- maxTokens = maxTokensFromModelInfo(modelInfo, modelType)
- }
- return &resolvedModel{providerEntity: &entity.TenantModelProvider{ProviderName: "Builtin"}, modelInfo: modelInfo, modelType: modelType, modelName: builtinName, driver: driver, apiConfig: &modelModule.APIConfig{ApiKey: &apiKey, Region: &region}, maxTokens: maxTokens}, nil
- }
- }
-
- provider, err := s.service.modelProviderDAO.GetByTenantIDAndProviderName(ctx, dao.DB, tenantID, providerName)
- if err != nil {
- if errors.Is(err, gorm.ErrRecordNotFound) {
- return nil, fmt.Errorf("%w: provider %q lookup failed: %w", errModelConfigUnavailable, providerName, err)
- }
- return nil, fmt.Errorf("provider %q lookup failed: %w", providerName, err)
- }
- if provider == nil {
- return nil, fmt.Errorf("%w: provider %q not found for model %q", errModelConfigUnavailable, providerName, modelRef)
- }
- instance, err := s.service.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, instanceName)
- if err != nil {
- if errors.Is(err, gorm.ErrRecordNotFound) {
- return nil, fmt.Errorf("%w: instance %q lookup failed: %w", errModelConfigUnavailable, instanceName, err)
- }
- return nil, fmt.Errorf("instance %q lookup failed: %w", instanceName, err)
- }
- if instance == nil {
- return nil, fmt.Errorf("%w: instance %q not found for model %q", errModelConfigUnavailable, instanceName, modelRef)
- }
- extra, err := decodeModelInstanceExtra(instance.Extra)
- if err != nil {
- return nil, fmt.Errorf("%w: decode model instance configuration: %v", errModelConfigUnavailable, err)
- }
- region, baseURL, apiKey := extra.Region, extra.BaseURL, instance.APIKey
- modelEntity, err := s.service.modelDAO.GetByProviderIDAndInstanceIDAndModelTypeAndModelName(ctx, dao.DB, provider.ID, instance.ID, int(modelType), pureModelName)
- if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
- return nil, fmt.Errorf("model %q lookup failed: %w", modelRef, err)
- }
- providerInfo := dao.GetModelProviderManager().FindProvider(providerName)
- if modelEntity != nil {
- if modelEntity.Status == "inactive" {
- return nil, fmt.Errorf("%w: model %q is disabled", errModelConfigUnavailable, modelRef)
- }
- if providerInfo == nil {
- return nil, fmt.Errorf("%w: provider %q driver not found", errModelConfigUnavailable, providerName)
- }
- driver, driverErr := newModelDriverForBaseURL(providerInfo.ModelDriver, providerName, region, baseURL)
- if driverErr != nil {
- return nil, fmt.Errorf("%w: create model driver: %v", errModelConfigUnavailable, driverErr)
- }
- modelInfo, _ := dao.GetModelProviderManager().GetModelByName(providerName, pureModelName)
- maxTokens := maxTokensFromModelInfo(modelInfo, modelType)
- maxTokens, err = maxTokensFromTenantModelExtra(modelEntity, maxTokens)
- if err != nil {
- return nil, fmt.Errorf("%w: read model limits: %v", errModelConfigUnavailable, err)
- }
- return &resolvedModel{modelEntity: modelEntity, providerEntity: provider, modelInfo: modelInfo, modelType: modelType, modelID: modelEntity.ID, modelName: modelEntity.ModelName, instanceID: instance.ID, instanceName: instanceName, driver: driver, apiConfig: &modelModule.APIConfig{ApiKey: &apiKey, Region: &region, BaseURL: &baseURL}, maxTokens: maxTokens}, nil
- }
- if providerInfo == nil {
- return nil, fmt.Errorf("%w: model provider config not found: %s", errModelConfigUnavailable, providerName)
- }
- targetFactoryName := providerName
- if region == "intl" && strings.EqualFold(providerName, "siliconflow") {
- targetFactoryName = "siliconflow_intl"
- }
- targetProvider := dao.GetModelProviderManager().FindProvider(targetFactoryName)
- if targetProvider == nil {
- return nil, fmt.Errorf("%w: model provider config not found: %s", errModelConfigUnavailable, providerName)
- }
- var modelInfo *modelModule.Model
- for _, candidate := range targetProvider.Models {
- if strings.EqualFold(candidate.Name, pureModelName) {
- modelInfo = candidate
- break
- }
- }
- if modelInfo == nil {
- return nil, fmt.Errorf("%w: model config not found: %s", errModelConfigUnavailable, modelRef)
- }
- driver, err := newModelDriverForBaseURL(targetProvider.ModelDriver, providerName, region, baseURL)
- if err != nil {
- return nil, fmt.Errorf("%w: create model driver: %v", errModelConfigUnavailable, err)
- }
- return &resolvedModel{providerEntity: provider, modelInfo: modelInfo, modelType: modelType, modelName: modelInfo.Name, instanceID: instance.ID, instanceName: instanceName, driver: driver, apiConfig: &modelModule.APIConfig{ApiKey: &apiKey, Region: &region, BaseURL: &baseURL}, maxTokens: maxTokensFromModelInfo(modelInfo, modelType)}, nil
-}
-
-func (s *ModelSolver) resolveCompositeModelType(ctx context.Context, tenantID, modelRef string) (entity.ModelType, error) {
- pureModelName, instanceName, providerName, err := parseModelName(modelRef)
- if err != nil {
- return 0, fmt.Errorf("%w: %v", errModelConfigUnavailable, err)
- }
-
- if strings.EqualFold(providerName, "Builtin") {
- if modelModule.GetBuiltinEmbeddingModel(pureModelName) == nil {
- return 0, fmt.Errorf("%w: builtin model %q not found", errModelConfigUnavailable, pureModelName)
- }
- return entity.ModelTypeEmbedding, nil
- }
- if s == nil || s.service == nil || s.service.modelProviderDAO == nil || s.service.modelInstanceDAO == nil || s.service.modelDAO == nil {
- return 0, fmt.Errorf("%w: model service is not initialized", errModelConfigUnavailable)
- }
-
- provider, err := s.service.modelProviderDAO.GetByTenantIDAndProviderName(ctx, dao.DB, tenantID, providerName)
- if err != nil {
- return 0, fmt.Errorf("%w: provider %q lookup failed: %w", errModelConfigUnavailable, providerName, err)
- }
- if provider == nil {
- return 0, fmt.Errorf("%w: provider %q not found for model %q", errModelConfigUnavailable, providerName, modelRef)
- }
- instance, err := s.service.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, instanceName)
- if err != nil {
- return 0, fmt.Errorf("%w: instance %q lookup failed: %w", errModelConfigUnavailable, instanceName, err)
- }
- if instance == nil {
- return 0, fmt.Errorf("%w: instance %q not found for model %q", errModelConfigUnavailable, instanceName, modelRef)
- }
-
- models, err := s.service.modelDAO.GetModelsByProviderIDAndInstanceIDAndModelName(ctx, dao.DB, provider.ID, instance.ID, pureModelName)
- if err != nil {
- return 0, fmt.Errorf("%w: model %q lookup failed: %v", errModelConfigUnavailable, modelRef, err)
- }
- var modelType entity.ModelType
- for _, model := range models {
- if model != nil && model.Status == "active" {
- modelType |= entity.ModelType(model.ModelType)
- }
- }
- if modelType != 0 {
- return modelType, nil
- }
-
- providerInfo := dao.GetModelProviderManager().FindProvider(providerName)
- if providerInfo == nil {
- return 0, fmt.Errorf("%w: model provider config not found: %s", errModelConfigUnavailable, providerName)
- }
- for _, model := range providerInfo.Models {
- if model != nil && strings.EqualFold(model.Name, pureModelName) {
- modelType = entity.ModelTypeFromStrings(model.ModelTypes)
- if modelType != 0 {
- return modelType, nil
- }
- break
- }
- }
- return 0, fmt.Errorf("%w: model %q not found for provider %q", errModelConfigUnavailable, pureModelName, providerName)
-}
-
-func modelTypesFromBitmask(modelType entity.ModelType) []entity.ModelType {
- modelTypes := make([]entity.ModelType, 0, 7)
- for _, candidate := range []entity.ModelType{
- entity.ModelTypeChat,
- entity.ModelTypeEmbedding,
- entity.ModelTypeSpeech2Text,
- entity.ModelTypeImage2Text,
- entity.ModelTypeRerank,
- entity.ModelTypeTTS,
- entity.ModelTypeOCR,
- } {
- if modelType.Has(candidate) {
- modelTypes = append(modelTypes, candidate)
- }
- }
- return modelTypes
-}
diff --git a/internal/service/nav_embedder.go b/internal/service/nav_embedder.go
index c57066415e..80403e1be5 100644
--- a/internal/service/nav_embedder.go
+++ b/internal/service/nav_embedder.go
@@ -21,8 +21,6 @@ import (
"fmt"
modelModule "ragflow/internal/entity/models"
"strings"
-
- "ragflow/internal/entity"
)
// NavEmbedder is the production implementation of nlp.NavEmbedder. It resolves
@@ -30,15 +28,15 @@ import (
// dataset-nav index stores q_<dim>_vec as float). It lives in the service
// package (not nlp) so it can import model_service without an import cycle.
type NavEmbedder struct {
- modelSvc *ModelProviderService
+ modelFactory *ModelFactory
// embdModelName is the composite embedding model name (e.g.
// "embedding_model@..." ). Empty falls back to resolving the tenant default.
embdModelName string
}
// NewNavEmbedder builds the production embedder used by NavService.
-func NewNavEmbedder(modelSvc *ModelProviderService, embdModelName string) *NavEmbedder {
- return &NavEmbedder{modelSvc: modelSvc, embdModelName: embdModelName}
+func NewNavEmbedder(modelFactory *ModelFactory, embdModelName string) *NavEmbedder {
+ return &NavEmbedder{modelFactory: modelFactory, embdModelName: embdModelName}
}
// Encode embeds texts as DOCUMENTS for the tenant and returns float32 vectors.
@@ -56,23 +54,20 @@ func (e *NavEmbedder) EncodeQueries(ctx context.Context, tenantID string, texts
}
func (e *NavEmbedder) encode(ctx context.Context, tenantID string, texts []string, query bool) ([][]float32, error) {
- if e.modelSvc == nil {
- return nil, fmt.Errorf("datasetnav: embedding model service not initialized")
+ if e.modelFactory == nil {
+ return nil, fmt.Errorf("datasetnav: model factory not initialized")
}
name := e.embdModelName
var model *modelModule.EmbeddingModel
+ access := ModelAccess{TenantID: tenantID}
+ var err error
if name == "" {
- target, err := e.modelSvc.modelSolver().ResolveDefaultModelConfig(ctx, tenantID, entity.ModelTypeEmbedding)
- if err != nil {
- return nil, fmt.Errorf("datasetnav: resolve embedding model for tenant %s: %w", tenantID, err)
- }
- model = modelModule.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
+ model, err = e.modelFactory.NewDefaultEmbeddingModel(ctx, access)
} else {
- target, err := e.modelSvc.modelSolver().ResolveModelConfig(ctx, tenantID, entity.ModelTypeEmbedding, name)
- if err != nil {
- return nil, fmt.Errorf("datasetnav: resolve embedding model for tenant %s: %w", tenantID, err)
- }
- model = modelModule.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
+ model, err = e.modelFactory.NewEmbeddingModel(ctx, access, name)
+ }
+ if err != nil {
+ return nil, fmt.Errorf("datasetnav: resolve embedding model for tenant %s: %w", tenantID, err)
}
nonEmpty := make([]string, 0, len(texts))
for _, t := range texts {
diff --git a/internal/service/nav_merge_llm.go b/internal/service/nav_merge_llm.go
index afd497db14..0594fb12a0 100644
--- a/internal/service/nav_merge_llm.go
+++ b/internal/service/nav_merge_llm.go
@@ -22,7 +22,6 @@ import (
"fmt"
"strings"
- "ragflow/internal/entity"
modelModule "ragflow/internal/entity/models"
kccommon "ragflow/internal/ingestion/component/knowledge_compiler/common"
)
@@ -41,7 +40,7 @@ const navNamingMaxRetries = 2
// chat model, mirroring Python dataset_nav._llm_create_summary / _llm_merge.
//
// It sits next to NavEmbedder in the service package, not with the seam it
-// implements, because it needs ModelProviderService and no inner package may
+// implements, because it needs ModelFactory and no inner package may
// import service: service already imports nlp (chat_pipeline, deep_researcher,
// memory) and nav (dataset_artifact_service). The nav package is deliberately a
// dependency-light leaf — the agent tool layer and the nlp implementation both
@@ -49,7 +48,7 @@ const navNamingMaxRetries = 2
// out here. Moving this type into nav would need the model access reduced to an
// injected interface first.
type NavMergeLLM struct {
- modelSvc *ModelProviderService
+ modelFactory *ModelFactory
// llmID is the configured chat model ref (a composite
// "model@instance@provider" name or a tenant model id). Empty resolves the
// tenant's default chat model, matching the dataset-level deduper's fallback.
@@ -57,8 +56,8 @@ type NavMergeLLM struct {
}
// NewNavMergeLLM builds the production nav cluster namer/merger.
-func NewNavMergeLLM(modelSvc *ModelProviderService, llmID string) *NavMergeLLM {
- return &NavMergeLLM{modelSvc: modelSvc, llmID: llmID}
+func NewNavMergeLLM(modelFactory *ModelFactory, llmID string) *NavMergeLLM {
+ return &NavMergeLLM{modelFactory: modelFactory, llmID: llmID}
}
// navNamingPrompt is the cluster-naming prompt (Python _llm_create_summary) plus
@@ -99,12 +98,12 @@ func (l *NavMergeLLM) CreateSummary(ctx context.Context, tenantID, text string)
if text == "" {
return "", "", nil
}
- llmID, err := l.chatModelID(ctx, tenantID)
+ llmID, err := l.chatModelRef()
if err != nil {
return "", "", err
}
temp := navNamingTemperature
- reply, err := kccommon.GenJSON(ctx, navChatInvoker{modelSvc: l.modelSvc, tenantID: tenantID, llmID: llmID},
+ reply, err := kccommon.GenJSON(ctx, navChatInvoker{modelFactory: l.modelFactory, tenantID: tenantID, modelRef: llmID},
kccommon.ChatRequest{UserPrompt: navNamingPrompt(text), Temperature: &temp}, navNamingMaxRetries)
if err != nil {
return "", "", err
@@ -130,35 +129,25 @@ func (l *NavMergeLLM) Merge(ctx context.Context, tenantID string, texts []string
if added == "" {
return existing, nil
}
- llmID, err := l.chatModelID(ctx, tenantID)
+ llmID, err := l.chatModelRef()
if err != nil {
return "", err
}
temp := navNamingTemperature
- reply, err := navChatText(ctx, l.modelSvc, tenantID, llmID, "", navMergePrompt(existing, added), &temp)
+ reply, err := navChatText(ctx, l.modelFactory, tenantID, llmID, "", navMergePrompt(existing, added), &temp)
if err != nil {
return "", err
}
return navMergedFromReply(reply, existing), nil
}
-// chatModelID resolves the chat model ref to call: the configured one, else the
-// tenant's default chat model.
-func (l *NavMergeLLM) chatModelID(ctx context.Context, tenantID string) (string, error) {
- if l.modelSvc == nil {
- return "", fmt.Errorf("datasetnav: model provider service not initialized")
+// chatModelRef returns the configured chat-model reference. An empty reference
+// asks ModelFactory to construct the tenant's default model at call time.
+func (l *NavMergeLLM) chatModelRef() (string, error) {
+ if l.modelFactory == nil {
+ return "", fmt.Errorf("datasetnav: model factory not initialized")
}
- if ref := strings.TrimSpace(l.llmID); ref != "" {
- return ref, nil
- }
- target, err := l.modelSvc.modelSolver().ResolveDefaultModelConfig(ctx, tenantID, entity.ModelTypeChat)
- if err != nil {
- return "", fmt.Errorf("datasetnav: resolve default chat model for tenant %s: %w", tenantID, err)
- }
- if target == nil || strings.TrimSpace(target.ModelID) == "" {
- return "", fmt.Errorf("datasetnav: no default chat model for tenant %s", tenantID)
- }
- return target.ModelID, nil
+ return strings.TrimSpace(l.llmID), nil
}
// navSummaryFromReply mirrors Python _llm_create_summary's response handling:
@@ -213,17 +202,17 @@ func navReplyString(v any) string {
return strings.TrimSpace(s)
}
-// navChatInvoker adapts the model provider service to the knowledge-compiler
+// navChatInvoker adapts a factory-created chat model to the knowledge-compiler
// ChatInvoker seam, so the JSON naming prompt reuses kccommon.GenJSON's
// extraction/repair/retry handling (the Go counterpart of Python gen_json).
type navChatInvoker struct {
- modelSvc *ModelProviderService
- tenantID string
- llmID string
+ modelFactory *ModelFactory
+ tenantID string
+ modelRef string
}
func (c navChatInvoker) Chat(ctx context.Context, req kccommon.ChatRequest) (*kccommon.ChatResponse, error) {
- content, err := navChatText(ctx, c.modelSvc, c.tenantID, c.llmID, req.SystemPrompt, req.UserPrompt, req.Temperature)
+ content, err := navChatText(ctx, c.modelFactory, c.tenantID, c.modelRef, req.SystemPrompt, req.UserPrompt, req.Temperature)
if err != nil {
return nil, err
}
@@ -232,12 +221,22 @@ func (c navChatInvoker) Chat(ctx context.Context, req kccommon.ChatRequest) (*kc
// navChatText dispatches one non-streaming chat call. system may be empty (both
// nav prompts are single-turn, matching Python's gen_json("", prompt, ...)).
-func navChatText(ctx context.Context, modelSvc *ModelProviderService, tenantID, llmID, system, user string, temperature *float64) (string, error) {
- if modelSvc == nil {
- return "", fmt.Errorf("datasetnav: model provider service not initialized")
+func navChatText(ctx context.Context, modelFactory *ModelFactory, tenantID, modelRef, system, user string, temperature *float64) (string, error) {
+ if modelFactory == nil {
+ return "", fmt.Errorf("datasetnav: model factory not initialized")
}
- if strings.TrimSpace(llmID) == "" {
- return "", fmt.Errorf("datasetnav: chat model is not resolved")
+ access := ModelAccess{TenantID: tenantID}
+ var (
+ chatModel *modelModule.ChatModel
+ err error
+ )
+ if strings.TrimSpace(modelRef) == "" {
+ chatModel, err = modelFactory.NewDefaultChatModel(ctx, access)
+ } else {
+ chatModel, err = modelFactory.NewChatModel(ctx, access, modelRef)
+ }
+ if err != nil {
+ return "", err
}
config := &modelModule.ChatConfig{}
if temperature != nil {
@@ -247,7 +246,7 @@ func navChatText(ctx context.Context, modelSvc *ModelProviderService, tenantID,
{Role: "system", Content: system},
{Role: "user", Content: user},
}
- resp, err := modelSvc.Chat(ctx, tenantID, llmID, msgs, config)
+ resp, err := chatModel.ChatWithMessages(ctx, msgs, config, nil)
if err != nil {
return "", err
}
diff --git a/internal/service/nlp/reranker.go b/internal/service/nlp/reranker.go
index 3bf8a54f99..bf26fa7375 100644
--- a/internal/service/nlp/reranker.go
+++ b/internal/service/nlp/reranker.go
@@ -165,7 +165,7 @@ func RerankByModel(
tsim = TokenSimilarity(keywords, insTw, qb)
// Get similarity scores from reranker model
- rerankResponse, err := rerankModel.Rerank(ctx, models.RerankRequest{Query: query, Documents: docs}, rerankModel.APIConfig, &models.RerankConfig{}, nil)
+ rerankResponse, err := rerankModel.Rerank(ctx, models.RerankRequest{Query: query, Documents: docs}, &models.RerankConfig{}, nil)
if err != nil {
return nil, nil, nil, err
}
diff --git a/internal/service/openai_chat.go b/internal/service/openai_chat.go
index 7711cd8fc2..f81846cfc5 100644
--- a/internal/service/openai_chat.go
+++ b/internal/service/openai_chat.go
@@ -249,7 +249,7 @@ func (s *OpenAIChatService) OpenAIChatCompletions(c *gin.Context, userID, chatID
}
}
if req.Model != "model" {
- if _, mErr := s.pipeline.ModelProviderSvc.modelSolver().ResolveModelConfig(ctx, dialog.TenantID, entity.ModelTypeChat, resolvedModel); mErr != nil {
+ if _, mErr := s.pipeline.ModelFactory.ResolveInfo(ctx, ModelAccess{UserID: userID, TenantID: dialog.TenantID}, entity.ModelTypeChat, resolvedModel); mErr != nil {
s.writeArgError(c, fmt.Sprintf("`llm_id` %s doesn't exist", req.Model))
return
}
diff --git a/internal/service/related_question.go b/internal/service/related_question.go
index 09513360cd..03bd32154d 100644
--- a/internal/service/related_question.go
+++ b/internal/service/related_question.go
@@ -28,9 +28,9 @@ import (
)
// GenerateRelatedQuestions generates related search questions for chat/searchbot endpoints.
-func GenerateRelatedQuestions(ctx context.Context, tenantID, question, searchID string, searchSvc *SearchService, tenantSvc *TenantService, modelProviderSvc *ModelProviderService) ([]string, error) {
- if modelProviderSvc == nil {
- return nil, fmt.Errorf("model provider service not configured")
+func GenerateRelatedQuestions(ctx context.Context, tenantID, question, searchID string, searchSvc *SearchService, tenantSvc *TenantService, modelFactory *ModelFactory) ([]string, error) {
+ if modelFactory == nil {
+ return nil, fmt.Errorf("model factory not configured")
}
searchConfig := relatedQuestionsSearchConfig(ctx, searchID, searchSvc)
modelID := relatedQuestionsModelID(ctx, tenantID, searchConfig, tenantSvc)
@@ -45,7 +45,11 @@ func GenerateRelatedQuestions(ctx context.Context, tenantID, question, searchID
{Role: "system", Content: prompt},
{Role: "user", Content: "\nKeywords: " + question + "\nRelated search terms:\n "},
}
- response, err := modelProviderSvc.Chat(ctx, tenantID, modelID, messages, relatedQuestionsConfig(searchConfig))
+ chatModel, err := modelFactory.NewChatModel(ctx, ModelAccess{TenantID: tenantID}, modelID)
+ if err != nil {
+ return nil, err
+ }
+ response, err := chatModel.ChatWithMessages(ctx, messages, relatedQuestionsConfig(searchConfig), nil)
if err != nil {
return nil, err
}
diff --git a/internal/service/skill_indexer.go b/internal/service/skill_indexer.go
index a85a32c36e..6a0135bef2 100644
--- a/internal/service/skill_indexer.go
+++ b/internal/service/skill_indexer.go
@@ -52,19 +52,19 @@ type FileSystemClient interface {
// SkillIndexerService handles skill indexing operations
type SkillIndexerService struct {
- configDAO *dao.SkillSearchConfigDAO
- fileDAO *dao.FileDAO
- spaceDAO *dao.SkillSpaceDAO
- modelProvider *ModelProviderService
+ configDAO *dao.SkillSearchConfigDAO
+ fileDAO *dao.FileDAO
+ spaceDAO *dao.SkillSpaceDAO
+ modelFactory *ModelFactory
}
// NewSkillIndexerService creates a new SkillIndexerService instance
func NewSkillIndexerService() *SkillIndexerService {
return &SkillIndexerService{
- configDAO: dao.NewSkillSearchConfigDAO(),
- fileDAO: dao.NewFileDAO(),
- spaceDAO: dao.NewSkillSpaceDAO(),
- modelProvider: NewModelProviderService(),
+ configDAO: dao.NewSkillSearchConfigDAO(),
+ fileDAO: dao.NewFileDAO(),
+ spaceDAO: dao.NewSkillSpaceDAO(),
+ modelFactory: NewModelFactory(),
}
}
@@ -912,7 +912,7 @@ func (s *SkillIndexerService) EnsureIndex(ctx context.Context, tenantID, spaceID
// generateEmbedding generates embedding for text using the specified model
func (s *SkillIndexerService) generateEmbedding(ctx context.Context, text, embdID, tenantID string) ([]float64, error) {
- if s.modelProvider == nil {
+ if s.modelFactory == nil {
return nil, fmt.Errorf("model provider not set")
}
@@ -920,11 +920,10 @@ func (s *SkillIndexerService) generateEmbedding(ctx context.Context, text, embdI
return nil, fmt.Errorf("embedding model ID not configured")
}
- target, err := s.modelProvider.modelSolver().ResolveModelConfig(ctx, tenantID, entity.ModelTypeEmbedding, embdID)
+ embeddingModel, err := s.modelFactory.NewEmbeddingModel(ctx, ModelAccess{TenantID: tenantID}, embdID)
if err != nil {
return nil, fmt.Errorf("failed to get embedding model: %w", err)
}
- embeddingModel := models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
var response []models.EmbeddingData
response, err = embeddingModel.Embed(ctx, models.EmbedRequest{Texts: []string{text}}, nil, nil)
@@ -943,7 +942,7 @@ func (s *SkillIndexerService) generateEmbedding(ctx context.Context, text, embdI
func (s *SkillIndexerService) generateEmbeddings(ctx context.Context, texts []string, embdID, tenantID string) ([]models.EmbeddingData, error) {
common.Info(fmt.Sprintf("generateEmbeddings called: texts=%d, embdID=%s, tenantID=%s", len(texts), embdID, tenantID))
- if s.modelProvider == nil {
+ if s.modelFactory == nil {
return nil, fmt.Errorf("model provider not set")
}
@@ -952,12 +951,11 @@ func (s *SkillIndexerService) generateEmbeddings(ctx context.Context, texts []st
}
common.Info(fmt.Sprintf("Getting embedding model for %s", embdID))
- target, err := s.modelProvider.modelSolver().ResolveModelConfig(ctx, tenantID, entity.ModelTypeEmbedding, embdID)
+ embeddingModel, err := s.modelFactory.NewEmbeddingModel(ctx, ModelAccess{TenantID: tenantID}, embdID)
if err != nil {
common.Error(fmt.Sprintf("Failed to get embedding model: %v", err), err)
return nil, fmt.Errorf("failed to get embedding model: %w", err)
}
- embeddingModel := models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
common.Info(fmt.Sprintf("Encoding %d texts", len(texts)))
// Use batch encode API (consistent with Python's encode(texts: list))
@@ -980,7 +978,7 @@ func (s *SkillIndexerService) generateEmbeddings(ctx context.Context, texts []st
// This follows Python's approach: use actual embedding result to determine dimension
// If embedding API fails, returns error (cannot create table without knowing dimension)
func (s *SkillIndexerService) getEmbeddingDimension(ctx context.Context, tenantID, embdID string) (int, error) {
- if s.modelProvider == nil {
+ if s.modelFactory == nil {
return 0, fmt.Errorf("model provider not set")
}
@@ -988,11 +986,10 @@ func (s *SkillIndexerService) getEmbeddingDimension(ctx context.Context, tenantI
return 0, fmt.Errorf("embedding model ID not configured")
}
- target, err := s.modelProvider.modelSolver().ResolveModelConfig(ctx, tenantID, entity.ModelTypeEmbedding, embdID)
+ embeddingModel, err := s.modelFactory.NewEmbeddingModel(ctx, ModelAccess{TenantID: tenantID}, embdID)
if err != nil {
return 0, fmt.Errorf("failed to get embedding model: %w", err)
}
- embeddingModel := models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
// Use simple test text like Python does: embedding_model.encode(["ok"])
testText := "ok"
diff --git a/internal/service/skill_search.go b/internal/service/skill_search.go
index 067c86d95d..93b283888f 100644
--- a/internal/service/skill_search.go
+++ b/internal/service/skill_search.go
@@ -36,23 +36,18 @@ import (
// SkillSearchService handles business logic for skill search operations
type SkillSearchService struct {
- configDAO *dao.SkillSearchConfigDAO
- modelProvider *ModelProviderService
+ configDAO *dao.SkillSearchConfigDAO
+ modelFactory *ModelFactory
}
// NewSkillSearchService creates a new SkillSearchService instance
func NewSkillSearchService() *SkillSearchService {
return &SkillSearchService{
- configDAO: dao.NewSkillSearchConfigDAO(),
- modelProvider: NewModelProviderService(),
+ configDAO: dao.NewSkillSearchConfigDAO(),
+ modelFactory: NewModelFactory(),
}
}
-// SetModelProvider sets the model provider for embedding generation
-func (s *SkillSearchService) SetModelProvider(provider *ModelProviderService) {
- s.modelProvider = provider
-}
-
// GetConfigRequest represents the request to get skill search config
type GetConfigRequest struct {
TenantID string `json:"tenant_id" binding:"required"`
@@ -659,7 +654,7 @@ func (s *SkillSearchService) convertChunksToResults(chunks []map[string]interfac
// getEmbedding generates embedding for text using the specified model
func (s *SkillSearchService) getEmbedding(ctx context.Context, text, embdID, tenantID string) ([]float64, error) {
- if s.modelProvider == nil {
+ if s.modelFactory == nil {
return nil, fmt.Errorf("model provider not set")
}
@@ -667,11 +662,10 @@ func (s *SkillSearchService) getEmbedding(ctx context.Context, text, embdID, ten
return nil, fmt.Errorf("embedding model ID not configured")
}
- target, err := s.modelProvider.modelSolver().ResolveModelConfig(ctx, tenantID, entity.ModelTypeEmbedding, embdID)
+ embeddingModel, err := s.modelFactory.NewEmbeddingModel(ctx, ModelAccess{TenantID: tenantID}, embdID)
if err != nil {
return nil, fmt.Errorf("failed to get embedding model: %w", err)
}
- embeddingModel := models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
// Query: true — getEmbedding is used only by the skill search legs
// (vectorSearch / hybridSearch) to embed the user's query.