Remove duplicate code in FindSimilar functions

Refactored FindSimilar() to delegate to FindSimilarWithThreshold() with default threshold instead of duplicating the entire implementation. This eliminates 226 lines of duplicate code across inmemory_cache.go and milvus_cache.go.

Co-authored-by: rootfs <[email protected]>

Author: Copilot

src/semantic-router/pkg/cache/inmemory_cache.go

@@ -207,131 +207,9 @@ func (c *InMemoryCache) AddEntry(requestID string, model string, query string, r
 	return nil
 }
 
-// FindSimilar searches for semantically similar cached requests
+// FindSimilar searches for semantically similar cached requests using the default threshold
 func (c *InMemoryCache) FindSimilar(model string, query string) ([]byte, bool, error) {
-	start := time.Now()
-
-	if !c.enabled {
-		observability.Debugf("InMemoryCache.FindSimilar: cache disabled")
-		return nil, false, nil
-	}
-	queryPreview := query
-	if len(query) > 50 {
-		queryPreview = query[:50] + "..."
-	}
-	observability.Debugf("InMemoryCache.FindSimilar: searching for model='%s', query='%s' (len=%d chars)",
-		model, queryPreview, len(query))
-
-	// Generate semantic embedding for similarity comparison
-	queryEmbedding, err := candle_binding.GetEmbedding(query, 0) // Auto-detect dimension
-	if err != nil {
-		metrics.RecordCacheOperation("memory", "find_similar", "error", time.Since(start).Seconds())
-		return nil, false, fmt.Errorf("failed to generate embedding: %w", err)
-	}
-
-	c.mu.RLock()
-	var (
-		bestIndex      = -1
-		bestEntry      CacheEntry
-		bestSimilarity float32
-		entriesChecked int
-		expiredCount   int
-	)
-	// Capture the lookup time after acquiring the read lock so TTL checks aren’t skewed by embedding work or lock wait
-	now := time.Now()
-
-	// Compare with completed entries for the same model, tracking only the best match
-	for entryIndex, entry := range c.entries {
-		// Skip incomplete entries
-		if entry.ResponseBody == nil {
-			continue
-		}
-
-		// Only consider entries for the same model
-		if entry.Model != model {
-			continue
-		}
-
-		// Skip entries that have expired before considering them
-		if c.isExpired(entry, now) {
-			expiredCount++
-			continue
-		}
-
-		// Compute semantic similarity using dot product
-		var dotProduct float32
-		for i := 0; i < len(queryEmbedding) && i < len(entry.Embedding); i++ {
-			dotProduct += queryEmbedding[i] * entry.Embedding[i]
-		}
-
-		entriesChecked++
-		if bestIndex == -1 || dotProduct > bestSimilarity {
-			bestSimilarity = dotProduct
-			bestIndex = entryIndex
-		}
-	}
-	// Snapshot the best entry before releasing the read lock
-	if bestIndex >= 0 {
-		bestEntry = c.entries[bestIndex]
-	}
-
-	// Unlock the read lock since we need the write lock to update the access info
-	c.mu.RUnlock()
-
-	// Log if any expired entries were skipped
-	if expiredCount > 0 {
-		observability.Debugf("InMemoryCache: excluded %d expired entries during search (TTL: %ds)",
-			expiredCount, c.ttlSeconds)
-		observability.LogEvent("cache_expired_entries_found", map[string]interface{}{
-			"backend":       "memory",
-			"expired_count": expiredCount,
-			"ttl_seconds":   c.ttlSeconds,
-		})
-	}
-
-	// Handle case where no suitable entries exist
-	if bestIndex < 0 {
-		atomic.AddInt64(&c.missCount, 1)
-		observability.Debugf("InMemoryCache.FindSimilar: no entries found with responses")
-		metrics.RecordCacheOperation("memory", "find_similar", "miss", time.Since(start).Seconds())
-		metrics.RecordCacheMiss()
-		return nil, false, nil
-	}
-
-	// Check if the best match meets the similarity threshold
-	if bestSimilarity >= c.similarityThreshold {
-		atomic.AddInt64(&c.hitCount, 1)
-
-		c.mu.Lock()
-		c.updateAccessInfo(bestIndex, bestEntry)
-		c.mu.Unlock()
-
-		observability.Debugf("InMemoryCache.FindSimilar: CACHE HIT - similarity=%.4f >= threshold=%.4f, response_size=%d bytes",
-			bestSimilarity, c.similarityThreshold, len(bestEntry.ResponseBody))
-		observability.LogEvent("cache_hit", map[string]interface{}{
-			"backend":    "memory",
-			"similarity": bestSimilarity,
-			"threshold":  c.similarityThreshold,
-			"model":      model,
-		})
-		metrics.RecordCacheOperation("memory", "find_similar", "hit", time.Since(start).Seconds())
-		metrics.RecordCacheHit()
-		return bestEntry.ResponseBody, true, nil
-	}
-
-	atomic.AddInt64(&c.missCount, 1)
-	observability.Debugf("InMemoryCache.FindSimilar: CACHE MISS - best_similarity=%.4f < threshold=%.4f (checked %d entries)",
-		bestSimilarity, c.similarityThreshold, entriesChecked)
-	observability.LogEvent("cache_miss", map[string]interface{}{
-		"backend":         "memory",
-		"best_similarity": bestSimilarity,
-		"threshold":       c.similarityThreshold,
-		"model":           model,
-		"entries_checked": entriesChecked,
-	})
-	metrics.RecordCacheOperation("memory", "find_similar", "miss", time.Since(start).Seconds())
-	metrics.RecordCacheMiss()
-	return nil, false, nil
+	return c.FindSimilarWithThreshold(model, query, c.similarityThreshold)
 }
 
 // FindSimilarWithThreshold searches for semantically similar cached requests using a specific threshold

