feat(backends): add system backend, refactor (#6059)

- Add a system backend path - Refactor and consolidate system information in system state - Use system state in all the components to figure out the system paths to used whenever needed - Refactor BackendConfig -> ModelConfig. This was otherway misleading as now we do have a backend configuration which is not the model config. Signed-off-by: Ettore Di Giacinto <mudler@localai.io>
2026-05-25 01:02:05 -04:00 · 2025-08-14 19:38:26 +02:00
parent 253b7537dc
commit 089efe05fd
85 changed files with 999 additions and 652 deletions
--- a/core/config/application_config.go
+++ b/core/config/application_config.go
@@ -6,6 +6,7 @@ import (
 	"regexp"
 	"time"

+	"github.com/mudler/LocalAI/pkg/system"
 	"github.com/mudler/LocalAI/pkg/xsysinfo"
 	"github.com/rs/zerolog/log"
 )
@@ -13,8 +14,7 @@ import (
 type ApplicationConfig struct {
 	Context                             context.Context
 	ConfigFile                          string
-	ModelPath                           string
-	BackendsPath                        string
+	SystemState                         *system.SystemState
 	ExternalBackends                    []string
 	UploadLimitMB, Threads, ContextSize int
 	F16                                 bool
@@ -86,15 +86,9 @@ func WithModelsURL(urls ...string) AppOption {
 	}
 }

-func WithModelPath(path string) AppOption {
+func WithSystemState(state *system.SystemState) AppOption {
 	return func(o *ApplicationConfig) {
-		o.ModelPath = path
-	}
-}
-
-func WithBackendsPath(path string) AppOption {
-	return func(o *ApplicationConfig) {
-		o.BackendsPath = path
+		o.SystemState = state
 	}
 }

@@ -379,7 +373,7 @@ func (o *ApplicationConfig) ToConfigLoaderOptions() []ConfigLoaderOption {
 		LoadOptionDebug(o.Debug),
 		LoadOptionF16(o.F16),
 		LoadOptionThreads(o.Threads),
-		ModelPath(o.ModelPath),
+		ModelPath(o.SystemState.Model.ModelsPath),
 	}
 }

--- a/core/config/backend_config.go
+++ b/core/config/backend_config.go
@@ -24,20 +24,20 @@ type TTSConfig struct {
 	AudioPath string `yaml:"audio_path"`
 }

-type BackendConfig struct {
+type ModelConfig struct {
 	schema.PredictionOptions `yaml:"parameters"`
 	Name                     string `yaml:"name"`

-	F16                 *bool                  `yaml:"f16"`
-	Threads             *int                   `yaml:"threads"`
-	Debug               *bool                  `yaml:"debug"`
-	Roles               map[string]string      `yaml:"roles"`
-	Embeddings          *bool                  `yaml:"embeddings"`
-	Backend             string                 `yaml:"backend"`
-	TemplateConfig      TemplateConfig         `yaml:"template"`
-	KnownUsecaseStrings []string               `yaml:"known_usecases"`
-	KnownUsecases       *BackendConfigUsecases `yaml:"-"`
-	Pipeline            Pipeline               `yaml:"pipeline"`
+	F16                 *bool                `yaml:"f16"`
+	Threads             *int                 `yaml:"threads"`
+	Debug               *bool                `yaml:"debug"`
+	Roles               map[string]string    `yaml:"roles"`
+	Embeddings          *bool                `yaml:"embeddings"`
+	Backend             string               `yaml:"backend"`
+	TemplateConfig      TemplateConfig       `yaml:"template"`
+	KnownUsecaseStrings []string             `yaml:"known_usecases"`
+	KnownUsecases       *ModelConfigUsecases `yaml:"-"`
+	Pipeline            Pipeline             `yaml:"pipeline"`

 	PromptStrings, InputStrings                []string               `yaml:"-"`
 	InputToken                                 [][]int                `yaml:"-"`
@@ -217,18 +217,18 @@ type TemplateConfig struct {
 	ReplyPrefix string `yaml:"reply_prefix"`
 }

-func (c *BackendConfig) UnmarshalYAML(value *yaml.Node) error {
-	type BCAlias BackendConfig
+func (c *ModelConfig) UnmarshalYAML(value *yaml.Node) error {
+	type BCAlias ModelConfig
 	var aux BCAlias
 	if err := value.Decode(&aux); err != nil {
 		return err
 	}
-	*c = BackendConfig(aux)
+	*c = ModelConfig(aux)

 	c.KnownUsecases = GetUsecasesFromYAML(c.KnownUsecaseStrings)
 	// Make sure the usecases are valid, we rewrite with what we identified
 	c.KnownUsecaseStrings = []string{}
-	for k, usecase := range GetAllBackendConfigUsecases() {
+	for k, usecase := range GetAllModelConfigUsecases() {
 		if c.HasUsecases(usecase) {
 			c.KnownUsecaseStrings = append(c.KnownUsecaseStrings, k)
 		}
@@ -236,25 +236,25 @@ func (c *BackendConfig) UnmarshalYAML(value *yaml.Node) error {
 	return nil
 }

-func (c *BackendConfig) SetFunctionCallString(s string) {
+func (c *ModelConfig) SetFunctionCallString(s string) {
 	c.functionCallString = s
 }

-func (c *BackendConfig) SetFunctionCallNameString(s string) {
+func (c *ModelConfig) SetFunctionCallNameString(s string) {
 	c.functionCallNameString = s
 }

-func (c *BackendConfig) ShouldUseFunctions() bool {
+func (c *ModelConfig) ShouldUseFunctions() bool {
 	return ((c.functionCallString != "none" || c.functionCallString == "") || c.ShouldCallSpecificFunction())
 }

-func (c *BackendConfig) ShouldCallSpecificFunction() bool {
+func (c *ModelConfig) ShouldCallSpecificFunction() bool {
 	return len(c.functionCallNameString) > 0
 }

 // MMProjFileName returns the filename of the MMProj file
 // If the MMProj is a URL, it will return the MD5 of the URL which is the filename
-func (c *BackendConfig) MMProjFileName() string {
+func (c *ModelConfig) MMProjFileName() string {
 	uri := downloader.URI(c.MMProj)
 	if uri.LooksLikeURL() {
 		f, _ := uri.FilenameFromUrl()
@@ -264,19 +264,19 @@ func (c *BackendConfig) MMProjFileName() string {
 	return c.MMProj
 }

-func (c *BackendConfig) IsMMProjURL() bool {
+func (c *ModelConfig) IsMMProjURL() bool {
 	uri := downloader.URI(c.MMProj)
 	return uri.LooksLikeURL()
 }

-func (c *BackendConfig) IsModelURL() bool {
+func (c *ModelConfig) IsModelURL() bool {
 	uri := downloader.URI(c.Model)
 	return uri.LooksLikeURL()
 }

 // ModelFileName returns the filename of the model
 // If the model is a URL, it will return the MD5 of the URL which is the filename
-func (c *BackendConfig) ModelFileName() string {
+func (c *ModelConfig) ModelFileName() string {
 	uri := downloader.URI(c.Model)
 	if uri.LooksLikeURL() {
 		f, _ := uri.FilenameFromUrl()
@@ -286,7 +286,7 @@ func (c *BackendConfig) ModelFileName() string {
 	return c.Model
 }

-func (c *BackendConfig) FunctionToCall() string {
+func (c *ModelConfig) FunctionToCall() string {
 	if c.functionCallNameString != "" &&
 		c.functionCallNameString != "none" && c.functionCallNameString != "auto" {
 		return c.functionCallNameString
@@ -295,7 +295,7 @@ func (c *BackendConfig) FunctionToCall() string {
 	return c.functionCallString
 }

-func (cfg *BackendConfig) SetDefaults(opts ...ConfigLoaderOption) {
+func (cfg *ModelConfig) SetDefaults(opts ...ConfigLoaderOption) {
 	lo := &LoadOptions{}
 	lo.Apply(opts...)

@@ -411,7 +411,7 @@ func (cfg *BackendConfig) SetDefaults(opts ...ConfigLoaderOption) {
 	guessDefaultsFromFile(cfg, lo.modelPath, ctx)
 }

-func (c *BackendConfig) Validate() bool {
+func (c *ModelConfig) Validate() bool {
 	downloadedFileNames := []string{}
 	for _, f := range c.DownloadFiles {
 		downloadedFileNames = append(downloadedFileNames, f.Filename)
@@ -438,34 +438,34 @@ func (c *BackendConfig) Validate() bool {
 	return true
 }

-func (c *BackendConfig) HasTemplate() bool {
+func (c *ModelConfig) HasTemplate() bool {
 	return c.TemplateConfig.Completion != "" || c.TemplateConfig.Edit != "" || c.TemplateConfig.Chat != "" || c.TemplateConfig.ChatMessage != ""
 }

-type BackendConfigUsecases int
+type ModelConfigUsecases int

 const (
-	FLAG_ANY              BackendConfigUsecases = 0b000000000000
-	FLAG_CHAT             BackendConfigUsecases = 0b000000000001
-	FLAG_COMPLETION       BackendConfigUsecases = 0b000000000010
-	FLAG_EDIT             BackendConfigUsecases = 0b000000000100
-	FLAG_EMBEDDINGS       BackendConfigUsecases = 0b000000001000
-	FLAG_RERANK           BackendConfigUsecases = 0b000000010000
-	FLAG_IMAGE            BackendConfigUsecases = 0b000000100000
-	FLAG_TRANSCRIPT       BackendConfigUsecases = 0b000001000000
-	FLAG_TTS              BackendConfigUsecases = 0b000010000000
-	FLAG_SOUND_GENERATION BackendConfigUsecases = 0b000100000000
-	FLAG_TOKENIZE         BackendConfigUsecases = 0b001000000000
-	FLAG_VAD              BackendConfigUsecases = 0b010000000000
-	FLAG_VIDEO            BackendConfigUsecases = 0b100000000000
-	FLAG_DETECTION        BackendConfigUsecases = 0b1000000000000
+	FLAG_ANY              ModelConfigUsecases = 0b000000000000
+	FLAG_CHAT             ModelConfigUsecases = 0b000000000001
+	FLAG_COMPLETION       ModelConfigUsecases = 0b000000000010
+	FLAG_EDIT             ModelConfigUsecases = 0b000000000100
+	FLAG_EMBEDDINGS       ModelConfigUsecases = 0b000000001000
+	FLAG_RERANK           ModelConfigUsecases = 0b000000010000
+	FLAG_IMAGE            ModelConfigUsecases = 0b000000100000
+	FLAG_TRANSCRIPT       ModelConfigUsecases = 0b000001000000
+	FLAG_TTS              ModelConfigUsecases = 0b000010000000
+	FLAG_SOUND_GENERATION ModelConfigUsecases = 0b000100000000
+	FLAG_TOKENIZE         ModelConfigUsecases = 0b001000000000
+	FLAG_VAD              ModelConfigUsecases = 0b010000000000
+	FLAG_VIDEO            ModelConfigUsecases = 0b100000000000
+	FLAG_DETECTION        ModelConfigUsecases = 0b1000000000000

 	// Common Subsets
-	FLAG_LLM BackendConfigUsecases = FLAG_CHAT | FLAG_COMPLETION | FLAG_EDIT
+	FLAG_LLM ModelConfigUsecases = FLAG_CHAT | FLAG_COMPLETION | FLAG_EDIT
 )

-func GetAllBackendConfigUsecases() map[string]BackendConfigUsecases {
-	return map[string]BackendConfigUsecases{
+func GetAllModelConfigUsecases() map[string]ModelConfigUsecases {
+	return map[string]ModelConfigUsecases{
 		"FLAG_ANY":              FLAG_ANY,
 		"FLAG_CHAT":             FLAG_CHAT,
 		"FLAG_COMPLETION":       FLAG_COMPLETION,
@@ -488,12 +488,12 @@ func stringToFlag(s string) string {
 	return "FLAG_" + strings.ToUpper(s)
 }

-func GetUsecasesFromYAML(input []string) *BackendConfigUsecases {
+func GetUsecasesFromYAML(input []string) *ModelConfigUsecases {
 	if len(input) == 0 {
 		return nil
 	}
 	result := FLAG_ANY
-	flags := GetAllBackendConfigUsecases()
+	flags := GetAllModelConfigUsecases()
 	for _, str := range input {
 		flag, exists := flags[stringToFlag(str)]
 		if exists {
@@ -503,8 +503,8 @@ func GetUsecasesFromYAML(input []string) *BackendConfigUsecases {
 	return &result
 }

-// HasUsecases examines a BackendConfig and determines which endpoints have a chance of success.
-func (c *BackendConfig) HasUsecases(u BackendConfigUsecases) bool {
+// HasUsecases examines a ModelConfig and determines which endpoints have a chance of success.
+func (c *ModelConfig) HasUsecases(u ModelConfigUsecases) bool {
 	if (c.KnownUsecases != nil) && ((u & *c.KnownUsecases) == u) {
 		return true
 	}
@@ -514,7 +514,7 @@ func (c *BackendConfig) HasUsecases(u BackendConfigUsecases) bool {
 // GuessUsecases is a **heuristic based** function, as the backend in question may not be loaded yet, and the config may not record what it's useful at.
 // In its current state, this function should ideally check for properties of the config like templates, rather than the direct backend name checks for the lower half.
 // This avoids the maintenance burden of updating this list for each new backend - but unfortunately, that's the best option for some services currently.
-func (c *BackendConfig) GuessUsecases(u BackendConfigUsecases) bool {
+func (c *ModelConfig) GuessUsecases(u ModelConfigUsecases) bool {
 	if (u & FLAG_CHAT) == FLAG_CHAT {
 		if c.TemplateConfig.Chat == "" && c.TemplateConfig.ChatMessage == "" {
 			return false
--- a/core/config/backend_config_filter.go
+++ b/core/config/backend_config_filter.go
@@ -2,11 +2,11 @@ package config

 import "regexp"

-type BackendConfigFilterFn func(string, *BackendConfig) bool
+type ModelConfigFilterFn func(string, *ModelConfig) bool

-func NoFilterFn(_ string, _ *BackendConfig) bool { return true }
+func NoFilterFn(_ string, _ *ModelConfig) bool { return true }

-func BuildNameFilterFn(filter string) (BackendConfigFilterFn, error) {
+func BuildNameFilterFn(filter string) (ModelConfigFilterFn, error) {
 	if filter == "" {
 		return NoFilterFn, nil
 	}
@@ -14,7 +14,7 @@ func BuildNameFilterFn(filter string) (BackendConfigFilterFn, error) {
 	if err != nil {
 		return nil, err
 	}
-	return func(name string, config *BackendConfig) bool {
+	return func(name string, config *ModelConfig) bool {
 		if config != nil {
 			return rxp.MatchString(config.Name)
 		}
@@ -22,11 +22,11 @@ func BuildNameFilterFn(filter string) (BackendConfigFilterFn, error) {
 	}, nil
 }

-func BuildUsecaseFilterFn(usecases BackendConfigUsecases) BackendConfigFilterFn {
+func BuildUsecaseFilterFn(usecases ModelConfigUsecases) ModelConfigFilterFn {
 	if usecases == FLAG_ANY {
 		return NoFilterFn
 	}
-	return func(name string, config *BackendConfig) bool {
+	return func(name string, config *ModelConfig) bool {
 		if config == nil {
 			return false // TODO: Potentially make this a param, for now, no known usecase to include
 		}
--- a/core/config/backend_config_loader.go
+++ b/core/config/backend_config_loader.go
@@ -18,15 +18,15 @@ import (
 	"gopkg.in/yaml.v3"
 )

-type BackendConfigLoader struct {
-	configs   map[string]BackendConfig
+type ModelConfigLoader struct {
+	configs   map[string]ModelConfig
 	modelPath string
 	sync.Mutex
 }

-func NewBackendConfigLoader(modelPath string) *BackendConfigLoader {
-	return &BackendConfigLoader{
-		configs:   make(map[string]BackendConfig),
+func NewModelConfigLoader(modelPath string) *ModelConfigLoader {
+	return &ModelConfigLoader{
+		configs:   make(map[string]ModelConfig),
 		modelPath: modelPath,
 	}
 }
@@ -77,14 +77,14 @@ func (lo *LoadOptions) Apply(options ...ConfigLoaderOption) {
 }

 // TODO: either in the next PR or the next commit, I want to merge these down into a single function that looks at the first few characters of the file to determine if we need to deserialize to []BackendConfig or BackendConfig
-func readMultipleBackendConfigsFromFile(file string, opts ...ConfigLoaderOption) ([]*BackendConfig, error) {
-	c := &[]*BackendConfig{}
+func readMultipleModelConfigsFromFile(file string, opts ...ConfigLoaderOption) ([]*ModelConfig, error) {
+	c := &[]*ModelConfig{}
 	f, err := os.ReadFile(file)
 	if err != nil {
-		return nil, fmt.Errorf("readMultipleBackendConfigsFromFile cannot read config file %q: %w", file, err)
+		return nil, fmt.Errorf("readMultipleModelConfigsFromFile cannot read config file %q: %w", file, err)
 	}
 	if err := yaml.Unmarshal(f, c); err != nil {
-		return nil, fmt.Errorf("readMultipleBackendConfigsFromFile cannot unmarshal config file %q: %w", file, err)
+		return nil, fmt.Errorf("readMultipleModelConfigsFromFile cannot unmarshal config file %q: %w", file, err)
 	}

 	for _, cc := range *c {
@@ -94,17 +94,17 @@ func readMultipleBackendConfigsFromFile(file string, opts ...ConfigLoaderOption)
 	return *c, nil
 }

-func readBackendConfigFromFile(file string, opts ...ConfigLoaderOption) (*BackendConfig, error) {
+func readModelConfigFromFile(file string, opts ...ConfigLoaderOption) (*ModelConfig, error) {
 	lo := &LoadOptions{}
 	lo.Apply(opts...)

-	c := &BackendConfig{}
+	c := &ModelConfig{}
 	f, err := os.ReadFile(file)
 	if err != nil {
-		return nil, fmt.Errorf("readBackendConfigFromFile cannot read config file %q: %w", file, err)
+		return nil, fmt.Errorf("readModelConfigFromFile cannot read config file %q: %w", file, err)
 	}
 	if err := yaml.Unmarshal(f, c); err != nil {
-		return nil, fmt.Errorf("readBackendConfigFromFile cannot unmarshal config file %q: %w", file, err)
+		return nil, fmt.Errorf("readModelConfigFromFile cannot unmarshal config file %q: %w", file, err)
 	}

 	c.SetDefaults(opts...)
@@ -112,10 +112,10 @@ func readBackendConfigFromFile(file string, opts ...ConfigLoaderOption) (*Backen
 }

 // Load a config file for a model
-func (bcl *BackendConfigLoader) LoadBackendConfigFileByName(modelName, modelPath string, opts ...ConfigLoaderOption) (*BackendConfig, error) {
+func (bcl *ModelConfigLoader) LoadModelConfigFileByName(modelName, modelPath string, opts ...ConfigLoaderOption) (*ModelConfig, error) {

 	// Load a config file if present after the model name
-	cfg := &BackendConfig{
+	cfg := &ModelConfig{
 		PredictionOptions: schema.PredictionOptions{
 			BasicModelRequest: schema.BasicModelRequest{
 				Model: modelName,
@@ -123,19 +123,19 @@ func (bcl *BackendConfigLoader) LoadBackendConfigFileByName(modelName, modelPath
 		},
 	}

-	cfgExisting, exists := bcl.GetBackendConfig(modelName)
+	cfgExisting, exists := bcl.GetModelConfig(modelName)
 	if exists {
 		cfg = &cfgExisting
 	} else {
 		// Try loading a model config file
 		modelConfig := filepath.Join(modelPath, modelName+".yaml")
 		if _, err := os.Stat(modelConfig); err == nil {
-			if err := bcl.LoadBackendConfig(
+			if err := bcl.ReadModelConfig(
 				modelConfig, opts...,
 			); err != nil {
 				return nil, fmt.Errorf("failed loading model config (%s) %s", modelConfig, err.Error())
 			}
-			cfgExisting, exists = bcl.GetBackendConfig(modelName)
+			cfgExisting, exists = bcl.GetModelConfig(modelName)
 			if exists {
 				cfg = &cfgExisting
 			}
@@ -147,20 +147,20 @@ func (bcl *BackendConfigLoader) LoadBackendConfigFileByName(modelName, modelPath
 	return cfg, nil
 }

-func (bcl *BackendConfigLoader) LoadBackendConfigFileByNameDefaultOptions(modelName string, appConfig *ApplicationConfig) (*BackendConfig, error) {
-	return bcl.LoadBackendConfigFileByName(modelName, appConfig.ModelPath,
+func (bcl *ModelConfigLoader) LoadModelConfigFileByNameDefaultOptions(modelName string, appConfig *ApplicationConfig) (*ModelConfig, error) {
+	return bcl.LoadModelConfigFileByName(modelName, appConfig.SystemState.Model.ModelsPath,
 		LoadOptionDebug(appConfig.Debug),
 		LoadOptionThreads(appConfig.Threads),
 		LoadOptionContextSize(appConfig.ContextSize),
 		LoadOptionF16(appConfig.F16),
-		ModelPath(appConfig.ModelPath))
+		ModelPath(appConfig.SystemState.Model.ModelsPath))
 }

 // This format is currently only used when reading a single file at startup, passed in via ApplicationConfig.ConfigFile
-func (bcl *BackendConfigLoader) LoadMultipleBackendConfigsSingleFile(file string, opts ...ConfigLoaderOption) error {
+func (bcl *ModelConfigLoader) LoadMultipleModelConfigsSingleFile(file string, opts ...ConfigLoaderOption) error {
 	bcl.Lock()
 	defer bcl.Unlock()
-	c, err := readMultipleBackendConfigsFromFile(file, opts...)
+	c, err := readMultipleModelConfigsFromFile(file, opts...)
 	if err != nil {
 		return fmt.Errorf("cannot load config file: %w", err)
 	}
@@ -173,12 +173,12 @@ func (bcl *BackendConfigLoader) LoadMultipleBackendConfigsSingleFile(file string
 	return nil
 }

-func (bcl *BackendConfigLoader) LoadBackendConfig(file string, opts ...ConfigLoaderOption) error {
+func (bcl *ModelConfigLoader) ReadModelConfig(file string, opts ...ConfigLoaderOption) error {
 	bcl.Lock()
 	defer bcl.Unlock()
-	c, err := readBackendConfigFromFile(file, opts...)
+	c, err := readModelConfigFromFile(file, opts...)
 	if err != nil {
-		return fmt.Errorf("LoadBackendConfig cannot read config file %q: %w", file, err)
+		return fmt.Errorf("ReadModelConfig cannot read config file %q: %w", file, err)
 	}

 	if c.Validate() {
@@ -190,17 +190,17 @@ func (bcl *BackendConfigLoader) LoadBackendConfig(file string, opts ...ConfigLoa
 	return nil
 }

-func (bcl *BackendConfigLoader) GetBackendConfig(m string) (BackendConfig, bool) {
+func (bcl *ModelConfigLoader) GetModelConfig(m string) (ModelConfig, bool) {
 	bcl.Lock()
 	defer bcl.Unlock()
 	v, exists := bcl.configs[m]
 	return v, exists
 }

-func (bcl *BackendConfigLoader) GetAllBackendConfigs() []BackendConfig {
+func (bcl *ModelConfigLoader) GetAllModelsConfigs() []ModelConfig {
 	bcl.Lock()
 	defer bcl.Unlock()
-	var res []BackendConfig
+	var res []ModelConfig
 	for _, v := range bcl.configs {
 		res = append(res, v)
 	}
@@ -212,10 +212,10 @@ func (bcl *BackendConfigLoader) GetAllBackendConfigs() []BackendConfig {
 	return res
 }

-func (bcl *BackendConfigLoader) GetBackendConfigsByFilter(filter BackendConfigFilterFn) []BackendConfig {
+func (bcl *ModelConfigLoader) GetModelConfigsByFilter(filter ModelConfigFilterFn) []ModelConfig {
 	bcl.Lock()
 	defer bcl.Unlock()
-	var res []BackendConfig
+	var res []ModelConfig

 	if filter == nil {
 		filter = NoFilterFn
@@ -232,14 +232,14 @@ func (bcl *BackendConfigLoader) GetBackendConfigsByFilter(filter BackendConfigFi
 	return res
 }

-func (bcl *BackendConfigLoader) RemoveBackendConfig(m string) {
+func (bcl *ModelConfigLoader) RemoveModelConfig(m string) {
 	bcl.Lock()
 	defer bcl.Unlock()
 	delete(bcl.configs, m)
 }

 // Preload prepare models if they are not local but url or huggingface repositories
-func (bcl *BackendConfigLoader) Preload(modelPath string) error {
+func (bcl *ModelConfigLoader) Preload(modelPath string) error {
 	bcl.Lock()
 	defer bcl.Unlock()

@@ -330,15 +330,15 @@ func (bcl *BackendConfigLoader) Preload(modelPath string) error {
 	return nil
 }

-// LoadBackendConfigsFromPath reads all the configurations of the models from a path
+// LoadModelConfigsFromPath reads all the configurations of the models from a path
 // (non-recursive)
-func (bcl *BackendConfigLoader) LoadBackendConfigsFromPath(path string, opts ...ConfigLoaderOption) error {
+func (bcl *ModelConfigLoader) LoadModelConfigsFromPath(path string, opts ...ConfigLoaderOption) error {
 	bcl.Lock()
 	defer bcl.Unlock()

 	entries, err := os.ReadDir(path)
 	if err != nil {
-		return fmt.Errorf("LoadBackendConfigsFromPath cannot read directory '%s': %w", path, err)
+		return fmt.Errorf("LoadModelConfigsFromPath cannot read directory '%s': %w", path, err)
 	}
 	files := make([]fs.FileInfo, 0, len(entries))
 	for _, entry := range entries {
@@ -354,9 +354,9 @@ func (bcl *BackendConfigLoader) LoadBackendConfigsFromPath(path string, opts ...
 			strings.HasPrefix(file.Name(), ".") {
 			continue
 		}
-		c, err := readBackendConfigFromFile(filepath.Join(path, file.Name()), opts...)
+		c, err := readModelConfigFromFile(filepath.Join(path, file.Name()), opts...)
 		if err != nil {
-			log.Error().Err(err).Str("File Name", file.Name()).Msgf("LoadBackendConfigsFromPath cannot read config file")
+			log.Error().Err(err).Str("File Name", file.Name()).Msgf("LoadModelConfigsFromPath cannot read config file")
 			continue
 		}
 		if c.Validate() {
--- a/core/config/backend_config_test.go
+++ b/core/config/backend_config_test.go
@@ -25,7 +25,7 @@ known_usecases:
 - COMPLETION
 `)
 			Expect(err).ToNot(HaveOccurred())
-			config, err := readBackendConfigFromFile(tmp.Name())
+			config, err := readModelConfigFromFile(tmp.Name())
 			Expect(err).To(BeNil())
 			Expect(config).ToNot(BeNil())
 			Expect(config.Validate()).To(BeFalse())
@@ -41,7 +41,7 @@ backend: "foo-bar"
 parameters:
  model: "foo-bar"`)
 			Expect(err).ToNot(HaveOccurred())
-			config, err := readBackendConfigFromFile(tmp.Name())
+			config, err := readModelConfigFromFile(tmp.Name())
 			Expect(err).To(BeNil())
 			Expect(config).ToNot(BeNil())
 			// two configs in config.yaml
@@ -58,7 +58,7 @@ parameters:
 			defer os.Remove(tmp.Name())
 			_, err = io.Copy(tmp, resp.Body)
 			Expect(err).To(BeNil())
-			config, err = readBackendConfigFromFile(tmp.Name())
+			config, err = readModelConfigFromFile(tmp.Name())
 			Expect(err).To(BeNil())
 			Expect(config).ToNot(BeNil())
 			// two configs in config.yaml
@@ -68,12 +68,12 @@ parameters:
 	})
 	It("Properly handles backend usecase matching", func() {

-		a := BackendConfig{
+		a := ModelConfig{
 			Name: "a",
 		}
 		Expect(a.HasUsecases(FLAG_ANY)).To(BeTrue()) // FLAG_ANY just means the config _exists_ essentially.

-		b := BackendConfig{
+		b := ModelConfig{
 			Name:    "b",
 			Backend: "stablediffusion",
 		}
@@ -81,7 +81,7 @@ parameters:
 		Expect(b.HasUsecases(FLAG_IMAGE)).To(BeTrue())
 		Expect(b.HasUsecases(FLAG_CHAT)).To(BeFalse())

-		c := BackendConfig{
+		c := ModelConfig{
 			Name:    "c",
 			Backend: "llama-cpp",
 			TemplateConfig: TemplateConfig{
@@ -93,7 +93,7 @@ parameters:
 		Expect(c.HasUsecases(FLAG_COMPLETION)).To(BeFalse())
 		Expect(c.HasUsecases(FLAG_CHAT)).To(BeTrue())

-		d := BackendConfig{
+		d := ModelConfig{
 			Name:    "d",
 			Backend: "llama-cpp",
 			TemplateConfig: TemplateConfig{
@@ -107,7 +107,7 @@ parameters:
 		Expect(d.HasUsecases(FLAG_CHAT)).To(BeTrue())

 		trueValue := true
-		e := BackendConfig{
+		e := ModelConfig{
 			Name:    "e",
 			Backend: "llama-cpp",
 			TemplateConfig: TemplateConfig{
@@ -122,7 +122,7 @@ parameters:
 		Expect(e.HasUsecases(FLAG_CHAT)).To(BeFalse())
 		Expect(e.HasUsecases(FLAG_EMBEDDINGS)).To(BeTrue())

-		f := BackendConfig{
+		f := ModelConfig{
 			Name:    "f",
 			Backend: "piper",
 		}
@@ -130,7 +130,7 @@ parameters:
 		Expect(f.HasUsecases(FLAG_TTS)).To(BeTrue())
 		Expect(f.HasUsecases(FLAG_CHAT)).To(BeFalse())

-		g := BackendConfig{
+		g := ModelConfig{
 			Name:    "g",
 			Backend: "whisper",
 		}
@@ -138,7 +138,7 @@ parameters:
 		Expect(g.HasUsecases(FLAG_TRANSCRIPT)).To(BeTrue())
 		Expect(g.HasUsecases(FLAG_TTS)).To(BeFalse())

-		h := BackendConfig{
+		h := ModelConfig{
 			Name:    "h",
 			Backend: "transformers-musicgen",
 		}
@@ -148,7 +148,7 @@ parameters:
 		Expect(h.HasUsecases(FLAG_SOUND_GENERATION)).To(BeTrue())

 		knownUsecases := FLAG_CHAT | FLAG_COMPLETION
-		i := BackendConfig{
+		i := ModelConfig{
 			Name:    "i",
 			Backend: "whisper",
 			// Earlier test checks parsing, this just needs to set final values
--- a/core/config/config_test.go
+++ b/core/config/config_test.go
@@ -16,7 +16,7 @@ var _ = Describe("Test cases for config related functions", func() {
 	Context("Test Read configuration functions", func() {
 		configFile = os.Getenv("CONFIG_FILE")
 		It("Test readConfigFile", func() {
-			config, err := readMultipleBackendConfigsFromFile(configFile)
+			config, err := readMultipleModelConfigsFromFile(configFile)
 			Expect(err).To(BeNil())
 			Expect(config).ToNot(BeNil())
 			// two configs in config.yaml
@@ -26,11 +26,11 @@ var _ = Describe("Test cases for config related functions", func() {

 		It("Test LoadConfigs", func() {

-			bcl := NewBackendConfigLoader(os.Getenv("MODELS_PATH"))
-			err := bcl.LoadBackendConfigsFromPath(os.Getenv("MODELS_PATH"))
+			bcl := NewModelConfigLoader(os.Getenv("MODELS_PATH"))
+			err := bcl.LoadModelConfigsFromPath(os.Getenv("MODELS_PATH"))

 			Expect(err).To(BeNil())
-			configs := bcl.GetAllBackendConfigs()
+			configs := bcl.GetAllModelsConfigs()
 			loadedModelNames := []string{}
 			for _, v := range configs {
 				loadedModelNames = append(loadedModelNames, v.Name)
@@ -51,10 +51,10 @@ var _ = Describe("Test cases for config related functions", func() {

 		It("Test new loadconfig", func() {

-			bcl := NewBackendConfigLoader(os.Getenv("MODELS_PATH"))
-			err := bcl.LoadBackendConfigsFromPath(os.Getenv("MODELS_PATH"))
+			bcl := NewModelConfigLoader(os.Getenv("MODELS_PATH"))
+			err := bcl.LoadModelConfigsFromPath(os.Getenv("MODELS_PATH"))
 			Expect(err).To(BeNil())
-			configs := bcl.GetAllBackendConfigs()
+			configs := bcl.GetAllModelsConfigs()
 			loadedModelNames := []string{}
 			for _, v := range configs {
 				loadedModelNames = append(loadedModelNames, v.Name)
@@ -90,14 +90,14 @@ options:
 			err = os.WriteFile(modelFile, []byte(model), 0644)
 			Expect(err).ToNot(HaveOccurred())

-			err = bcl.LoadBackendConfigsFromPath(tmpdir)
+			err = bcl.LoadModelConfigsFromPath(tmpdir)
 			Expect(err).ToNot(HaveOccurred())

-			configs = bcl.GetAllBackendConfigs()
+			configs = bcl.GetAllModelsConfigs()
 			Expect(len(configs)).ToNot(Equal(totalModels))

 			loadedModelNames = []string{}
-			var testModel BackendConfig
+			var testModel ModelConfig
 			for _, v := range configs {
 				loadedModelNames = append(loadedModelNames, v.Name)
 				if v.Name == "test-model" {
--- a/core/config/gguf.go
+++ b/core/config/gguf.go
@@ -146,7 +146,7 @@ var knownTemplates = map[string]familyType{
 	`{{ bos_token }}{% for message in messages %}{% if (message['role'] == 'user') != (loop.index0 % 2 == 0) %}{{ raise_exception('Conversation roles must alternate user/assistant/user/assistant/...') }}{% endif %}{% if message['role'] == 'user' %}{{ '[INST] ' + message['content'] + ' [/INST]' }}{% elif message['role'] == 'assistant' %}{{ message['content'] + eos_token}}{% else %}{{ raise_exception('Only user and assistant roles are supported!') }}{% endif %}{% endfor %}`: Mistral03,
 }

-func guessGGUFFromFile(cfg *BackendConfig, f *gguf.GGUFFile, defaultCtx int) {
+func guessGGUFFromFile(cfg *ModelConfig, f *gguf.GGUFFile, defaultCtx int) {

 	if defaultCtx == 0 && cfg.ContextSize == nil {
 		ctxSize := f.EstimateLLaMACppRun().ContextSize
--- a/core/config/guesser.go
+++ b/core/config/guesser.go
@@ -8,7 +8,7 @@ import (
 	"github.com/rs/zerolog/log"
 )

-func guessDefaultsFromFile(cfg *BackendConfig, modelPath string, defaultCtx int) {
+func guessDefaultsFromFile(cfg *ModelConfig, modelPath string, defaultCtx int) {
 	if os.Getenv("LOCALAI_DISABLE_GUESSING") == "true" {
 		log.Debug().Msgf("guessDefaultsFromFile: %s", "guessing disabled with LOCALAI_DISABLE_GUESSING")
 		return