[DELETED]: embedding cache

src/api/dependencies.py

@@ -6,16 +6,13 @@ route handlers, ensuring consistent access to shared resources.
 """
 
 from typing import Optional
-from fastapi import Depends, HTTPException, status
+from fastapi import HTTPException, status
 
-from src.config.settings import Settings, get_settings
 from src.core.manager import ModelManager
-from src.core.cache import EmbeddingCache
 
 
 # Global instances (initialized at startup)
 _model_manager: Optional[ModelManager] = None
-_embedding_cache: Optional[EmbeddingCache] = None
 
 
 def set_model_manager(manager: ModelManager) -> None:
@@ -31,19 +28,6 @@ def set_model_manager(manager: ModelManager) -> None:
     _model_manager = manager
 
 
-def set_embedding_cache(cache: EmbeddingCache) -> None:
-    """
-    Set the global embedding cache instance.
-
-    Called during application startup if caching is enabled.
-
-    Args:
-        cache: EmbeddingCache instance
-    """
-    global _embedding_cache
-    _embedding_cache = cache
-
-
 def get_model_manager() -> ModelManager:
     """
     Get the model manager instance.
@@ -72,29 +56,3 @@ def get_model_manager() -> ModelManager:
         )
     return _model_manager
 
-
-def get_embedding_cache() -> Optional[EmbeddingCache]:
-    """
-    Get the embedding cache instance (if enabled).
-
-    Returns:
-        EmbeddingCache instance or None if caching is disabled
-    """
-    return _embedding_cache
-
-
-def get_cache_if_enabled(
-    settings: Settings = Depends(get_settings),
-) -> Optional[EmbeddingCache]:
-    """
-    Get cache only if caching is enabled in settings.
-
-    Args:
-        settings: Application settings
-
-    Returns:
-        EmbeddingCache instance if enabled, None otherwise
-    """
-    if settings.ENABLE_CACHE:
-        return _embedding_cache
-    return None

src/api/routers/embedding.py

@@ -17,14 +17,13 @@ from src.models.schemas import (
     SparseEmbedding,
 )
 from src.core.manager import ModelManager
-from src.core.cache import EmbeddingCache
 from src.core.exceptions import (
     ModelNotFoundError,
     ModelNotLoadedError,
     EmbeddingGenerationError,
     ValidationError,
 )
-from src.api.dependencies import get_model_manager, get_cache_if_enabled
+from src.api.dependencies import get_model_manager
 from src.utils.validators import extract_embedding_kwargs, validate_texts
 from src.config.settings import get_settings
 
@@ -41,7 +40,6 @@ router = APIRouter(prefix="/embeddings", tags=["embeddings"])
 async def create_embeddings_document(
     request: EmbedRequest,
     manager: ModelManager = Depends(get_model_manager),
-    cache: EmbeddingCache = Depends(get_cache_if_enabled),
     settings=Depends(get_settings),
 ):
     """
@@ -53,7 +51,6 @@ async def create_embeddings_document(
     Args:
         request: BatchEmbedRequest with texts, model_id, and optional parameters
         manager: Model manager dependency
-        cache: Cache dependency (if enabled)
         settings: Application settings
 
     Returns:
@@ -73,19 +70,6 @@ async def create_embeddings_document(
         # Extract kwargs
         kwargs = extract_embedding_kwargs(request)
 
-        # Check cache first (batch requests typically not cached due to size)
-        # But we can cache if batch is small
-        if cache is not None and len(request.texts) <= 10:
-            cache_key = str(sorted(request.texts))  # Simple key for small batches
-            cached_result = cache.get(
-                texts=cache_key,
-                model_id=request.model_id,
-                prompt=request.prompt,
-                **kwargs,
-            )
-            if cached_result is not None:
-                logger.debug(f"Cache hit for batch (size={len(request.texts)})")
-                return cached_result
 
         # Get model
         model = manager.get_model(request.model_id)
@@ -133,17 +117,6 @@ async def create_embeddings_document(
                 processing_time=processing_time,
             )
 
-        # Cache small batches
-        if cache is not None and len(request.texts) <= 10:
-            cache_key = str(sorted(request.texts))
-            cache.set(
-                texts=cache_key,
-                model_id=request.model_id,
-                result=response,
-                prompt=request.prompt,
-                **kwargs,
-            )
-
         logger.info(
             f"Generated {len(request.texts)} embeddings "
             f"in {processing_time:.3f}s ({len(request.texts) / processing_time:.1f} texts/s)"
@@ -174,7 +147,6 @@ async def create_embeddings_document(
 async def create_query_embedding(
     request: EmbedRequest,
     manager: ModelManager = Depends(get_model_manager),
-    cache: EmbeddingCache = Depends(get_cache_if_enabled),
 ):
     """
     Generate a single/batch query embedding.
