Skip to content

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

13.2 KB
Raw Blame
//
// 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"
	"errors"
	"fmt"
	"strings"

	"ragflow/internal/common"
	"ragflow/internal/dao"
	"ragflow/internal/entity"
	"ragflow/internal/permission"
)

// SetModelSettingsRequest represents default model selections for a user in the current tenant.
type SetModelSettingsRequest struct {
	TenantID     *string                `json:"tenant_id"`
	ASRID        *string                `json:"asr_id"`
	EmbdID       *string                `json:"embd_id"`
	Img2TxtID    *string                `json:"img2txt_id"`
	LLMID        *string                `json:"llm_id"`
	RerankID     *string                `json:"rerank_id"`
	TTSID        *string                `json:"tts_id"`
	Raw          map[string]interface{} `json:"-"`
	DefaultModel *DefaultModelSelection `json:"-"`
}

// DefaultModelSelection is the single-model form used by the default-model endpoints.
type DefaultModelSelection struct {
	ModelProvider string
	ModelInstance string
	ModelName     string
	ModelType     string
	ModelID       string
}

// UserTenantService manages user settings scoped to a tenant membership.
type UserTenantService struct {
	userTenantDAO *dao.UserTenantDAO
	tenantDAO     *dao.TenantDAO
}

// NewUserTenantService creates a UserTenantService.
func NewUserTenantService() *UserTenantService {
	return &UserTenantService{
		userTenantDAO: dao.NewUserTenantDAO(),
		tenantDAO:     dao.NewTenantDAO(),
	}
}

// TenantInfoResponse contains the current tenant and membership settings.
type TenantInfoResponse struct {
	TenantID  string  `json:"tenant_id"`
	Name      *string `json:"name,omitempty"`
	LLMID     string  `json:"llm_id"`
	EmbDID    string  `json:"embd_id"`
	RerankID  string  `json:"rerank_id"`
	ASRID     string  `json:"asr_id"`
	Img2TxtID string  `json:"img2txt_id"`
	TTSID     string  `json:"tts_id"`
	ParserIDs string  `json:"parser_ids"`
	Role      string  `json:"role"`
}

// GetCurrentTenantInfo returns the active tenant with the user's membership settings.
func (s *UserTenantService) GetCurrentTenantInfo(ctx context.Context) (*TenantInfoResponse, error) {
	userID := permission.UserIDFromContext(ctx)
	tenantID, err := requireCurrentTenantID(ctx)
	if err != nil {
		return nil, err
	}
	membership, err := s.userTenantDAO.FilterByUserIDAndTenantID(ctx, dao.DB, userID, tenantID)
	if err != nil {
		return nil, err
	}
	tenant, err := s.tenantDAO.GetByID(ctx, dao.DB, tenantID)
	if err != nil {
		return nil, err
	}
	return &TenantInfoResponse{
		TenantID:  tenant.ID,
		Name:      tenant.Name,
		LLMID:     membership.LLMID,
		EmbDID:    membership.EmbdID,
		RerankID:  membership.RerankID,
		ASRID:     membership.ASRID,
		Img2TxtID: membership.Img2TxtID,
		TTSID:     ptrStringValue(membership.TTSID),
		ParserIDs: tenant.ParserIDs,
		Role:      membership.Role,
	}, nil
}

// UserTenantRelation represents a user-tenant relationship response.
type UserTenantRelation struct {
	ID       string `json:"id"`
	UserID   string `json:"user_id"`
	TenantID string `json:"tenant_id"`
	Role     string `json:"role"`
}

// GetUserTenantRelationByUserIDWithContext retrieves a user's active tenant relationships.
func (s *UserTenantService) GetUserTenantRelationByUserIDWithContext(ctx context.Context, userID string) ([]*UserTenantRelation, error) {
	relations, err := s.userTenantDAO.GetByUserID(ctx, dao.DB, userID)
	if err != nil {
		return nil, err
	}

	result := make([]*UserTenantRelation, len(relations))
	for i, relation := range relations {
		result[i] = &UserTenantRelation{
			ID:       relation.ID,
			UserID:   relation.UserID,
			TenantID: relation.TenantID,
			Role:     relation.Role,
		}
	}
	return result, nil
}

var defaultModelTypeNames = [...]string{"chat", "embedding", "rerank", "asr", "vision", "tts", "ocr", "decision"}

