claude-code-workflow 6.3.18 → 6.3.19

package/codex-lens/src/codexlens/semantic/factory.py

@@ -1,14 +1,23 @@
 """Factory for creating embedders.
 
 Provides a unified interface for instantiating different embedder backends.
+Includes caching to avoid repeated model loading overhead.
 """
 
 from __future__ import annotations
 
+import logging
+import threading
 from typing import Any, Dict, List, Optional
 
 from .base import BaseEmbedder
 
+# Module-level cache for embedder instances
+# Key: (backend, profile, model, use_gpu) -> embedder instance
+_embedder_cache: Dict[tuple, BaseEmbedder] = {}
+_cache_lock = threading.Lock()
+_logger = logging.getLogger(__name__)
+
 
 def get_embedder(
     backend: str = "fastembed",
@@ -65,13 +74,38 @@ def get_embedder(
             ... ]
             >>> embedder = get_embedder(backend="litellm", endpoints=endpoints)
     """
+    # Build cache key from immutable configuration
+    if backend == "fastembed":
+        cache_key = ("fastembed", profile, None, use_gpu)
+    elif backend == "litellm":
+        # For litellm, use model as part of cache key
+        # Multi-endpoint mode is not cached as it's more complex
+        if endpoints and len(endpoints) > 1:
+            cache_key = None  # Skip cache for multi-endpoint
+        else:
+            effective_model = endpoints[0]["model"] if endpoints else model
+            cache_key = ("litellm", None, effective_model, None)
+    else:
+        cache_key = None
+
+    # Check cache first (thread-safe)
+    if cache_key is not None:
+        with _cache_lock:
+            if cache_key in _embedder_cache:
+                _logger.debug("Returning cached embedder for %s", cache_key)
+                return _embedder_cache[cache_key]
+
+    # Create new embedder instance
+    embedder: Optional[BaseEmbedder] = None
+
     if backend == "fastembed":
         from .embedder import Embedder
-        return Embedder(profile=profile, use_gpu=use_gpu, **kwargs)
+        embedder = Embedder(profile=profile, use_gpu=use_gpu, **kwargs)
     elif backend == "litellm":
         # Check if multi-endpoint mode is requested
         if endpoints and len(endpoints) > 1:
             from .rotational_embedder import create_rotational_embedder
+            # Multi-endpoint is not cached
             return create_rotational_embedder(
                 endpoints_config=endpoints,
                 strategy=strategy,
@@ -86,13 +120,39 @@ def get_embedder(
             if "api_base" in ep:
                 ep_kwargs["api_base"] = ep["api_base"]
             from .litellm_embedder import LiteLLMEmbedderWrapper
-            return LiteLLMEmbedderWrapper(model=ep["model"], **ep_kwargs)
+            embedder = LiteLLMEmbedderWrapper(model=ep["model"], **ep_kwargs)
         else:
             # No endpoints list - use model parameter
             from .litellm_embedder import LiteLLMEmbedderWrapper
-            return LiteLLMEmbedderWrapper(model=model, **kwargs)
+            embedder = LiteLLMEmbedderWrapper(model=model, **kwargs)
     else:
         raise ValueError(
             f"Unknown backend: {backend}. "
             f"Supported backends: 'fastembed', 'litellm'"
         )
+
+    # Cache the embedder for future use (thread-safe)
+    if cache_key is not None and embedder is not None:
+        with _cache_lock:
+            # Double-check to avoid race condition
+            if cache_key not in _embedder_cache:
+                _embedder_cache[cache_key] = embedder
+                _logger.debug("Cached new embedder for %s", cache_key)
+            else:
+                # Another thread created it already, use that one
+                embedder = _embedder_cache[cache_key]
+
+    return embedder  # type: ignore
+
+
+def clear_embedder_cache() -> int:
+    """Clear the embedder cache.
+
+    Returns:
+        Number of embedders cleared from cache
+    """
+    with _cache_lock:
+        count = len(_embedder_cache)
+        _embedder_cache.clear()
+        _logger.debug("Cleared %d embedders from cache", count)
+        return count

package/codex-lens/src/codexlens/semantic/gpu_support.py

@@ -282,10 +282,27 @@ def get_optimal_providers(use_gpu: bool = True, with_device_options: bool = Fals
         return ["CPUExecutionProvider"]
 
     gpu_info = detect_gpu()
-    
+
+    # Check if GPU was requested but not available - log warning
+    if not gpu_info.gpu_available:
+        try:
+            import onnxruntime as ort
+            available_providers = ort.get_available_providers()
+        except ImportError:
+            available_providers = []
+        logger.warning(
+            "GPU acceleration was requested, but no supported GPU provider (CUDA, DirectML) "
+            f"was found. Available providers: {available_providers}. Falling back to CPU."
+        )
+    else:
+        # Log which GPU provider is being used
+        gpu_providers = [p for p in gpu_info.onnx_providers if p != "CPUExecutionProvider"]
+        if gpu_providers:
+            logger.info(f"Using {gpu_providers[0]} for ONNX GPU acceleration")
+
     if not with_device_options:
         return gpu_info.onnx_providers
-    
+
     # Build providers with device_id options for GPU providers
     device_id = get_selected_device_id()
     providers = []

package/codex-lens/src/codexlens/semantic/litellm_embedder.py

@@ -1,144 +1,144 @@
-"""LiteLLM embedder wrapper for CodexLens.
-
-Provides integration with ccw-litellm's LiteLLMEmbedder for embedding generation.
-"""
-
-from __future__ import annotations
-
-from typing import Iterable
-
-import numpy as np
-
-from .base import BaseEmbedder
-
-
-class LiteLLMEmbedderWrapper(BaseEmbedder):
-    """Wrapper for ccw-litellm LiteLLMEmbedder.
-
-    This wrapper adapts the ccw-litellm LiteLLMEmbedder to the CodexLens
-    BaseEmbedder interface, enabling seamless integration with CodexLens
-    semantic search functionality.
-
-    Args:
-        model: Model identifier for LiteLLM (default: "default")
-        **kwargs: Additional arguments passed to LiteLLMEmbedder
-
-    Raises:
-        ImportError: If ccw-litellm package is not installed
-    """
-
-    def __init__(self, model: str = "default", **kwargs) -> None:
-        """Initialize LiteLLM embedder wrapper.
-
-        Args:
-            model: Model identifier for LiteLLM (default: "default")
-            **kwargs: Additional arguments passed to LiteLLMEmbedder
-
-        Raises:
-            ImportError: If ccw-litellm package is not installed
-        """
-        try:
-            from ccw_litellm import LiteLLMEmbedder
-            self._embedder = LiteLLMEmbedder(model=model, **kwargs)
-        except ImportError as e:
-            raise ImportError(
-                "ccw-litellm not installed. Install with: pip install ccw-litellm"
-            ) from e
-
-    @property
-    def embedding_dim(self) -> int:
-        """Return embedding dimensions from LiteLLMEmbedder.
-
-        Returns:
-            int: Dimension of the embedding vectors.
-        """
-        return self._embedder.dimensions
-
-    @property
-    def model_name(self) -> str:
-        """Return model name from LiteLLMEmbedder.
-
-        Returns:
-            str: Name or identifier of the underlying model.
-        """
-        return self._embedder.model_name
-
-    @property
-    def max_tokens(self) -> int:
-        """Return maximum token limit for the embedding model.
-
-        Returns:
-            int: Maximum number of tokens that can be embedded at once.
-                Inferred from model config or model name patterns.
-        """
-        # Try to get from LiteLLM config first
-        if hasattr(self._embedder, 'max_input_tokens') and self._embedder.max_input_tokens:
-            return self._embedder.max_input_tokens
-
-        # Infer from model name
-        model_name_lower = self.model_name.lower()
-
-        # Large models (8B or "large" in name)
-        if '8b' in model_name_lower or 'large' in model_name_lower:
-            return 32768
-
-        # OpenAI text-embedding-3-* models
-        if 'text-embedding-3' in model_name_lower:
-            return 8191
-
-        # Default fallback
-        return 8192
-
-    def _sanitize_text(self, text: str) -> str:
-        """Sanitize text to work around ModelScope API routing bug.
-
-        ModelScope incorrectly routes text starting with lowercase 'import'
-        to an Ollama endpoint, causing failures. This adds a leading space
-        to work around the issue without affecting embedding quality.
-
-        Args:
-            text: Text to sanitize.
-
-        Returns:
-            Sanitized text safe for embedding API.
-        """
-        if text.startswith('import'):
-            return ' ' + text
-        return text
-
-    def embed_to_numpy(self, texts: str | Iterable[str], **kwargs) -> np.ndarray:
-        """Embed texts to numpy array using LiteLLMEmbedder.
-
-        Args:
-            texts: Single text or iterable of texts to embed.
-            **kwargs: Additional arguments (ignored for LiteLLM backend).
-                      Accepts batch_size for API compatibility with fastembed.
-
-        Returns:
-            numpy.ndarray: Array of shape (n_texts, embedding_dim) containing embeddings.
-        """
-        if isinstance(texts, str):
-            texts = [texts]
-        else:
-            texts = list(texts)
-
-        # Sanitize texts to avoid ModelScope routing bug
-        texts = [self._sanitize_text(t) for t in texts]
-
-        # LiteLLM handles batching internally, ignore batch_size parameter
-        return self._embedder.embed(texts)
-
-    def embed_single(self, text: str) -> list[float]:
-        """Generate embedding for a single text.
-
-        Args:
-            text: Text to embed.
-
-        Returns:
-            list[float]: Embedding vector as a list of floats.
-        """
-        # Sanitize text before embedding
-        sanitized = self._sanitize_text(text)
-        embedding = self._embedder.embed([sanitized])
-        return embedding[0].tolist()
-
+"""LiteLLM embedder wrapper for CodexLens.
+
+Provides integration with ccw-litellm's LiteLLMEmbedder for embedding generation.
+"""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+import numpy as np
+
+from .base import BaseEmbedder
+
+
+class LiteLLMEmbedderWrapper(BaseEmbedder):
+    """Wrapper for ccw-litellm LiteLLMEmbedder.
+
+    This wrapper adapts the ccw-litellm LiteLLMEmbedder to the CodexLens
+    BaseEmbedder interface, enabling seamless integration with CodexLens
+    semantic search functionality.
+
+    Args:
+        model: Model identifier for LiteLLM (default: "default")
+        **kwargs: Additional arguments passed to LiteLLMEmbedder
+
+    Raises:
+        ImportError: If ccw-litellm package is not installed
+    """
+
+    def __init__(self, model: str = "default", **kwargs) -> None:
+        """Initialize LiteLLM embedder wrapper.
+
+        Args:
+            model: Model identifier for LiteLLM (default: "default")
+            **kwargs: Additional arguments passed to LiteLLMEmbedder
+
+        Raises:
+            ImportError: If ccw-litellm package is not installed
+        """
+        try:
+            from ccw_litellm import LiteLLMEmbedder
+            self._embedder = LiteLLMEmbedder(model=model, **kwargs)
+        except ImportError as e:
+            raise ImportError(
+                "ccw-litellm not installed. Install with: pip install ccw-litellm"
+            ) from e
+
+    @property
+    def embedding_dim(self) -> int:
+        """Return embedding dimensions from LiteLLMEmbedder.
+
+        Returns:
+            int: Dimension of the embedding vectors.
+        """
+        return self._embedder.dimensions
+
+    @property
+    def model_name(self) -> str:
+        """Return model name from LiteLLMEmbedder.
+
+        Returns:
+            str: Name or identifier of the underlying model.
+        """
+        return self._embedder.model_name
+
+    @property
+    def max_tokens(self) -> int:
+        """Return maximum token limit for the embedding model.
+
+        Returns:
+            int: Maximum number of tokens that can be embedded at once.
+                Reads from LiteLLM config's max_input_tokens property.
+        """
+        # Get from LiteLLM embedder's max_input_tokens property (now exposed)
+        if hasattr(self._embedder, 'max_input_tokens'):
+            return self._embedder.max_input_tokens
+
+        # Fallback: infer from model name
+        model_name_lower = self.model_name.lower()
+
+        # Large models (8B or "large" in name)
+        if '8b' in model_name_lower or 'large' in model_name_lower:
+            return 32768
+
+        # OpenAI text-embedding-3-* models
+        if 'text-embedding-3' in model_name_lower:
+            return 8191
+
+        # Default fallback
+        return 8192
+
+    def _sanitize_text(self, text: str) -> str:
+        """Sanitize text to work around ModelScope API routing bug.
+
+        ModelScope incorrectly routes text starting with lowercase 'import'
+        to an Ollama endpoint, causing failures. This adds a leading space
+        to work around the issue without affecting embedding quality.
+
+        Args:
+            text: Text to sanitize.
+
+        Returns:
+            Sanitized text safe for embedding API.
+        """
+        if text.startswith('import'):
+            return ' ' + text
+        return text
+
+    def embed_to_numpy(self, texts: str | Iterable[str], **kwargs) -> np.ndarray:
+        """Embed texts to numpy array using LiteLLMEmbedder.
+
+        Args:
+            texts: Single text or iterable of texts to embed.
+            **kwargs: Additional arguments (ignored for LiteLLM backend).
+                      Accepts batch_size for API compatibility with fastembed.
+
+        Returns:
+            numpy.ndarray: Array of shape (n_texts, embedding_dim) containing embeddings.
+        """
+        if isinstance(texts, str):
+            texts = [texts]
+        else:
+            texts = list(texts)
+
+        # Sanitize texts to avoid ModelScope routing bug
+        texts = [self._sanitize_text(t) for t in texts]
+
+        # LiteLLM handles batching internally, ignore batch_size parameter
+        return self._embedder.embed(texts)
+
+    def embed_single(self, text: str) -> list[float]:
+        """Generate embedding for a single text.
+
+        Args:
+            text: Text to embed.
+
+        Returns:
+            list[float]: Embedding vector as a list of floats.
+        """
+        # Sanitize text before embedding
+        sanitized = self._sanitize_text(text)
+        embedding = self._embedder.embed([sanitized])
+        return embedding[0].tolist()
+

package/codex-lens/src/codexlens/semantic/reranker/__init__.py

@@ -0,0 +1,25 @@
+"""Reranker backends for second-stage search ranking.
+
+This subpackage provides a unified interface and factory for different reranking
+implementations (e.g., ONNX, API-based, LiteLLM, and legacy sentence-transformers).
+"""
+
+from __future__ import annotations
+
+from .base import BaseReranker
+from .factory import check_reranker_available, get_reranker
+from .fastembed_reranker import FastEmbedReranker, check_fastembed_reranker_available
+from .legacy import CrossEncoderReranker, check_cross_encoder_available
+from .onnx_reranker import ONNXReranker, check_onnx_reranker_available
+
+__all__ = [
+    "BaseReranker",
+    "check_reranker_available",
+    "get_reranker",
+    "CrossEncoderReranker",
+    "check_cross_encoder_available",
+    "FastEmbedReranker",
+    "check_fastembed_reranker_available",
+    "ONNXReranker",
+    "check_onnx_reranker_available",
+]