mcp-code-indexer 4.1.0__py3-none-any.whl → 4.2.1__py3-none-any.whl

mcp_code_indexer/main.py

@@ -1019,7 +1019,7 @@ async def main() -> None:
                 
                 # Check if vector mode is available
                 if not is_vector_mode_available():
-                    logger.error("Vector mode requires additional dependencies. Install with: pip install mcp-code-indexer[vector]")
+                    logger.error("Vector mode dependencies not found. Try reinstalling: pip install --upgrade mcp-code-indexer")
                     sys.exit(1)
                 
                 # Check API keys

mcp_code_indexer/vector_mode/config.py

@@ -18,6 +18,7 @@ class VectorConfig:
     # API Configuration
     voyage_api_key: Optional[str] = None
     turbopuffer_api_key: Optional[str] = None
+    turbopuffer_region: str = "gcp-europe-west3"
     
     # Embedding Configuration  
     embedding_model: str = "voyage-code-2"
@@ -57,9 +58,10 @@ class VectorConfig:
         return cls(
             voyage_api_key=os.getenv("VOYAGE_API_KEY"),
             turbopuffer_api_key=os.getenv("TURBOPUFFER_API_KEY"),
-            embedding_model=os.getenv("VECTOR_EMBEDDING_MODEL", "voyage-code-2"),
+            turbopuffer_region=os.getenv("TURBOPUFFER_REGION", "gcp-europe-west3"),
+            embedding_model=os.getenv("VECTOR_EMBEDDING_MODEL", "voyage-code-3"),
             batch_size=int(os.getenv("VECTOR_BATCH_SIZE", "128")),
-            max_tokens_per_chunk=int(os.getenv("VECTOR_MAX_TOKENS", "1024")),
+            max_tokens_per_chunk=int(os.getenv("VECTOR_MAX_TOKENS", "2048")),
             similarity_threshold=float(os.getenv("VECTOR_SIMILARITY_THRESHOLD", "0.5")),
             max_search_results=int(os.getenv("VECTOR_MAX_RESULTS", "20")),
             enable_recency_boost=os.getenv("VECTOR_RECENCY_BOOST", "true").lower() == "true",
@@ -122,6 +124,16 @@ class VectorConfig:
             if not self.turbopuffer_api_key:
                 errors.append("TURBOPUFFER_API_KEY environment variable required for vector mode")
         
+        # Validate TurboPuffer region
+        supported_regions = [
+            'aws-ap-southeast-2', 'aws-eu-central-1', 'aws-us-east-1', 
+            'aws-us-east-2', 'aws-us-west-2', 'gcp-us-central1',
+            'gcp-us-west1', 'gcp-us-east4', 'gcp-europe-west3'
+        ]
+        if self.turbopuffer_region not in supported_regions:
+            errors.append(f"turbopuffer_region '{self.turbopuffer_region}' is not supported. " +
+                         f"Supported regions: {', '.join(supported_regions)}")
+        
         if self.batch_size <= 0:
             errors.append("batch_size must be positive")
         if self.max_tokens_per_chunk <= 0:

mcp_code_indexer/vector_mode/providers/__init__.py

@@ -1,72 +1,17 @@
 """
 External service providers for vector mode.
 
-This package provides integrations with external services including:
-- Voyage AI for embedding generation
-- Turbopuffer for vector storage and search
+This package provides clean integrations with external services using official SDKs:
+- Voyage AI for embedding generation (voyageai SDK)
+- Turbopuffer for vector storage and search (turbopuffer SDK)
 """
 
-from typing import Protocol, List, Dict, Any, Optional
-from abc import abstractmethod
+from .voyage_client import VoyageClient, create_voyage_client
+from .turbopuffer_client import TurbopufferClient, create_turbopuffer_client
 
-class EmbeddingProvider(Protocol):
-    """Protocol for embedding generation providers."""
-    
-    @abstractmethod
-    async def generate_embeddings(
-        self,
-        texts: List[str],
-        input_type: str = "document",
-        **kwargs
-    ) -> List[List[float]]:
-        """Generate embeddings for a list of texts."""
-        ...
-    
-    @abstractmethod
-    async def get_embedding_dimension(self) -> int:
-        """Get the dimension of embeddings produced by this provider."""
-        ...
-
-class VectorStoreProvider(Protocol):
-    """Protocol for vector storage providers."""
-    
-    @abstractmethod
-    async def upsert_vectors(
-        self,
-        vectors: List[Dict[str, Any]],
-        namespace: Optional[str] = None,
-        **kwargs
-    ) -> Dict[str, Any]:
-        """Store or update vectors in the database."""
-        ...
-    
-    @abstractmethod
-    async def search_vectors(
-        self,
-        query_vector: List[float],
-        top_k: int = 10,
-        namespace: Optional[str] = None,
-        filters: Optional[Dict[str, Any]] = None,
-        **kwargs
-    ) -> List[Dict[str, Any]]:
-        """Search for similar vectors."""
-        ...
-    
-    @abstractmethod
-    async def delete_vectors(
-        self,
-        vector_ids: List[str],
-        namespace: Optional[str] = None,
-        **kwargs
-    ) -> Dict[str, Any]:
-        """Delete vectors by ID."""
-        ...
-    
-    @abstractmethod
-    async def get_namespace_stats(
-        self,
-        namespace: Optional[str] = None,
-        **kwargs
-    ) -> Dict[str, Any]:
-        """Get statistics about a namespace."""
-        ...
+__all__ = [
+    'VoyageClient',
+    'create_voyage_client', 
+    'TurbopufferClient',
+    'create_turbopuffer_client',
+]

mcp_code_indexer/vector_mode/providers/turbopuffer_client.py

@@ -1,68 +1,63 @@
 """
-Turbopuffer client for vector storage and search.
+Turbopuffer client for vector storage and search using official SDK.
 
-Provides integration with Turbopuffer's vector database for storing
-embeddings and performing similarity searches.
+Provides clean integration with Turbopuffer's vector database for storing
+embeddings and performing similarity searches. Supports configurable
+regions for optimal latency and data residency compliance.
+
+Default region: gcp-europe-west3 (Frankfurt)
+Configure via TURBOPUFFER_REGION environment variable.
 """
 
 import logging
 import uuid
-from typing import List, Dict, Any, Optional, Union
-import json
+from typing import List, Dict, Any, Optional
+import turbopuffer
 
-from .base_provider import BaseProvider, ProviderError
 from ..config import VectorConfig
 
 logger = logging.getLogger(__name__)
 
-class TurbopufferClient(BaseProvider):
-    """Client for Turbopuffer vector database."""
+class TurbopufferClient:
+    """Clean Turbopuffer client using official SDK."""
     
-    def __init__(
-        self,
-        api_key: str,
-        base_url: str = "https://api.turbopuffer.com/v1",
-        **kwargs
-    ):
-        super().__init__(api_key, base_url, **kwargs)
+    def __init__(self, api_key: str, region: str = "gcp-europe-west3"):
+        self.api_key = api_key
+        self.region = region
+        
+        # Initialize official TurboPuffer client
+        self.client = turbopuffer.Turbopuffer(
+            api_key=api_key,
+            region=region
+        )
+        logger.info(f"Initialized TurboPuffer client with region {region}")
     
-    async def health_check(self) -> bool:
+    def health_check(self) -> bool:
         """Check if Turbopuffer service is healthy."""
         try:
-            # List namespaces to test connectivity
-            await self.list_namespaces()
+            namespaces = self.client.namespaces()
             return True
         except Exception as e:
             logger.warning(f"Turbopuffer health check failed: {e}")
             return False
     
-    def _generate_vector_id(self, project_id: str, chunk_id: int) -> str:
+    def generate_vector_id(self, project_id: str, chunk_id: int) -> str:
         """Generate a unique vector ID."""
         return f"{project_id}_{chunk_id}_{uuid.uuid4().hex[:8]}"
     
-    async def upsert_vectors(
+    def upsert_vectors(
         self,
         vectors: List[Dict[str, Any]],
         namespace: str,
         **kwargs
     ) -> Dict[str, Any]:
-        """
-        Store or update vectors in the database.
-        
-        Args:
-            vectors: List of vector objects with id, values, and metadata
-            namespace: Turbopuffer namespace to store vectors in
-            **kwargs: Additional arguments
-            
-        Returns:
-            Response from Turbopuffer API
-        """
+        """Store or update vectors in the database."""
         if not vectors:
             return {"upserted": 0}
         
         logger.info(f"Upserting {len(vectors)} vectors to namespace '{namespace}'")
         
-        # Format vectors for Turbopuffer API
+        # Format vectors for Turbopuffer SDK
         formatted_vectors = []
         for vector in vectors:
             if "id" not in vector or "values" not in vector:
@@ -75,210 +70,108 @@ class TurbopufferClient(BaseProvider):
             }
             formatted_vectors.append(formatted_vector)
         
-        request_data = {
-            "vectors": formatted_vectors,
-        }
-        
         try:
-            response = await self._make_request(
-                method="POST",
-                endpoint=f"/namespaces/{namespace}/vectors",
-                data=request_data,
-            )
+            ns = self.client.namespace(namespace)
+            ns.upsert(vectors=formatted_vectors)
             
             logger.info(f"Successfully upserted {len(vectors)} vectors")
-            return response
+            return {"upserted": len(vectors)}
             
         except Exception as e:
             logger.error(f"Failed to upsert vectors: {e}")
-            raise ProviderError(f"Vector upsert failed: {e}")
+            raise RuntimeError(f"Vector upsert failed: {e}")
     
-    async def search_vectors(
+    def search_vectors(
         self,
         query_vector: List[float],
         top_k: int = 10,
         namespace: str = "default",
         filters: Optional[Dict[str, Any]] = None,
-        include_attributes: bool = True,
         **kwargs
     ) -> List[Dict[str, Any]]:
-        """
-        Search for similar vectors.
-        
-        Args:
-            query_vector: Query vector to search with
-            top_k: Number of results to return
-            namespace: Turbopuffer namespace to search in
-            filters: Metadata filters to apply
-            include_attributes: Whether to include vector attributes in results
-            **kwargs: Additional arguments
-            
-        Returns:
-            List of search results with id, score, and metadata
-        """
+        """Search for similar vectors."""
         logger.debug(f"Searching {top_k} vectors in namespace '{namespace}'")
         
-        request_data = {
-            "vector": query_vector,
-            "top_k": top_k,
-            "include_attributes": include_attributes,
-        }
-        
-        if filters:
-            request_data["filters"] = filters
-        
         try:
-            response = await self._make_request(
-                method="POST",
-                endpoint=f"/namespaces/{namespace}/search",
-                data=request_data,
+            ns = self.client.namespace(namespace)
+            
+            results = ns.query(
+                rank_by=[("vector", "ANN", query_vector)],
+                top_k=top_k,
+                filters=filters,
+                include_attributes=True
             )
             
-            results = response.get("results", [])
             logger.debug(f"Found {len(results)} similar vectors")
-            
             return results
             
         except Exception as e:
             logger.error(f"Vector search failed: {e}")
-            raise ProviderError(f"Vector search failed: {e}")
+            raise RuntimeError(f"Vector search failed: {e}")
     
-    async def delete_vectors(
+    def delete_vectors(
         self,
         vector_ids: List[str],
         namespace: str,
         **kwargs
     ) -> Dict[str, Any]:
-        """
-        Delete vectors by ID.
-        
-        Args:
-            vector_ids: List of vector IDs to delete
-            namespace: Turbopuffer namespace
-            **kwargs: Additional arguments
-            
-        Returns:
-            Response from Turbopuffer API
-        """
+        """Delete vectors by ID."""
         if not vector_ids:
             return {"deleted": 0}
         
         logger.info(f"Deleting {len(vector_ids)} vectors from namespace '{namespace}'")
         
-        request_data = {
-            "ids": vector_ids,
-        }
-        
         try:
-            response = await self._make_request(
-                method="DELETE",
-                endpoint=f"/namespaces/{namespace}/vectors",
-                data=request_data,
-            )
+            ns = self.client.namespace(namespace)
+            ns.delete(ids=vector_ids)
             
             logger.info(f"Successfully deleted vectors")
-            return response
+            return {"deleted": len(vector_ids)}
             
         except Exception as e:
             logger.error(f"Failed to delete vectors: {e}")
-            raise ProviderError(f"Vector deletion failed: {e}")
-    
-    async def get_namespace_stats(
-        self,
-        namespace: str,
-        **kwargs
-    ) -> Dict[str, Any]:
-        """
-        Get statistics about a namespace.
-        
-        Args:
-            namespace: Turbopuffer namespace
-            **kwargs: Additional arguments
-            
-        Returns:
-            Namespace statistics
-        """
-        try:
-            response = await self._make_request(
-                method="GET",
-                endpoint=f"/namespaces/{namespace}",
-            )
-            
-            return response
-            
-        except Exception as e:
-            logger.error(f"Failed to get namespace stats: {e}")
-            raise ProviderError(f"Namespace stats failed: {e}")
+            raise RuntimeError(f"Vector deletion failed: {e}")
     
-    async def list_namespaces(self) -> List[str]:
+    def list_namespaces(self) -> List[str]:
         """List all available namespaces."""
         try:
-            response = await self._make_request(
-                method="GET",
-                endpoint="/namespaces",
-            )
-            
-            namespaces = response.get("namespaces", [])
-            return [ns["name"] for ns in namespaces]
+            namespaces = self.client.namespaces()
+            return [ns.name for ns in namespaces]
             
         except Exception as e:
             logger.error(f"Failed to list namespaces: {e}")
-            raise ProviderError(f"Namespace listing failed: {e}")
+            raise RuntimeError(f"Namespace listing failed: {e}")
     
-    async def create_namespace(
-        self,
-        namespace: str,
-        dimension: int,
-        **kwargs
-    ) -> Dict[str, Any]:
-        """
-        Create a new namespace.
-        
-        Args:
-            namespace: Name of the namespace to create
-            dimension: Vector dimension for the namespace
-            **kwargs: Additional arguments
-            
-        Returns:
-            Response from Turbopuffer API
-        """
+    def create_namespace(self, namespace: str, dimension: int, **kwargs) -> Dict[str, Any]:
+        """Create a new namespace."""
         logger.info(f"Creating namespace '{namespace}' with dimension {dimension}")
         
-        request_data = {
-            "name": namespace,
-            "dimension": dimension,
-        }
-        
         try:
-            response = await self._make_request(
-                method="POST",
-                endpoint="/namespaces",
-                data=request_data,
+            self.client.create_namespace(
+                name=namespace,
+                dimension=dimension
             )
             
             logger.info(f"Successfully created namespace '{namespace}'")
-            return response
+            return {"name": namespace, "dimension": dimension}
             
         except Exception as e:
             logger.error(f"Failed to create namespace: {e}")
-            raise ProviderError(f"Namespace creation failed: {e}")
+            raise RuntimeError(f"Namespace creation failed: {e}")
     
-    async def delete_namespace(self, namespace: str) -> Dict[str, Any]:
+    def delete_namespace(self, namespace: str) -> Dict[str, Any]:
         """Delete a namespace and all its vectors."""
         logger.warning(f"Deleting namespace '{namespace}' and all its vectors")
         
         try:
-            response = await self._make_request(
-                method="DELETE",
-                endpoint=f"/namespaces/{namespace}",
-            )
+            self.client.delete_namespace(namespace)
             
             logger.info(f"Successfully deleted namespace '{namespace}'")
-            return response
+            return {"deleted": namespace}
             
         except Exception as e:
             logger.error(f"Failed to delete namespace: {e}")
-            raise ProviderError(f"Namespace deletion failed: {e}")
+            raise RuntimeError(f"Namespace deletion failed: {e}")
     
     def get_namespace_for_project(self, project_id: str) -> str:
         """Get the namespace name for a project."""
@@ -286,7 +179,7 @@ class TurbopufferClient(BaseProvider):
         safe_project_id = "".join(c if c.isalnum() or c in "-_" else "_" for c in project_id)
         return f"mcp_code_{safe_project_id}".lower()
     
-    async def search_with_metadata_filter(
+    def search_with_metadata_filter(
         self,
         query_vector: List[float],
         project_id: str,
@@ -295,20 +188,7 @@ class TurbopufferClient(BaseProvider):
         top_k: int = 10,
         **kwargs
     ) -> List[Dict[str, Any]]:
-        """
-        Search vectors with metadata filtering.
-        
-        Args:
-            query_vector: Query vector
-            project_id: Project to search within
-            chunk_type: Filter by chunk type (optional)
-            file_path: Filter by file path (optional)
-            top_k: Number of results to return
-            **kwargs: Additional arguments
-            
-        Returns:
-            Filtered search results
-        """
+        """Search vectors with metadata filtering."""
         namespace = self.get_namespace_for_project(project_id)
         
         # Build metadata filters
@@ -318,7 +198,7 @@ class TurbopufferClient(BaseProvider):
         if file_path:
             filters["file_path"] = file_path
         
-        return await self.search_vectors(
+        return self.search_vectors(
             query_vector=query_vector,
             top_k=top_k,
             namespace=namespace,
@@ -333,6 +213,5 @@ def create_turbopuffer_client(config: VectorConfig) -> TurbopufferClient:
     
     return TurbopufferClient(
         api_key=config.turbopuffer_api_key,
-        timeout=30.0,
-        max_retries=3,
+        region=config.turbopuffer_region,
     )

mcp_code_indexer/vector_mode/providers/voyage_client.py

@@ -1,164 +1,78 @@
 """
-Voyage AI client for embedding generation.
+Voyage AI client for embedding generation using official SDK.
 
-Provides integration with Voyage AI's embedding API for generating
+Provides clean integration with Voyage AI's embedding API for generating
 high-quality code embeddings using the voyage-code-2 model.
 """
 
 import logging
-from typing import List, Dict, Any, Optional, Union
-import tiktoken
+from typing import List, Dict, Any
+import voyageai
 
-from .base_provider import BaseProvider, ProviderError
 from ..config import VectorConfig
 
 logger = logging.getLogger(__name__)
 
-class VoyageClient(BaseProvider):
-    """Client for Voyage AI embedding generation."""
+class VoyageClient:
+    """Clean Voyage AI client using official SDK."""
     
-    def __init__(
-        self,
-        api_key: str,
-        model: str = "voyage-code-2",
-        base_url: str = "https://api.voyageai.com/v1",
-        **kwargs
-    ):
-        super().__init__(api_key, base_url, **kwargs)
+    def __init__(self, api_key: str, model: str = "voyage-code-2"):
+        self.api_key = api_key
         self.model = model
-        self._embedding_dimension: Optional[int] = None
+        self._embedding_dimension: int | None = None
         
-        # Note: Voyage AI uses proprietary tokenizer, not tiktoken
-        # We'll use approximate counting and let the API handle truncation
-        self.tokenizer = None
-        logger.info("Using approximate token counting - Voyage AI handles tokenization internally")
+        # Initialize official Voyage AI client
+        self.client = voyageai.Client(api_key=api_key)
+        logger.info(f"Initialized Voyage AI client with model {model}")
     
-    async def health_check(self) -> bool:
+    def health_check(self) -> bool:
         """Check if Voyage AI service is healthy."""
         try:
-            # Make a small test request
-            await self.generate_embeddings(["test"], input_type="query")
-            return True
+            result = self.client.embed(["test"], model=self.model, input_type="query")
+            return len(result.embeddings) > 0
         except Exception as e:
             logger.warning(f"Voyage AI health check failed: {e}")
             return False
     
-    def _count_tokens(self, text: str) -> int:
-        """Approximate token count - Voyage AI handles exact tokenization."""
-        # Voyage AI uses proprietary tokenizer - this is just for batching estimates
-        # Rough approximation: 4 characters per token (conservative estimate)
-        return len(text) // 4
-    
-    def _batch_texts_by_tokens(
-        self,
-        texts: List[str],
-        max_tokens_per_batch: int = 120000  # Leave buffer under 128k limit
-    ) -> List[List[str]]:
-        """Batch texts to stay under token limits."""
-        batches = []
-        current_batch = []
-        current_tokens = 0
-        
-        for text in texts:
-            text_tokens = self._count_tokens(text)
-            
-            # If single text exceeds limit, truncate it (let Voyage API handle exact truncation)
-            if text_tokens > max_tokens_per_batch:
-                # Rough character-based truncation - Voyage API will handle exact tokenization
-                target_chars = (max_tokens_per_batch - 100) * 4  # Conservative estimate
-                text = text[:target_chars]
-                text_tokens = self._count_tokens(text)
-                
-                logger.warning(f"Pre-truncated text to ~{text_tokens} tokens (Voyage API will handle exact tokenization)")
-            
-            # Check if adding this text would exceed the batch limit
-            if current_tokens + text_tokens > max_tokens_per_batch and current_batch:
-                batches.append(current_batch)
-                current_batch = [text]
-                current_tokens = text_tokens
-            else:
-                current_batch.append(text)
-                current_tokens += text_tokens
-        
-        if current_batch:
-            batches.append(current_batch)
-        
-        return batches
-    
-    async def generate_embeddings(
+    def generate_embeddings(
         self,
         texts: List[str],
         input_type: str = "document",
-        truncation: bool = True,
         **kwargs
     ) -> List[List[float]]:
-        """
-        Generate embeddings for a list of texts.
-        
-        Args:
-            texts: List of texts to embed
-            input_type: Type of input ("document" or "query")
-            truncation: Whether to enable truncation
-            **kwargs: Additional arguments
-            
-        Returns:
-            List of embedding vectors
-        """
+        """Generate embeddings for texts using official SDK."""
         if not texts:
             return []
         
         logger.info(f"Generating embeddings for {len(texts)} texts using {self.model}")
         
-        # Batch texts to stay under token limits
-        batches = self._batch_texts_by_tokens(texts)
-        all_embeddings = []
-        
-        for i, batch in enumerate(batches):
-            logger.debug(f"Processing batch {i+1}/{len(batches)} with {len(batch)} texts")
+        try:
+            result = self.client.embed(
+                texts=texts,
+                model=self.model,
+                input_type=input_type,
+                truncation=True
+            )
             
-            request_data = {
-                "input": batch,
-                "model": self.model,
-                "input_type": input_type,
-                "truncation": truncation,
-            }
+            # Log usage if available
+            if hasattr(result, 'usage') and result.usage:
+                logger.debug(f"Token usage: {result.usage.total_tokens}")
             
-            try:
-                response = await self._make_request(
-                    method="POST",
-                    endpoint="/embeddings",
-                    data=request_data,
-                )
-                
-                # Extract embeddings from response
-                if "data" not in response:
-                    raise ProviderError("Invalid response format from Voyage AI")
-                
-                batch_embeddings = [item["embedding"] for item in response["data"]]
-                all_embeddings.extend(batch_embeddings)
-                
-                # Log usage information if available
-                if "usage" in response:
-                    usage = response["usage"]
-                    logger.debug(
-                        f"Batch {i+1} usage: {usage.get('total_tokens', 0)} tokens"
-                    )
-                
-            except Exception as e:
-                logger.error(f"Failed to generate embeddings for batch {i+1}: {e}")
-                raise ProviderError(f"Embedding generation failed: {e}")
-        
-        logger.info(f"Successfully generated {len(all_embeddings)} embeddings")
-        return all_embeddings
+            logger.info(f"Successfully generated {len(result.embeddings)} embeddings")
+            return result.embeddings
+            
+        except Exception as e:
+            logger.error(f"Failed to generate embeddings: {e}")
+            raise RuntimeError(f"Embedding generation failed: {e}")
     
-    async def get_embedding_dimension(self) -> int:
+    def get_embedding_dimension(self) -> int:
         """Get the dimension of embeddings produced by this model."""
         if self._embedding_dimension is not None:
             return self._embedding_dimension
         
         # Generate a test embedding to determine dimension
         try:
-            test_embeddings = await self.generate_embeddings(["test"], input_type="query")
+            test_embeddings = self.generate_embeddings(["test"], input_type="query")
             if test_embeddings:
                 self._embedding_dimension = len(test_embeddings[0])
                 logger.info(f"Detected embedding dimension: {self._embedding_dimension}")
@@ -166,27 +80,22 @@ class VoyageClient(BaseProvider):
         except Exception as e:
             logger.warning(f"Could not determine embedding dimension: {e}")
         
-        # Default dimensions for known Voyage models (as of 2024)
-        # Note: These may change - verify with Voyage AI documentation
+        # Default dimensions for known Voyage models
         model_dimensions = {
-            "voyage-code-2": 1536,    # Code-optimized model
-            "voyage-2": 1024,         # General purpose
-            "voyage-large-2": 1536,   # Large general purpose
-            "voyage-3": 1024,         # Newer general purpose (if available)
+            "voyage-code-2": 1536,
+            "voyage-2": 1024,
+            "voyage-large-2": 1536,
+            "voyage-3": 1024,
         }
         
         self._embedding_dimension = model_dimensions.get(self.model, 1536)
-        logger.info(f"Using default dimension for {self.model}: {self._embedding_dimension}")
+        logger.info(f"Using default embedding dimension: {self._embedding_dimension}")
         return self._embedding_dimension
     
-    async def generate_query_embedding(self, query: str) -> List[float]:
-        """Generate a single embedding for a search query."""
-        embeddings = await self.generate_embeddings([query], input_type="query")
-        return embeddings[0] if embeddings else []
-    
-    async def estimate_cost(self, texts: List[str]) -> Dict[str, Any]:
+    def estimate_cost(self, texts: List[str]) -> Dict[str, Any]:
         """Estimate the cost of embedding generation."""
-        total_tokens = sum(self._count_tokens(text) for text in texts)
+        # Rough token estimation (4 chars per token)
+        total_tokens = sum(len(text) // 4 for text in texts)
         
         # Voyage AI pricing (approximate, may change)
         cost_per_1k_tokens = 0.00013  # voyage-code-2 pricing
@@ -207,6 +116,4 @@ def create_voyage_client(config: VectorConfig) -> VoyageClient:
     return VoyageClient(
         api_key=config.voyage_api_key,
         model=config.embedding_model,
-        timeout=30.0,
-        max_retries=3,
     )

{mcp_code_indexer-4.1.0.dist-info → mcp_code_indexer-4.2.1.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.3
 Name: mcp-code-indexer
-Version: 4.1.0
+Version: 4.2.1
 Summary: MCP server that tracks file descriptions across codebases, enabling AI agents to efficiently navigate and understand code through searchable summaries and token-aware overviews.
 License: MIT
 Keywords: mcp,model-context-protocol,code-indexer,ai-tools,codebase-navigation,file-descriptions,llm-tools
 Author: MCP Code Indexer Contributors
 Maintainer: MCP Code Indexer Contributors
-Requires-Python: >=3.9,<4.0
+Requires-Python: >=3.10,<3.13
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Framework :: AsyncIO
@@ -14,16 +14,15 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.9
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Provides-Extra: vector
 Requires-Dist: aiofiles (==23.2.0)
 Requires-Dist: aiohttp (>=3.8.0)
 Requires-Dist: aiosqlite (==0.19.0)
@@ -33,10 +32,15 @@ Requires-Dist: importlib-metadata (>=1.0.0) ; python_version < "3.8"
 Requires-Dist: mcp (>=1.9.0)
 Requires-Dist: pydantic (>=2.8.0)
 Requires-Dist: python-multipart (>=0.0.6)
+Requires-Dist: pyyaml (>=6.0)
 Requires-Dist: tenacity (>=8.0.0)
 Requires-Dist: tiktoken (>=0.9.0)
 Requires-Dist: tomli (>=1.2.0) ; python_version < "3.11"
+Requires-Dist: tree-sitter (>=0.25.0)
+Requires-Dist: turbopuffer (>=0.6.0)
 Requires-Dist: uvicorn (>=0.24.0)
+Requires-Dist: voyageai (>=0.3.0)
+Requires-Dist: watchdog (>=6.0.0)
 Project-URL: Documentation, https://github.com/fluffypony/mcp-code-indexer/blob/main/README.md
 Project-URL: Homepage, https://github.com/fluffypony/mcp-code-indexer
 Project-URL: Repository, https://github.com/fluffypony/mcp-code-indexer
@@ -44,8 +48,8 @@ Description-Content-Type: text/markdown
 
 # MCP Code Indexer 🚀
 
-[![PyPI version](https://badge.fury.io/py/mcp-code-indexer.svg?46)](https://badge.fury.io/py/mcp-code-indexer)
-[![Python](https://img.shields.io/pypi/pyversions/mcp-code-indexer.svg?46)](https://pypi.org/project/mcp-code-indexer/)
+[![PyPI version](https://badge.fury.io/py/mcp-code-indexer.svg?48)](https://badge.fury.io/py/mcp-code-indexer)
+[![Python](https://img.shields.io/pypi/pyversions/mcp-code-indexer.svg?48)](https://pypi.org/project/mcp-code-indexer/)
 [![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
 A production-ready **Model Context Protocol (MCP) server** that revolutionizes how AI agents navigate and understand codebases. Built for high-concurrency environments with advanced database resilience, the server provides instant access to intelligent descriptions, semantic search, and context-aware recommendations while maintaining 800+ writes/sec throughput.
@@ -215,12 +219,15 @@ Vector Mode transforms how you search and understand codebases by using AI embed
 ### 🚀 Quick Start
 
 ```bash
-# Install vector mode dependencies
-pip install mcp-code-indexer[vector]
+# Install MCP Code Indexer (includes vector mode)
+pip install mcp-code-indexer
 
 # Set required API keys
 export VOYAGE_API_KEY="pa-your-voyage-api-key"
-export TURBOPUFFER_API_KEY="your-turbopuffer-api-key" 
+export TURBOPUFFER_API_KEY="your-turbopuffer-api-key"
+
+# Optional: Configure region (default: gcp-europe-west3)
+export TURBOPUFFER_REGION="gcp-europe-west3" 
 
 # Start with vector mode enabled
 mcp-code-indexer --vector

{mcp_code_indexer-4.1.0.dist-info → mcp_code_indexer-4.2.1.dist-info}/RECORD

@@ -19,7 +19,7 @@ mcp_code_indexer/error_handler.py,sha256=ylciEM-cR7E8Gmd8cfh5olcllJm0FnaYBGH86ya
 mcp_code_indexer/file_scanner.py,sha256=7Ab34lRQGeh5GBCzcSP96p4YK6LDWFGUHLXqi499UZ4,11838
 mcp_code_indexer/git_hook_handler.py,sha256=sTtZV3-Yy1Evt06R5NZclELeepM4Ia9OQoR2O6BK3Hk,45517
 mcp_code_indexer/logging_config.py,sha256=M5eVZ5PwfTROib7ISTQ522n2hUSc4hJ_wUgsrJKsTTg,10030
-mcp_code_indexer/main.py,sha256=tdUEcTVLweLmrG49TReGAl1nBf0vnzCIa7NSg6IPPec,37137
+mcp_code_indexer/main.py,sha256=tII1x_LHmD1T951-L1lTzXkR9Vz0z8_pNs-mznfj1CY,37133
 mcp_code_indexer/middleware/__init__.py,sha256=UCEPzOlZldlqFzYEfrXw1HvCDvY1jpLvyaDGUzVr2aw,368
 mcp_code_indexer/middleware/auth.py,sha256=4HkHMDZBNsyPA1VE8qF7pRNKbqG4xIDZjllENbgynxI,7258
 mcp_code_indexer/middleware/error_middleware.py,sha256=0RnKM5fK_n_7AITK2ueAqv30kLBdjU3vaWOTwWd2Xs0,11965
@@ -46,21 +46,20 @@ mcp_code_indexer/vector_mode/chunking/__init__.py,sha256=rjjFMbHsqWIBzL4IajYxXXJ
 mcp_code_indexer/vector_mode/chunking/ast_chunker.py,sha256=GTl_6U0nSgDRRzKS07tJ7RMX8AmJvvY_IsRn95hvVfA,14623
 mcp_code_indexer/vector_mode/chunking/chunk_optimizer.py,sha256=xD0zEibjt6FLBFaKHNc63-iKTtCgnOlLL_9Hc8mCrzE,19752
 mcp_code_indexer/vector_mode/chunking/language_handlers.py,sha256=YEpTVjzyJH445OjniGV05apexsfG5KVR4lwBEl4mGJc,18189
-mcp_code_indexer/vector_mode/config.py,sha256=OgjkY-chGIWJCusNA327gm0Jzy_j6U-k4Qdiq70MRBM,6023
+mcp_code_indexer/vector_mode/config.py,sha256=g5p9Q4EAR20DfLv4RxaQnk3_UdysuvWS8rcsjs1vgwI,6680
 mcp_code_indexer/vector_mode/daemon.py,sha256=le3NkxFD73bKeutruzLY-Bauc-nXzlhlIlDJv4jlxhU,12096
 mcp_code_indexer/vector_mode/monitoring/__init__.py,sha256=9rNWCvHxRMvYumdIrPjb5K9fpOwe1Aem24hdh8gXoDM,439
 mcp_code_indexer/vector_mode/monitoring/change_detector.py,sha256=X82e_sKbJJFPhqZFJubLQb8Rs-srRtS7sh0nUOsPCPw,10338
 mcp_code_indexer/vector_mode/monitoring/file_watcher.py,sha256=AQ6YHSKXPubtprLZngeLb0othJOCNQZ7wwXUvqwphT4,15299
 mcp_code_indexer/vector_mode/monitoring/merkle_tree.py,sha256=83RLdUj_cgcAlrT9Wev9IBavVEyc8Jo8w--IOJisLOk,14645
-mcp_code_indexer/vector_mode/providers/__init__.py,sha256=xZLGtAuaQpEWm5KW5Bdf8fMO92wb7OwOedSKhacjmwY,1908
-mcp_code_indexer/vector_mode/providers/base_provider.py,sha256=4lmWUTDwB5CmFhEc004DkniiCuiRfFFTBBB0BOHlsUE,7513
-mcp_code_indexer/vector_mode/providers/turbopuffer_client.py,sha256=97em_sHGvzEy6h1BI4Ux7IPj8U4d5ayYJyLwzmFRMyM,10758
-mcp_code_indexer/vector_mode/providers/voyage_client.py,sha256=12uVi6Hqo2dfoUnbxaXohlsDmfBkeRKEotbvEPzT3n4,8315
+mcp_code_indexer/vector_mode/providers/__init__.py,sha256=0GhPHn7XEBSHa6bLvy8j0Eqvto82o6Bs2hZCrHawLus,514
+mcp_code_indexer/vector_mode/providers/turbopuffer_client.py,sha256=NdBAghmaRUUIGFZOTOZYhYyXvv_QB36lieGQjVlLEno,7599
+mcp_code_indexer/vector_mode/providers/voyage_client.py,sha256=pfm9BOx5Temf0LM-VZ4LH6xwBmZ6XO8XeCSiSZ5LU80,4375
 mcp_code_indexer/vector_mode/security/__init__.py,sha256=itfeuysSqV-m9xuo-CMkAoucxexVfPgeOU-ieTLvdls,336
 mcp_code_indexer/vector_mode/security/patterns.py,sha256=0xaiMnZm7YXswq3hVe_DJYePE9MhWuvizApLnmXus9M,11572
 mcp_code_indexer/vector_mode/security/redactor.py,sha256=tsFzhCJ99bp4EFqQVjZ-4f8Uf3ux9X4ODVR09oJG01U,13380
-mcp_code_indexer-4.1.0.dist-info/LICENSE,sha256=JN9dyPPgYwH9C-UjYM7FLNZjQ6BF7kAzpF3_4PwY4rY,1086
-mcp_code_indexer-4.1.0.dist-info/METADATA,sha256=_oF0bxlQWX1SczGQb-nUVkNPWHs4Pt0DlqczLacfSPw,27221
-mcp_code_indexer-4.1.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-mcp_code_indexer-4.1.0.dist-info/entry_points.txt,sha256=UABj7HZ0mC6rvF22gxaz2LLNLGQShTrFmp5u00iUtvo,67
-mcp_code_indexer-4.1.0.dist-info/RECORD,,
+mcp_code_indexer-4.2.1.dist-info/LICENSE,sha256=JN9dyPPgYwH9C-UjYM7FLNZjQ6BF7kAzpF3_4PwY4rY,1086
+mcp_code_indexer-4.2.1.dist-info/METADATA,sha256=jsPpjmDRZabOKWzLTt0MHzdE-jaNJCiosMx2SBQCtJU,27483
+mcp_code_indexer-4.2.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+mcp_code_indexer-4.2.1.dist-info/entry_points.txt,sha256=UABj7HZ0mC6rvF22gxaz2LLNLGQShTrFmp5u00iUtvo,67
+mcp_code_indexer-4.2.1.dist-info/RECORD,,

mcp_code_indexer/vector_mode/providers/base_provider.py

@@ -1,230 +0,0 @@
-"""
-Base provider classes with common functionality.
-
-Provides retry logic, circuit breaker pattern, and error handling
-for external service integrations.
-"""
-
-import asyncio
-import logging
-import time
-from typing import Any, Dict, List, Optional, Callable, TypeVar
-from abc import ABC, abstractmethod
-from contextlib import asynccontextmanager
-import aiohttp
-from tenacity import (
-    retry,
-    stop_after_attempt,
-    wait_exponential,
-    retry_if_exception_type,
-    retry_if_result,
-    before_sleep_log,
-)
-
-logger = logging.getLogger(__name__)
-
-T = TypeVar('T')
-
-class CircuitBreakerError(Exception):
-    """Raised when circuit breaker is open."""
-    pass
-
-class ProviderError(Exception):
-    """Base exception for provider errors."""
-    pass
-
-class RateLimitError(ProviderError):
-    """Raised when rate limit is exceeded."""
-    pass
-
-class AuthenticationError(ProviderError):
-    """Raised when authentication fails."""
-    pass
-
-class CircuitBreaker:
-    """Circuit breaker implementation for external services."""
-    
-    def __init__(
-        self,
-        failure_threshold: int = 5,
-        recovery_timeout: float = 60.0,
-        expected_exception: type = Exception,
-    ):
-        self.failure_threshold = failure_threshold
-        self.recovery_timeout = recovery_timeout
-        self.expected_exception = expected_exception
-        
-        self.failure_count = 0
-        self.last_failure_time: Optional[float] = None
-        self.state = "closed"  # closed, open, half-open
-    
-    def _should_attempt_reset(self) -> bool:
-        """Check if we should attempt to reset the circuit breaker."""
-        return (
-            self.state == "open"
-            and self.last_failure_time is not None
-            and time.time() - self.last_failure_time >= self.recovery_timeout
-        )
-    
-    async def call(self, func: Callable[[], T]) -> T:
-        """Call a function through the circuit breaker."""
-        if self.state == "open":
-            if self._should_attempt_reset():
-                self.state = "half-open"
-                logger.info("Circuit breaker attempting reset")
-            else:
-                raise CircuitBreakerError("Circuit breaker is open")
-        
-        try:
-            result = await func()
-            # Success - reset failure count
-            if self.state == "half-open":
-                self.state = "closed"
-                logger.info("Circuit breaker reset to closed")
-            self.failure_count = 0
-            return result
-            
-        except self.expected_exception as e:
-            self.failure_count += 1
-            self.last_failure_time = time.time()
-            
-            if self.failure_count >= self.failure_threshold:
-                self.state = "open"
-                logger.warning(
-                    f"Circuit breaker opened after {self.failure_count} failures"
-                )
-            
-            raise
-
-class BaseProvider(ABC):
-    """Base class for external service providers."""
-    
-    def __init__(
-        self,
-        api_key: str,
-        base_url: str,
-        timeout: float = 30.0,
-        max_retries: int = 3,
-        circuit_breaker_enabled: bool = True,
-    ):
-        self.api_key = api_key
-        self.base_url = base_url.rstrip('/')
-        self.timeout = timeout
-        self.max_retries = max_retries
-        
-        # Circuit breaker for resilience
-        self.circuit_breaker = CircuitBreaker(
-            failure_threshold=5,
-            recovery_timeout=60.0,
-            expected_exception=(aiohttp.ClientError, ProviderError),
-        ) if circuit_breaker_enabled else None
-        
-        # Rate limiting state
-        self.last_request_time: Optional[float] = None
-        self.min_request_interval = 0.1  # 100ms between requests
-        
-        # Session will be created lazily
-        self._session: Optional[aiohttp.ClientSession] = None
-    
-    @asynccontextmanager
-    async def _get_session(self):
-        """Get or create HTTP session."""
-        if self._session is None or self._session.closed:
-            connector = aiohttp.TCPConnector(
-                limit=100,
-                limit_per_host=30,
-                ttl_dns_cache=300,
-                use_dns_cache=True,
-            )
-            timeout = aiohttp.ClientTimeout(total=self.timeout)
-            self._session = aiohttp.ClientSession(
-                connector=connector,
-                timeout=timeout,
-                headers=self._get_default_headers(),
-            )
-        
-        try:
-            yield self._session
-        finally:
-            # Keep session alive for reuse
-            pass
-    
-    def _get_default_headers(self) -> Dict[str, str]:
-        """Get default headers for API requests."""
-        return {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json",
-            "User-Agent": "mcp-code-indexer/1.0.0",
-        }
-    
-    async def _rate_limit_wait(self) -> None:
-        """Wait if necessary to respect rate limits."""
-        if self.last_request_time is not None:
-            elapsed = time.time() - self.last_request_time
-            if elapsed < self.min_request_interval:
-                await asyncio.sleep(self.min_request_interval - elapsed)
-        
-        self.last_request_time = time.time()
-    
-    @retry(
-        stop=stop_after_attempt(3),
-        wait=wait_exponential(multiplier=1, min=1, max=10),
-        retry=retry_if_exception_type((aiohttp.ClientError, RateLimitError)),
-        before_sleep=before_sleep_log(logger, logging.WARNING),
-    )
-    async def _make_request(
-        self,
-        method: str,
-        endpoint: str,
-        data: Optional[Dict[str, Any]] = None,
-        params: Optional[Dict[str, Any]] = None,
-        **kwargs
-    ) -> Dict[str, Any]:
-        """Make an HTTP request with retry logic."""
-        
-        async def _request():
-            await self._rate_limit_wait()
-            
-            url = f"{self.base_url}/{endpoint.lstrip('/')}"
-            
-            async with self._get_session() as session:
-                async with session.request(
-                    method=method,
-                    url=url,
-                    json=data,
-                    params=params,
-                    **kwargs
-                ) as response:
-                    response_data = await response.json()
-                    
-                    if response.status == 429:
-                        raise RateLimitError("Rate limit exceeded")
-                    elif response.status == 401:
-                        raise AuthenticationError("Authentication failed")
-                    elif response.status >= 400:
-                        raise ProviderError(
-                            f"HTTP {response.status}: {response_data.get('error', 'Unknown error')}"
-                        )
-                    
-                    return response_data
-        
-        if self.circuit_breaker:
-            return await self.circuit_breaker.call(_request)
-        else:
-            return await _request()
-    
-    async def close(self) -> None:
-        """Close the HTTP session."""
-        if self._session and not self._session.closed:
-            await self._session.close()
-    
-    async def __aenter__(self):
-        return self
-    
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        await self.close()
-    
-    @abstractmethod
-    async def health_check(self) -> bool:
-        """Check if the service is healthy."""
-        pass