// SetModelSettings validates and updates default models on the user's active tenant membership.
func (s *UserTenantService) SetModelSettings(ctx context.Context, req *SetModelSettingsRequest) (common.ErrorCode, error) {
	if req == nil || (req.Raw != nil && req.DefaultModel != nil) {
		return common.CodeArgumentError, fmt.Errorf("provide either model settings or one default model selection")
	}
	raw := req.Raw
	if selection := req.DefaultModel; selection != nil {
		legacyField, idField, _, err := defaultModelFields(selection.ModelType)
		if err != nil {
			return common.CodeArgumentError, err
		}
		provider := strings.TrimSpace(selection.ModelProvider)
		instance := strings.TrimSpace(selection.ModelInstance)
		name := strings.TrimSpace(selection.ModelName)
		modelID := strings.TrimSpace(selection.ModelID)
		anyNameField := provider != "" || instance != "" || name != ""
		if anyNameField && modelID == "" && (provider == "" || instance == "" || name == "") {
			return common.CodeArgumentError, fmt.Errorf("model provider, instance and name must be specified together")
		}
		modelRef := ""
		if anyNameField && provider != "" && instance != "" && name != "" {
			modelRef = fmt.Sprintf("%s@%s@%s", name, instance, provider)
		}
		var modelIDValue interface{}
		if modelID != "" {
			modelIDValue = modelID
		}
		raw = map[string]interface{}{legacyField: modelRef, idField: modelIDValue}
	}
	updates, err := modelSettingUpdates(raw)
	if err != nil {
		return common.CodeArgumentError, err
	}
	userID := permission.UserIDFromContext(ctx)
	tenantID, err := requireCurrentTenantID(ctx)
	if err != nil {
		return common.CodeForbidden, err
	}
	if req.TenantID != nil && strings.TrimSpace(*req.TenantID) != "" && strings.TrimSpace(*req.TenantID) != tenantID {
		return common.CodeForbidden, fmt.Errorf("tenant_id must match the active Tenant context")
	}
	if rawTenantID, ok := raw["tenant_id"].(string); ok && strings.TrimSpace(rawTenantID) != "" && strings.TrimSpace(rawTenantID) != tenantID {
		return common.CodeForbidden, fmt.Errorf("tenant_id must match the active Tenant context")
	}
	if s == nil || s.userTenantDAO == nil || dao.DB == nil {
		return common.CodeExceptionError, fmt.Errorf("User Tenant service is not initialized")
	}
	membership, err := s.userTenantDAO.FilterByUserIDAndTenantID(ctx, dao.DB, userID, tenantID)
	if err != nil {
		if dao.IsNotFoundErr(err) {
			return common.CodeForbidden, err
		}
		return common.CodeExceptionError, err
	}

	factory := NewModelFactory()
	modelUpdates := make(map[string]interface{}, len(updates))
	for _, modelTypeName := range defaultModelTypeNames {
		legacyField, idField, modelType, _ := defaultModelFields(modelTypeName)
		legacyValue, hasLegacy := updates[legacyField]
		idValue, hasID := updates[idField]
		if !hasLegacy && !hasID {
			continue
		}
		legacyRef, _ := legacyValue.(string)
		idRef, _ := idValue.(string)
		legacyRef = strings.TrimSpace(legacyRef)
		idRef = strings.TrimSpace(idRef)
		modelRef := idRef
		if modelRef == "" {
			modelRef = legacyRef
		}
		if modelRef == "" {
			modelUpdates[legacyField] = ""
			modelUpdates[idField] = nil
			continue
		}

		info, err := factory.ResolveInfo(permission.WithTenantID(ctx, tenantID), modelType, modelRef)
		if err != nil {
			switch {
			case errors.Is(err, permission.ErrPermissionDenied), errors.Is(err, permission.ErrResourceNotFound), errors.Is(err, permission.ErrMembershipNotFound):
				return common.CodeForbidden, err
			case errors.Is(err, errModelConfigUnavailable):
				return common.CodeArgumentError, err
			default:
				return common.CodeExceptionError, err
			}
		}
		if info == nil {
			return common.CodeArgumentError, fmt.Errorf("model %q is unavailable", modelRef)
		}
		if info.InstanceName != "" {
			modelUpdates[legacyField] = fmt.Sprintf("%s@%s@%s", info.Name, info.InstanceName, info.ProviderName)
		} else if info.ProviderName != "" {
			modelUpdates[legacyField] = fmt.Sprintf("%s@%s", info.Name, info.ProviderName)
		} else {
			modelUpdates[legacyField] = info.Name
		}
		var resolvedModelID interface{}
		if info.ID != "" {
			resolvedModelID = info.ID
		}
		modelUpdates[idField] = resolvedModelID
	}
	if len(modelUpdates) == 0 {
		return common.CodeSuccess, nil
	}
	if err := dao.DB.WithContext(ctx).Model(&entity.UserTenant{}).Where("id = ?", membership.ID).Updates(modelUpdates).Error; err != nil {
		return common.CodeExceptionError, err
	}
	return common.CodeSuccess, nil
}

func modelSettingField(key string) (string, string, bool) {
	for _, modelType := range defaultModelTypeNames {
		legacyField, idField, _, err := defaultModelFields(modelType)
		if err != nil {
			continue
		}
		if key == legacyField || key == idField {
			nullable := key == idField || legacyField == "tts_id" || legacyField == "ocr_id" || legacyField == "decision_id"
			return legacyField, idField, nullable
		}
	}
	return "", "", false
}