src/semantic-router/pkg/cache/milvus_cache.go

@@ -487,108 +487,7 @@ func (c *MilvusCache) addEntry(id string, requestID string, model string, query
 
 // FindSimilar searches for semantically similar cached requests
 func (c *MilvusCache) FindSimilar(model string, query string) ([]byte, bool, error) {
-	start := time.Now()
-
-	if !c.enabled {
-		observability.Debugf("MilvusCache.FindSimilar: cache disabled")
-		return nil, false, nil
-	}
-	queryPreview := query
-	if len(query) > 50 {
-		queryPreview = query[:50] + "..."
-	}
-	observability.Debugf("MilvusCache.FindSimilar: searching for model='%s', query='%s' (len=%d chars)",
-		model, queryPreview, len(query))
-
-	// Generate semantic embedding for similarity comparison
-	queryEmbedding, err := candle_binding.GetEmbedding(query, 0) // Auto-detect dimension
-	if err != nil {
-		metrics.RecordCacheOperation("milvus", "find_similar", "error", time.Since(start).Seconds())
-		return nil, false, fmt.Errorf("failed to generate embedding: %w", err)
-	}
-
-	ctx := context.Background()
-
-	// Define search parameters
-	searchParam, err := entity.NewIndexHNSWSearchParam(c.config.Search.Params.Ef)
-	if err != nil {
-		return nil, false, fmt.Errorf("failed to create search parameters: %w", err)
-	}
-
-	// Use Milvus Search for efficient similarity search
-	searchResult, err := c.client.Search(
-		ctx,
-		c.collectionName,
-		[]string{},
-		fmt.Sprintf("model == \"%s\" && response_body != \"\"", model),
-		[]string{"response_body"},
-		[]entity.Vector{entity.FloatVector(queryEmbedding)},
-		c.config.Collection.VectorField.Name,
-		entity.MetricType(c.config.Collection.VectorField.MetricType),
-		c.config.Search.TopK,
-		searchParam,
-	)
-	if err != nil {
-		observability.Debugf("MilvusCache.FindSimilar: search failed: %v", err)
-		atomic.AddInt64(&c.missCount, 1)
-		metrics.RecordCacheOperation("milvus", "find_similar", "error", time.Since(start).Seconds())
-		metrics.RecordCacheMiss()
-		return nil, false, nil
-	}
-
-	if len(searchResult) == 0 || searchResult[0].ResultCount == 0 {
-		atomic.AddInt64(&c.missCount, 1)
-		observability.Debugf("MilvusCache.FindSimilar: no entries found")
-		metrics.RecordCacheOperation("milvus", "find_similar", "miss", time.Since(start).Seconds())
-		metrics.RecordCacheMiss()
-		return nil, false, nil
-	}
-
-	bestScore := searchResult[0].Scores[0]
-	if bestScore < c.similarityThreshold {
-		atomic.AddInt64(&c.missCount, 1)
-		observability.Debugf("MilvusCache.FindSimilar: CACHE MISS - best_similarity=%.4f < threshold=%.4f",
-			bestScore, c.similarityThreshold)
-		observability.LogEvent("cache_miss", map[string]interface{}{
-			"backend":         "milvus",
-			"best_similarity": bestScore,
-			"threshold":       c.similarityThreshold,
-			"model":           model,
-			"collection":      c.collectionName,
-		})
-		metrics.RecordCacheOperation("milvus", "find_similar", "miss", time.Since(start).Seconds())
-		metrics.RecordCacheMiss()
-		return nil, false, nil
-	}
-
-	// Cache Hit
-	var responseBody []byte
-	responseBodyColumn, ok := searchResult[0].Fields[0].(*entity.ColumnVarChar)
-	if ok && responseBodyColumn.Len() > 0 {
-		responseBody = []byte(responseBodyColumn.Data()[0])
-	}
-
-	if responseBody == nil {
-		observability.Debugf("MilvusCache.FindSimilar: cache hit but response_body is missing or not a string")
-		atomic.AddInt64(&c.missCount, 1)
-		metrics.RecordCacheOperation("milvus", "find_similar", "error", time.Since(start).Seconds())
-		metrics.RecordCacheMiss()
-		return nil, false, nil
-	}
-
-	atomic.AddInt64(&c.hitCount, 1)
-	observability.Debugf("MilvusCache.FindSimilar: CACHE HIT - similarity=%.4f >= threshold=%.4f, response_size=%d bytes",
-		bestScore, c.similarityThreshold, len(responseBody))
-	observability.LogEvent("cache_hit", map[string]interface{}{
-		"backend":    "milvus",
-		"similarity": bestScore,
-		"threshold":  c.similarityThreshold,
-		"model":      model,
-		"collection": c.collectionName,
-	})
-	metrics.RecordCacheOperation("milvus", "find_similar", "hit", time.Since(start).Seconds())
-	metrics.RecordCacheHit()
-	return responseBody, true, nil
+	return c.FindSimilarWithThreshold(model, query, c.similarityThreshold)
 }
 
 // FindSimilarWithThreshold searches for semantically similar cached requests using a specific threshold