refactor(config): restructure config to use nested model objects (#577)

* refactor(config): restructure config to use nested model objects

This commit refactors the RouterConfig structure to organize related
configuration fields into nested objects for better modularity and clarity:

- BertModel: Groups BERT similarity model configuration (ModelID, Threshold, UseCPU)
- MCPCategoryModel: Groups MCP category classifier configuration (Enabled, TransportType, Command, Args, etc.)
- SemanticCache: Groups semantic cache configuration (Enabled, BackendType, MaxEntries, TTLSeconds, etc.)

Updated all references across the codebase:
- pkg/apiserver/route_model_info.go: Access BERT config via BertModel nested object
- pkg/classification/classifier.go: Check MCP enabled via MCPCategoryModel.Enabled
- pkg/classification/mcp_classifier.go: Access all MCP config via MCPCategoryModel
- pkg/extproc/request_handler.go: Access cache config via SemanticCache.Enabled
- pkg/extproc/router.go: Access BERT and cache config via nested objects
- pkg/services/classification.go: Check MCP enabled via MCPCategoryModel.Enabled

This improves code organization and makes the configuration structure
more maintainable and easier to understand.

Signed-off-by: bitliu <[email protected]>

* test

Signed-off-by: bitliu <[email protected]>

---------

Signed-off-by: bitliu <[email protected]>

Author: Xunzhuo

src/semantic-router/pkg/apiserver/route_model_info.go

@@ -130,15 +130,15 @@ func (s *ClassificationAPIServer) getLoadedModelsInfo() []ModelInfo {
 	}
 
 	// BERT similarity model
-	if s.config.ModelID != "" {
+	if s.config.BertModel.ModelID != "" {
 		models = append(models, ModelInfo{
 			Name:      "bert_similarity_model",
 			Type:      "similarity",
 			Loaded:    true,
-			ModelPath: s.config.ModelID,
+			ModelPath: s.config.BertModel.ModelID,
 			Metadata: map[string]string{
 				"model_type": "sentence_transformer",
-				"threshold":  fmt.Sprintf("%.2f", s.config.Threshold),
+				"threshold":  fmt.Sprintf("%.2f", s.config.BertModel.Threshold),
 				"use_cpu":    fmt.Sprintf("%t", s.config.BertModel.UseCPU),
 			},
 		})

src/semantic-router/pkg/classification/classifier.go

@@ -329,7 +329,7 @@ func NewClassifier(cfg *config.RouterConfig, categoryMapping *CategoryMapping, p
 	// Note: Both in-tree and MCP classifiers can be configured simultaneously.
 	// At runtime, in-tree classifier will be tried first, with MCP as a fallback.
 	// This allows flexible deployment scenarios (e.g., gradual migration, A/B testing).
-	if cfg.Enabled {
+	if cfg.MCPCategoryModel.Enabled {
 		mcpInit := createMCPCategoryInitializer()
 		mcpInf := createMCPCategoryInference(mcpInit)
 		options = append(options, withMCPCategory(mcpInit, mcpInf))

src/semantic-router/pkg/classification/classifier_test.go

@@ -2335,10 +2335,38 @@ var _ = Describe("Classifier MCP Methods", func() {
 	BeforeEach(func() {
 		mockClient = &MockMCPClient{}
 		cfg := &config.RouterConfig{}
-		cfg.Enabled = true
-		cfg.ToolName = "classify_text"
+		cfg.MCPCategoryModel.Enabled = true
+		cfg.MCPCategoryModel.ToolName = "classify_text"
 		cfg.MCPCategoryModel.Threshold = 0.5
-		cfg.TimeoutSeconds = 30
+		cfg.MCPCategoryModel.TimeoutSeconds = 30
+
+		// Add Categories configuration for entropy-based tests
+		cfg.Categories = []config.Category{
+			{
+				CategoryMetadata: config.CategoryMetadata{Name: "tech"},
+				ModelScores: []config.ModelScore{{
+					Model:                 "phi4",
+					Score:                 0.8,
+					ModelReasoningControl: config.ModelReasoningControl{UseReasoning: lo.ToPtr(false)},
+				}},
+			},
+			{
+				CategoryMetadata: config.CategoryMetadata{Name: "sports"},
+				ModelScores: []config.ModelScore{{
+					Model:                 "phi4",
+					Score:                 0.8,
+					ModelReasoningControl: config.ModelReasoningControl{UseReasoning: lo.ToPtr(false)},
+				}},
+			},
+			{
+				CategoryMetadata: config.CategoryMetadata{Name: "politics"},
+				ModelScores: []config.ModelScore{{
+					Model:                 "deepseek-v31",
+					Score:                 0.9,
+					ModelReasoningControl: config.ModelReasoningControl{UseReasoning: lo.ToPtr(true)},
+				}},
+			},
+		}
 
 		// Create MCP classifier manually and inject mock client
 		mcpClassifier := &MCPCategoryClassifier{
@@ -2374,7 +2402,7 @@ var _ = Describe("Classifier MCP Methods", func() {
 		})
 
 		It("should return false when not enabled", func() {
-			classifier.Config.Enabled = false
+			classifier.Config.MCPCategoryModel.Enabled = false
 			Expect(classifier.IsMCPCategoryEnabled()).To(BeFalse())
 		})
 
@@ -2387,7 +2415,7 @@ var _ = Describe("Classifier MCP Methods", func() {
 	Describe("classifyCategoryMCP", func() {
 		Context("when MCP is not enabled", func() {
 			It("should return error", func() {
-				classifier.Config.Enabled = false
+				classifier.Config.MCPCategoryModel.Enabled = false
 				_, _, err := classifier.classifyCategoryMCP("test text")
 				Expect(err).To(HaveOccurred())
 				Expect(err.Error()).To(ContainSubstring("not properly configured"))
@@ -2463,35 +2491,6 @@ var _ = Describe("Classifier MCP Methods", func() {
 	})
 
 	Describe("classifyCategoryWithEntropyMCP", func() {
-		BeforeEach(func() {
-			classifier.Config.Categories = []config.Category{
-				{
-					CategoryMetadata: config.CategoryMetadata{Name: "tech"},
-					ModelScores: []config.ModelScore{{
-						Model:                 "phi4",
-						Score:                 0.8,
-						ModelReasoningControl: config.ModelReasoningControl{UseReasoning: lo.ToPtr(false)},
-					}},
-				},
-				{
-					CategoryMetadata: config.CategoryMetadata{Name: "sports"},
-					ModelScores: []config.ModelScore{{
-						Model:                 "phi4",
-						Score:                 0.8,
-						ModelReasoningControl: config.ModelReasoningControl{UseReasoning: lo.ToPtr(false)},
-					}},
-				},
-				{
-					CategoryMetadata: config.CategoryMetadata{Name: "politics"},
-					ModelScores: []config.ModelScore{{
-						Model:                 "deepseek-v31",
-						Score:                 0.9,
-						ModelReasoningControl: config.ModelReasoningControl{UseReasoning: lo.ToPtr(true)},
-					}},
-				},
-			}
-		})
-
 		Context("when MCP returns probabilities", func() {
 			It("should return category with entropy decision", func() {
 				mockClient.callToolResult = &mcp.CallToolResult{
@@ -2536,7 +2535,7 @@ var _ = Describe("Classifier MCP Methods", func() {
 	Describe("initializeMCPCategoryClassifier", func() {
 		Context("when MCP is not enabled", func() {
 			It("should return error", func() {
-				classifier.Config.Enabled = false
+				classifier.Config.MCPCategoryModel.Enabled = false
 				err := classifier.initializeMCPCategoryClassifier()
 				Expect(err).To(HaveOccurred())
 				Expect(err.Error()).To(ContainSubstring("not properly configured"))

src/semantic-router/pkg/classification/mcp_classifier.go

@@ -75,7 +75,7 @@ func (m *MCPCategoryClassifier) Init(cfg *config.RouterConfig) error {
 	}
 
 	// Validate MCP configuration
-	if !cfg.Enabled {
+	if !cfg.MCPCategoryModel.Enabled {
 		return fmt.Errorf("MCP category classifier is not enabled")
 	}
 
@@ -84,19 +84,19 @@ func (m *MCPCategoryClassifier) Init(cfg *config.RouterConfig) error {
 
 	// Create MCP client configuration
 	mcpConfig := mcpclient.ClientConfig{
-		TransportType: cfg.TransportType,
-		Command:       cfg.Command,
-		Args:          cfg.Args,
-		Env:           cfg.Env,
-		URL:           cfg.URL,
+		TransportType: cfg.MCPCategoryModel.TransportType,
+		Command:       cfg.MCPCategoryModel.Command,
+		Args:          cfg.MCPCategoryModel.Args,
+		Env:           cfg.MCPCategoryModel.Env,
+		URL:           cfg.MCPCategoryModel.URL,
 		Options: mcpclient.ClientOptions{
 			LogEnabled: true,
 		},
 	}
 
 	// Set timeout if specified
-	if cfg.TimeoutSeconds > 0 {
-		mcpConfig.Timeout = time.Duration(cfg.TimeoutSeconds) * time.Second
+	if cfg.MCPCategoryModel.TimeoutSeconds > 0 {
+		mcpConfig.Timeout = time.Duration(cfg.MCPCategoryModel.TimeoutSeconds) * time.Second
 	}
 
 	// Create MCP client
@@ -125,8 +125,8 @@ func (m *MCPCategoryClassifier) Init(cfg *config.RouterConfig) error {
 // discoverClassificationTool finds the appropriate classification tool from available MCP tools
 func (m *MCPCategoryClassifier) discoverClassificationTool() error {
 	// If tool name is explicitly specified, use it
-	if m.config.ToolName != "" {
-		m.toolName = m.config.ToolName
+	if m.config.MCPCategoryModel.ToolName != "" {
+		m.toolName = m.config.MCPCategoryModel.ToolName
 		logging.Infof("Using explicitly configured tool: %s", m.toolName)
 		return nil
 	}
@@ -356,7 +356,7 @@ func createMCPCategoryInference(initializer MCPCategoryInitializer) MCPCategoryI
 // IsMCPCategoryEnabled checks if MCP-based category classification is properly configured.
 // Note: tool_name is optional and will be auto-discovered during initialization if not specified.
 func (c *Classifier) IsMCPCategoryEnabled() bool {
-	return c.Config.Enabled
+	return c.Config.MCPCategoryModel.Enabled
 }
 
 // initializeMCPCategoryClassifier initializes the MCP category classification model
@@ -380,9 +380,9 @@ func (c *Classifier) initializeMCPCategoryClassifier() error {
 
 		// Create a context with timeout for the list_categories call
 		ctx := context.Background()
-		if c.Config.TimeoutSeconds > 0 {
+		if c.Config.MCPCategoryModel.TimeoutSeconds > 0 {
 			var cancel context.CancelFunc
-			ctx, cancel = context.WithTimeout(ctx, time.Duration(c.Config.TimeoutSeconds)*time.Second)
+			ctx, cancel = context.WithTimeout(ctx, time.Duration(c.Config.MCPCategoryModel.TimeoutSeconds)*time.Second)
 			defer cancel()
 		}
 
@@ -422,9 +422,9 @@ func (c *Classifier) classifyCategoryMCPWithRouting(text string) (*MCPClassifica
 
 	// Create context with timeout
 	ctx := context.Background()
-	if c.Config.TimeoutSeconds > 0 {
+	if c.Config.MCPCategoryModel.TimeoutSeconds > 0 {
 		var cancel context.CancelFunc
-		ctx, cancel = context.WithTimeout(ctx, time.Duration(c.Config.TimeoutSeconds)*time.Second)
+		ctx, cancel = context.WithTimeout(ctx, time.Duration(c.Config.MCPCategoryModel.TimeoutSeconds)*time.Second)
 		defer cancel()
 	}
 
@@ -530,9 +530,9 @@ func (c *Classifier) classifyCategoryWithEntropyMCP(text string) (string, float6
 
 	// Create context with timeout
 	ctx := context.Background()
-	if c.Config.TimeoutSeconds > 0 {
+	if c.Config.MCPCategoryModel.TimeoutSeconds > 0 {
 		var cancel context.CancelFunc
-		ctx, cancel = context.WithTimeout(ctx, time.Duration(c.Config.TimeoutSeconds)*time.Second)
+		ctx, cancel = context.WithTimeout(ctx, time.Duration(c.Config.MCPCategoryModel.TimeoutSeconds)*time.Second)
 		defer cancel()
 	}
 

src/semantic-router/pkg/extproc/request_handler.go

@@ -520,7 +520,7 @@ func (r *OpenAIRouter) handleCaching(ctx *RequestContext, categoryName string) (
 	ctx.RequestQuery = requestQuery
 
 	// Check if caching is enabled for this category
-	cacheEnabled := r.Config.Enabled
+	cacheEnabled := r.Config.SemanticCache.Enabled
 	if categoryName != "" {
 		cacheEnabled = r.Config.IsCacheEnabledForCategory(categoryName)
 	}

src/semantic-router/pkg/extproc/router.go

@@ -69,7 +69,7 @@ func NewOpenAIRouter(configPath string) (*OpenAIRouter, error) {
 	}
 
 	// Initialize the BERT model for similarity search
-	if initErr := candle_binding.InitModel(cfg.ModelID, cfg.BertModel.UseCPU); initErr != nil {
+	if initErr := candle_binding.InitModel(cfg.BertModel.ModelID, cfg.BertModel.UseCPU); initErr != nil {
 		return nil, fmt.Errorf("failed to initialize BERT model: %w", initErr)
 	}
 
@@ -78,14 +78,14 @@ func NewOpenAIRouter(configPath string) (*OpenAIRouter, error) {
 
 	// Create semantic cache with config options
 	cacheConfig := cache.CacheConfig{
-		BackendType:         cache.CacheBackendType(cfg.BackendType),
-		Enabled:             cfg.Enabled,
+		BackendType:         cache.CacheBackendType(cfg.SemanticCache.BackendType),
+		Enabled:             cfg.SemanticCache.Enabled,
 		SimilarityThreshold: cfg.GetCacheSimilarityThreshold(),
-		MaxEntries:          cfg.MaxEntries,
-		TTLSeconds:          cfg.TTLSeconds,
-		EvictionPolicy:      cache.EvictionPolicyType(cfg.EvictionPolicy),
-		BackendConfigPath:   cfg.BackendConfigPath,
-		EmbeddingModel:      cfg.EmbeddingModel,
+		MaxEntries:          cfg.SemanticCache.MaxEntries,
+		TTLSeconds:          cfg.SemanticCache.TTLSeconds,
+		EvictionPolicy:      cache.EvictionPolicyType(cfg.SemanticCache.EvictionPolicy),
+		BackendConfigPath:   cfg.SemanticCache.BackendConfigPath,
+		EmbeddingModel:      cfg.SemanticCache.EmbeddingModel,
 	}
 
 	// Use default backend type if not specified
@@ -109,7 +109,7 @@ func NewOpenAIRouter(configPath string) (*OpenAIRouter, error) {
 	}
 
 	// Create tools database with config options
-	toolsThreshold := cfg.Threshold // Default to BERT threshold
+	toolsThreshold := cfg.BertModel.Threshold // Default to BERT threshold
 	if cfg.Tools.SimilarityThreshold != nil {
 		toolsThreshold = *cfg.Tools.SimilarityThreshold
 	}

src/semantic-router/pkg/services/classification.go

@@ -87,7 +87,7 @@ func createLegacyClassifier(config *config.RouterConfig) (*classification.Classi
 	// Check if we should load categories from MCP server
 	// Note: tool_name is optional and will be auto-discovered if not specified
 	useMCPCategories := config.CategoryModel.ModelID == "" &&
-		config.Enabled
+		config.MCPCategoryModel.Enabled
 
 	if useMCPCategories {
 		// Categories will be loaded from MCP server during initialization