func modelSettingUpdates(raw map[string]interface{}) (map[string]interface{}, error) {
	updates := make(map[string]interface{}, len(raw))
	for key, value := range raw {
		if key == "tenant_id" {
			if _, ok := value.(string); !ok {
				return nil, fmt.Errorf("tenant_id must be a string")
			}
			continue
		}
		legacyField, _, nullable := modelSettingField(key)
		if legacyField == "" {
			return nil, fmt.Errorf("unsupported model setting %q", key)
		}
		if value == nil {
			if !nullable {
				return nil, fmt.Errorf("%s cannot be null", key)
			}
			updates[key] = nil
			continue
		}
		if _, ok := value.(string); !ok {
			return nil, fmt.Errorf("%s must be a string", key)
		}
		updates[key] = value
	}
	return updates, nil
}

// ModelItem describes one configured default model.
type ModelItem struct {
	ModelProvider *string `json:"model_provider"`
	ModelInstance *string `json:"model_instance"`
	ModelName     *string `json:"model_name"`
	ModelID       string  `json:"model_id"`
	ModelType     string  `json:"model_type"`
	Enable        bool    `json:"enable"`
}

func defaultModelFields(modelType string) (string, string, entity.ModelType, error) {
	switch modelType {
	case "chat":
		return "llm_id", "tenant_llm_id", entity.ModelTypeChat, nil
	case "embedding":
		return "embd_id", "tenant_embd_id", entity.ModelTypeEmbedding, nil
	case "rerank":
		return "rerank_id", "tenant_rerank_id", entity.ModelTypeRerank, nil
	case "asr", "speech2text":
		return "asr_id", "tenant_asr_id", entity.ModelTypeSpeech2Text, nil
	case "vision", "image2text":
		return "img2txt_id", "tenant_img2txt_id", entity.ModelTypeImage2Text, nil
	case "tts":
		return "tts_id", "tenant_tts_id", entity.ModelTypeTTS, nil
	case "ocr":
		return "ocr_id", "tenant_ocr_id", entity.ModelTypeOCR, nil
	case "decision":
		return "decision_id", "tenant_decision_id", entity.ModelTypeDecision, nil
	default:
		return "", "", 0, fmt.Errorf("model type %s is invalid", modelType)
	}
}

func ptrStringValue(value *string) string {
	if value == nil {
		return ""
	}
	return *value
}

// ListDefaultModels returns the models configured on the user's current tenant membership.
func (s *UserTenantService) ListDefaultModels(ctx context.Context) ([]ModelItem, error) {
	userID := permission.UserIDFromContext(ctx)
	tenantID, err := requireCurrentTenantID(ctx)
	if err != nil {
		return nil, err
	}
	membership, err := s.userTenantDAO.FilterByUserIDAndTenantID(ctx, dao.DB, userID, tenantID)
	if err != nil {
		return nil, err
	}
	type defaultModel struct {
		modelType string
		modelName string
		modelID   *string
	}
	models := []defaultModel{
		{modelType: "chat", modelName: membership.LLMID, modelID: membership.TenantLLMID},
		{modelType: "embedding", modelName: membership.EmbdID, modelID: membership.TenantEmbdID},
		{modelType: "rerank", modelName: membership.RerankID, modelID: membership.TenantRerankID},
		{modelType: "asr", modelName: membership.ASRID, modelID: membership.TenantASRID},
		{modelType: "vision", modelName: membership.Img2TxtID, modelID: membership.TenantImg2TxtID},
		{modelType: "ocr", modelName: ptrStringValue(membership.OCRID), modelID: membership.TenantOCRID},
		{modelType: "tts", modelName: ptrStringValue(membership.TTSID), modelID: membership.TenantTTSID},
		{modelType: "decision", modelName: ptrStringValue(membership.DecisionID), modelID: membership.TenantDecisionID},
	}
	factory := NewModelFactory()
	result := make([]ModelItem, 0, len(models))
	for _, model := range models {
		modelRef := ptrStringValue(model.modelID)
		if modelRef == "" {
			modelRef = model.modelName
		}
		if strings.TrimSpace(modelRef) == "" {
			continue
		}
		_, _, modelType, err := defaultModelFields(model.modelType)
		if err != nil {
			continue
		}
		info, err := factory.ResolveInfo(permission.WithTenantID(ctx, tenantID), modelType, modelRef)
		if err != nil || info == nil {
			continue
		}
		modelID := info.ID
		if modelID == "" {
			modelID = ptrStringValue(model.modelID)
		}
		result = append(result, ModelItem{
			ModelProvider: &info.ProviderName,
			ModelInstance: &info.InstanceName,
			ModelName:     &info.Name,
			ModelID:       modelID,
			ModelType:     model.modelType,
			Enable:        true,
		})
	}
	return result, nil
}