@@ -185,7 +157,6 @@ async def create_query_embedding(
     Args:
         request: EmbedRequest with text, model_id, and optional parameters
         manager: Model manager dependency
-        cache: Cache dependency (if enabled)
         settings: Application settings
 
     Returns:
@@ -201,20 +172,6 @@ async def create_query_embedding(
         # Extract kwargs
         kwargs = extract_embedding_kwargs(request)
 
-        # Check cache (with 'query' prefix in key)
-        cache_key_kwargs = {"endpoint": "query", **kwargs}
-
-        if cache is not None:
-            cached_result = cache.get(
-                texts=request.texts,
-                model_id=request.model_id,
-                prompt=request.prompt,
-                **cache_key_kwargs,
-            )
-            if cached_result is not None:
-                logger.debug(f"Cache hit for query model {request.model_id}")
-                return cached_result
-
         # Get model
         model = manager.get_model(request.model_id)
         config = manager.model_configs[request.model_id]
@@ -261,16 +218,6 @@ async def create_query_embedding(
                 processing_time=processing_time,
             )
 
-        # Cache small batches
-        if cache is not None and len(request.texts) <= 10:
-            cache_key = str(sorted(request.texts))
-            cache.set(
-                texts=cache_key,
-                model_id=request.model_id,
-                result=response,
-                prompt=request.prompt,
-                **kwargs,
-            )
 
         logger.info(
             f"Generated {len(request.texts)} embeddings "

src/core/cache.py

@@ -1,237 +0,0 @@
-"""
-Simple in-memory caching layer for embeddings.
-
-This module provides an LRU cache for embedding results to reduce
-redundant computations for identical requests.
-"""
-
-import hashlib
-import json
-import time
-from typing import Any, Dict, List, Optional, Union
-from collections import OrderedDict
-from threading import Lock
-from loguru import logger
-
-
-class EmbeddingCache:
-    """
-    Thread-safe LRU cache for embedding results.
-
-    This cache stores embedding results with a TTL (time-to-live) and
-    implements LRU eviction when the cache is full.
-
-    Attributes:
-        max_size: Maximum number of entries in the cache
-        ttl: Time-to-live in seconds for cached entries
-        _cache: OrderedDict storing cached entries
-        _lock: Threading lock for thread-safety
-        _hits: Number of cache hits
-        _misses: Number of cache misses
-    """
-
-    def __init__(self, max_size: int = 1000, ttl: int = 3600):
-        """
-        Initialize the embedding cache.
-
-        Args:
-            max_size: Maximum number of entries (default: 1000)
-            ttl: Time-to-live in seconds (default: 3600 = 1 hour)
-        """
-        self.max_size = max_size
-        self.ttl = ttl
-        self._cache: OrderedDict[str, Dict[str, Any]] = OrderedDict()
-        self._lock = Lock()
-        self._hits = 0
-        self._misses = 0
-
-        logger.info(f"Initialized embedding cache (max_size={max_size}, ttl={ttl}s)")
-
-    def _generate_key(
-        self,
-        texts: Union[str, List[str]],
-        model_id: str,
-        prompt: Optional[str] = None,
-        **kwargs,
-    ) -> str:
-        """
-        Generate a unique cache key for the request.
-
-        Args:
-            texts: Single text or list of texts
-            model_id: Model identifier
-            prompt: Optional prompt
-            **kwargs: Additional parameters
-
-        Returns:
-            SHA256 hash of the request parameters
-        """
-        # Normalize texts to list
-        if isinstance(texts, str):
-            texts = [texts]
-
-        # Create deterministic representation
-        cache_dict = {
-            "texts": texts,
-            "model_id": model_id,
-            "prompt": prompt,
-            "kwargs": sorted(kwargs.items()) if kwargs else [],
-        }
-
-        # Generate hash
-        cache_str = json.dumps(cache_dict, sort_keys=True)
-        return hashlib.sha256(cache_str.encode()).hexdigest()
-
-    def get(
-        self,
-        texts: Union[str, List[str]],
-        model_id: str,
-        prompt: Optional[str] = None,
-        **kwargs,
-    ) -> Optional[Any]:
-        """
-        Retrieve a cached embedding result.
-
-        Args:
-            texts: Single text or list of texts
-            model_id: Model identifier
-            prompt: Optional prompt
-            **kwargs: Additional parameters
-
-        Returns:
-            Cached result if found and not expired, None otherwise
-        """
-        key = self._generate_key(texts, model_id, prompt, **kwargs)
-
-        with self._lock:
-            if key not in self._cache:
-                self._misses += 1
-                return None
-
-            entry = self._cache[key]
-
-            # Check if expired
-            if time.time() - entry["timestamp"] > self.ttl:
-                del self._cache[key]
-                self._misses += 1
-                logger.debug(f"Cache entry expired: {key[:8]}...")
-                return None
-
-            # Move to end (LRU)
-            self._cache.move_to_end(key)
-            self._hits += 1
-
-            logger.debug(f"Cache hit: {key[:8]}... (hit_rate={self.hit_rate:.2%})")
-
-            return entry["result"]
-
-    def set(
-        self,
-        texts: Union[str, List[str]],
-        model_id: str,
-        result: Any,
-        prompt: Optional[str] = None,
-        **kwargs,
-    ) -> None:
-        """
-        Store an embedding result in the cache.
-
-        Args:
-            texts: Single text or list of texts
-            model_id: Model identifier
-            result: Embedding result to cache
-            prompt: Optional prompt
-            **kwargs: Additional parameters
-        """
-        key = self._generate_key(texts, model_id, prompt, **kwargs)
-
-        with self._lock:
-            # Evict oldest entry if cache is full
-            if len(self._cache) >= self.max_size:
-                oldest_key = next(iter(self._cache))
-                del self._cache[oldest_key]
-                logger.debug(f"Cache full, evicted: {oldest_key[:8]}...")
-
-            # Store new entry
-            self._cache[key] = {"result": result, "timestamp": time.time()}
-
-            logger.debug(
-                f"Cache set: {key[:8]}... (size={len(self._cache)}/{self.max_size})"
-            )
-
-    def clear(self) -> None:
-        """Clear all cached entries."""
-        with self._lock:
-            count = len(self._cache)
-            self._cache.clear()
-            self._hits = 0
-            self._misses = 0
-            logger.info(f"Cleared {count} cache entries")
-
-    def cleanup_expired(self) -> int:
-        """
-        Remove all expired entries from the cache.
-
-        Returns:
-            Number of entries removed
-        """
-        with self._lock:
-            current_time = time.time()
-            expired_keys = [
-                key
-                for key, entry in self._cache.items()
-                if current_time - entry["timestamp"] > self.ttl
-            ]
-
-            for key in expired_keys:
-                del self._cache[key]
-
-            if expired_keys:
-                logger.info(f"Cleaned up {len(expired_keys)} expired cache entries")
-
-            return len(expired_keys)
-
-    @property
-    def size(self) -> int:
-        """Get current number of cached entries."""
-        return len(self._cache)
-
-    @property
-    def hit_rate(self) -> float:
-        """
-        Calculate cache hit rate.
-
-        Returns:
-            Hit rate as a float between 0 and 1
-        """
-        total = self._hits + self._misses
-        if total == 0:
-            return 0.0
-        return self._hits / total
-
-    @property
-    def stats(self) -> Dict[str, Any]:
-        """
-        Get cache statistics.
-
-        Returns:
-            Dictionary with cache statistics
-        """
-        return {
-            "size": self.size,
-            "max_size": self.max_size,
-            "hits": self._hits,
-            "misses": self._misses,
-            "hit_rate": f"{self.hit_rate:.2%}",
-            "ttl": self.ttl,
-        }
-
-    def __repr__(self) -> str:
-        """String representation of the cache."""
-        return (
-            f"EmbeddingCache("
-            f"size={self.size}/{self.max_size}, "
-            f"hits={self._hits}, "
-            f"misses={self._misses}, "
-            f"hit_rate={self.hit_rate:.2%})"
-        )