mcp-vector-search 0.4.12__py3-none-any.whl → 0.4.14__py3-none-any.whl

mcp_vector_search/core/database.py

@@ -1,5 +1,6 @@
 """Database abstraction and ChromaDB implementation for MCP Vector Search."""
 
+import shutil
 from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Any, Protocol, runtime_checkable
@@ -12,6 +13,7 @@ from .exceptions import (
     DatabaseInitializationError,
     DatabaseNotInitializedError,
     DocumentAdditionError,
+    IndexCorruptionError,
     SearchError,
 )
 from .models import CodeChunk, IndexStats, SearchResult
@@ -95,6 +97,15 @@ class VectorDatabase(ABC):
         """Reset the database (delete all data)."""
         ...
 
+    @abstractmethod
+    async def health_check(self) -> bool:
+        """Check database health and integrity.
+        
+        Returns:
+            True if database is healthy, False otherwise
+        """
+        ...
+
     async def __aenter__(self) -> "VectorDatabase":
         """Async context manager entry."""
         await self.initialize()
@@ -128,12 +139,15 @@ class ChromaVectorDatabase(VectorDatabase):
         self._collection = None
 
     async def initialize(self) -> None:
-        """Initialize ChromaDB client and collection."""
+        """Initialize ChromaDB client and collection with corruption recovery."""
         try:
             import chromadb
 
             # Ensure directory exists
             self.persist_directory.mkdir(parents=True, exist_ok=True)
+            
+            # Check for corruption before initializing
+            await self._detect_and_recover_corruption()
 
             # Create client with new API
             self._client = chromadb.PersistentClient(
@@ -156,10 +170,22 @@ class ChromaVectorDatabase(VectorDatabase):
             logger.debug(f"ChromaDB initialized at {self.persist_directory}")
 
         except Exception as e:
-            logger.error(f"Failed to initialize ChromaDB: {e}")
-            raise DatabaseInitializationError(
-                f"ChromaDB initialization failed: {e}"
-            ) from e
+            # Check if this is a corruption error
+            error_msg = str(e).lower()
+            if any(indicator in error_msg for indicator in [
+                "pickle", "unpickling", "eof", "ran out of input",
+                "hnsw", "index", "deserialize", "corrupt"
+            ]):
+                logger.warning(f"Detected index corruption: {e}")
+                # Try to recover
+                await self._recover_from_corruption()
+                # Retry initialization
+                await self.initialize()
+            else:
+                logger.error(f"Failed to initialize ChromaDB: {e}")
+                raise DatabaseInitializationError(
+                    f"ChromaDB initialization failed: {e}"
+                ) from e
 
     async def remove_file_chunks(self, file_path: str) -> int:
         """Remove all chunks for a specific file.
@@ -438,6 +464,114 @@ class ChromaVectorDatabase(VectorDatabase):
 
         return where
 
+    async def _detect_and_recover_corruption(self) -> None:
+        """Detect and recover from index corruption proactively."""
+        # Check for common corruption indicators in ChromaDB files
+        chroma_db_path = self.persist_directory / "chroma.sqlite3"
+        
+        # If database doesn't exist yet, nothing to check
+        if not chroma_db_path.exists():
+            return
+            
+        # Check for HNSW index files that might be corrupted
+        collection_path = self.persist_directory / "chroma-collections.parquet"
+        index_path = self.persist_directory / "index"
+        
+        if index_path.exists():
+            # Look for pickle files in the index
+            pickle_files = list(index_path.glob("**/*.pkl"))
+            pickle_files.extend(list(index_path.glob("**/*.pickle")))
+            
+            for pickle_file in pickle_files:
+                try:
+                    # Try to read the pickle file to detect corruption
+                    import pickle
+                    with open(pickle_file, 'rb') as f:
+                        pickle.load(f)
+                except (EOFError, pickle.UnpicklingError, Exception) as e:
+                    logger.warning(f"Corrupted index file detected: {pickle_file} - {e}")
+                    await self._recover_from_corruption()
+                    return
+
+    async def _recover_from_corruption(self) -> None:
+        """Recover from index corruption by rebuilding the index."""
+        logger.info("Attempting to recover from index corruption...")
+        
+        # Create backup directory
+        backup_dir = self.persist_directory.parent / f"{self.persist_directory.name}_backup"
+        backup_dir.mkdir(exist_ok=True)
+        
+        # Backup current state (in case we need it)
+        import time
+        timestamp = int(time.time())
+        backup_path = backup_dir / f"backup_{timestamp}"
+        
+        if self.persist_directory.exists():
+            try:
+                shutil.copytree(self.persist_directory, backup_path)
+                logger.info(f"Created backup at {backup_path}")
+            except Exception as e:
+                logger.warning(f"Could not create backup: {e}")
+        
+        # Clear the corrupted index
+        if self.persist_directory.exists():
+            try:
+                shutil.rmtree(self.persist_directory)
+                logger.info(f"Cleared corrupted index at {self.persist_directory}")
+            except Exception as e:
+                logger.error(f"Failed to clear corrupted index: {e}")
+                raise IndexCorruptionError(
+                    f"Could not clear corrupted index: {e}"
+                ) from e
+        
+        # Recreate the directory
+        self.persist_directory.mkdir(parents=True, exist_ok=True)
+        logger.info("Index directory recreated. Please re-index your codebase.")
+
+    async def health_check(self) -> bool:
+        """Check database health and integrity.
+        
+        Returns:
+            True if database is healthy, False otherwise
+        """
+        try:
+            # First check if client is initialized
+            if not self._client or not self._collection:
+                logger.warning("Database not initialized")
+                return False
+            
+            # Try a simple operation to test the connection
+            try:
+                # Attempt to get count - this will fail if index is corrupted
+                count = self._collection.count()
+                logger.debug(f"Health check passed: {count} chunks in database")
+                
+                # Try a minimal query to ensure search works
+                self._collection.query(
+                    query_texts=["test"],
+                    n_results=1,
+                    include=["metadatas"]
+                )
+                
+                return True
+                
+            except Exception as e:
+                error_msg = str(e).lower()
+                if any(indicator in error_msg for indicator in [
+                    "pickle", "unpickling", "eof", "ran out of input",
+                    "hnsw", "index", "deserialize", "corrupt"
+                ]):
+                    logger.error(f"Index corruption detected during health check: {e}")
+                    return False
+                else:
+                    # Some other error
+                    logger.warning(f"Health check failed: {e}")
+                    return False
+                    
+        except Exception as e:
+            logger.error(f"Health check error: {e}")
+            return False
+
 
 class PooledChromaVectorDatabase(VectorDatabase):
     """ChromaDB implementation with connection pooling for improved performance."""
@@ -729,7 +863,80 @@ class PooledChromaVectorDatabase(VectorDatabase):
 
     async def health_check(self) -> bool:
         """Perform a health check on the database and connection pool."""
-        return await self._pool.health_check()
+        try:
+            # Check pool health
+            pool_healthy = await self._pool.health_check()
+            if not pool_healthy:
+                return False
+                
+            # Try a simple query to verify database integrity
+            try:
+                async with self._pool.get_connection() as conn:
+                    # Test basic operations
+                    conn.collection.count()
+                    conn.collection.query(
+                        query_texts=["test"],
+                        n_results=1,
+                        include=["metadatas"]
+                    )
+                return True
+            except Exception as e:
+                error_msg = str(e).lower()
+                if any(indicator in error_msg for indicator in [
+                    "pickle", "unpickling", "eof", "ran out of input",
+                    "hnsw", "index", "deserialize", "corrupt"
+                ]):
+                    logger.error(f"Index corruption detected: {e}")
+                    # Attempt recovery
+                    await self._recover_from_corruption()
+                    return False
+                else:
+                    logger.warning(f"Health check failed: {e}")
+                    return False
+        except Exception as e:
+            logger.error(f"Health check error: {e}")
+            return False
+    
+    async def _recover_from_corruption(self) -> None:
+        """Recover from index corruption by rebuilding the index."""
+        logger.info("Attempting to recover from index corruption...")
+        
+        # Close the pool first
+        await self._pool.close()
+        
+        # Create backup directory
+        backup_dir = self.persist_directory.parent / f"{self.persist_directory.name}_backup"
+        backup_dir.mkdir(exist_ok=True)
+        
+        # Backup current state
+        import time
+        timestamp = int(time.time())
+        backup_path = backup_dir / f"backup_{timestamp}"
+        
+        if self.persist_directory.exists():
+            try:
+                shutil.copytree(self.persist_directory, backup_path)
+                logger.info(f"Created backup at {backup_path}")
+            except Exception as e:
+                logger.warning(f"Could not create backup: {e}")
+        
+        # Clear the corrupted index
+        if self.persist_directory.exists():
+            try:
+                shutil.rmtree(self.persist_directory)
+                logger.info(f"Cleared corrupted index at {self.persist_directory}")
+            except Exception as e:
+                logger.error(f"Failed to clear corrupted index: {e}")
+                raise IndexCorruptionError(
+                    f"Could not clear corrupted index: {e}"
+                ) from e
+        
+        # Recreate the directory
+        self.persist_directory.mkdir(parents=True, exist_ok=True)
+        
+        # Reinitialize the pool
+        await self._pool.initialize()
+        logger.info("Index recovered. Please re-index your codebase.")
 
     async def __aenter__(self):
         """Async context manager entry."""

mcp_vector_search/core/exceptions.py

@@ -47,6 +47,12 @@ class SearchError(DatabaseError):
     pass
 
 
+class IndexCorruptionError(DatabaseError):
+    """Index corruption detected."""
+
+    pass
+
+
 class ParsingError(MCPVectorSearchError):
     """Code parsing errors."""
 

mcp_vector_search/core/search.py

@@ -66,6 +66,16 @@ class SemanticSearchEngine:
         if not query.strip():
             return []
 
+        # Health check before search
+        try:
+            if hasattr(self.database, 'health_check'):
+                is_healthy = await self.database.health_check()
+                if not is_healthy:
+                    logger.warning("Database health check failed - attempting recovery")
+                    # Health check already attempts recovery, so we can proceed
+        except Exception as e:
+            logger.warning(f"Health check failed: {e}")
+
         # Auto-reindex check before search
         if self.search_triggered_indexer:
             try:
@@ -106,8 +116,20 @@ class SemanticSearchEngine:
             return ranked_results
 
         except Exception as e:
-            logger.error(f"Search failed for query '{query}': {e}")
-            raise SearchError(f"Search failed: {e}") from e
+            error_msg = str(e).lower()
+            # Check for corruption indicators
+            if any(indicator in error_msg for indicator in [
+                "pickle", "unpickling", "eof", "ran out of input",
+                "hnsw", "index", "deserialize", "corrupt"
+            ]):
+                logger.error(f"Index corruption detected during search: {e}")
+                logger.info("The index appears to be corrupted. Please run 'mcp-vector-search reset' to clear the index and then 'mcp-vector-search index' to rebuild it.")
+                raise SearchError(
+                    "Index corruption detected. Please run 'mcp-vector-search reset' followed by 'mcp-vector-search index' to rebuild."
+                ) from e
+            else:
+                logger.error(f"Search failed for query '{query}': {e}")
+                raise SearchError(f"Search failed: {e}") from e
 
     async def search_similar(
         self,

mcp_vector_search/mcp/server.py

@@ -499,7 +499,6 @@ class MCPVectorSearchServer:
 
         try:
             from pathlib import Path
-            from ..cli.commands.search import run_similar_search
 
             # Convert to Path object
             file_path_obj = Path(file_path)
@@ -532,11 +531,24 @@ class MCPVectorSearchServer:
                     )]
                 )
 
-            result_text = f"Found {len(results)} similar code snippets for {file_path}:\n\n"
+            response_lines = [f"Found {len(results)} similar code snippets for {file_path}\n"]
+            
             for i, result in enumerate(results, 1):
-                result_text += f"{i}. {result.file_path}:{result.line_number}\n"
-                result_text += f"   Similarity: {result.similarity:.3f}\n"
-                result_text += f"   {result.content[:100]}...\n\n"
+                response_lines.append(f"## Result {i} (Score: {result.similarity_score:.3f})")
+                response_lines.append(f"**File:** {result.file_path}")
+                if result.function_name:
+                    response_lines.append(f"**Function:** {result.function_name}")
+                if result.class_name:
+                    response_lines.append(f"**Class:** {result.class_name}")
+                response_lines.append(f"**Lines:** {result.start_line}-{result.end_line}")
+                response_lines.append("**Code:**")
+                response_lines.append("```" + (result.language or ""))
+                # Show more of the content for similar search
+                content_preview = result.content[:500] if len(result.content) > 500 else result.content
+                response_lines.append(content_preview + ("..." if len(result.content) > 500 else ""))
+                response_lines.append("```\n")
+            
+            result_text = "\n".join(response_lines)
 
             return CallToolResult(
                 content=[TextContent(
@@ -586,15 +598,27 @@ class MCPVectorSearchServer:
                     )]
                 )
 
-            result_text = f"Found {len(results)} contextually relevant code snippets"
+            response_lines = [f"Found {len(results)} contextually relevant code snippets"]
             if focus_areas:
-                result_text += f" (focus: {', '.join(focus_areas)})"
-            result_text += f" for: {description}\n\n"
-
+                response_lines[0] += f" (focus: {', '.join(focus_areas)})"
+            response_lines[0] += f" for: {description}\n"
+            
             for i, result in enumerate(results, 1):
-                result_text += f"{i}. {result.file_path}:{result.line_number}\n"
-                result_text += f"   Similarity: {result.similarity:.3f}\n"
-                result_text += f"   {result.content[:100]}...\n\n"
+                response_lines.append(f"## Result {i} (Score: {result.similarity_score:.3f})")
+                response_lines.append(f"**File:** {result.file_path}")
+                if result.function_name:
+                    response_lines.append(f"**Function:** {result.function_name}")
+                if result.class_name:
+                    response_lines.append(f"**Class:** {result.class_name}")
+                response_lines.append(f"**Lines:** {result.start_line}-{result.end_line}")
+                response_lines.append("**Code:**")
+                response_lines.append("```" + (result.language or ""))
+                # Show more of the content for context search
+                content_preview = result.content[:500] if len(result.content) > 500 else result.content
+                response_lines.append(content_preview + ("..." if len(result.content) > 500 else ""))
+                response_lines.append("```\n")
+            
+            result_text = "\n".join(response_lines)
 
             return CallToolResult(
                 content=[TextContent(

{mcp_vector_search-0.4.12.dist-info → mcp_vector_search-0.4.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-vector-search
-Version: 0.4.12
+Version: 0.4.14
 Summary: CLI-first semantic code search with MCP integration
 Project-URL: Homepage, https://github.com/bobmatnyc/mcp-vector-search
 Project-URL: Documentation, https://mcp-vector-search.readthedocs.io

{mcp_vector_search-0.4.12.dist-info → mcp_vector_search-0.4.14.dist-info}/RECORD

@@ -1,12 +1,13 @@
-mcp_vector_search/__init__.py,sha256=nFyxm4tNaoAt44JrlTIxd09tNWtdvFhQr-svXkpKxTo,300
+mcp_vector_search/__init__.py,sha256=ir_M_lclJGDDVJ6Gf_IYKqrhZLJU1I7Tq1zE7pTA7dM,300
 mcp_vector_search/py.typed,sha256=lCKeV9Qcn9sGtbRsgg-LJO2ZwWRuknnnlmomq3bJFH0,43
 mcp_vector_search/cli/__init__.py,sha256=TNB7CaOASz8u3yHWLbNmo8-GtHF0qwUjVKWAuNphKgo,40
-mcp_vector_search/cli/didyoumean.py,sha256=F4b9jTJfeAkg5XLDx93sgiNS-o7NTmnDVEwDrNcg64w,6438
+mcp_vector_search/cli/didyoumean.py,sha256=eq2uhP3E3qrPHmk2BrbFq8i8nT896uq24_IB8dzMHIk,16092
 mcp_vector_search/cli/export.py,sha256=iluxuRT2KELdKlQeDAlVkteiel4GGrng153UAw9H0as,10804
 mcp_vector_search/cli/history.py,sha256=osQVNiTIdGSRZQiJEjC_AYMmHxaqv7RSKSeuO325Ip0,9115
 mcp_vector_search/cli/interactive.py,sha256=T7P4dAdvbglznzQYgiePv5YNyOx9FeE57Y3OKYnnbYE,12744
-mcp_vector_search/cli/main.py,sha256=q_714AV8q7Euf5fTgk5Zs82ELrZ44mRbFqMOmZklZcw,9030
+mcp_vector_search/cli/main.py,sha256=I5WXHyB654YV0j2HODSv8Cy_zm_xfr91pFCSTb_0hLQ,15342
 mcp_vector_search/cli/output.py,sha256=TGtWHrsfFg2tFf05aplZI2pDkoSnlKf_if78qXSRDtE,8077
+mcp_vector_search/cli/suggestions.py,sha256=J7GB4r4PBqGY5QO20ZjfLLls1y1QYdvq0VxE-U3Cz70,12717
 mcp_vector_search/cli/commands/__init__.py,sha256=vQls-YKZ54YEwmf7g1dL0T2SS9D4pdQljXzsUChG_V4,42
 mcp_vector_search/cli/commands/auto_index.py,sha256=imVVbxWRlA128NPdK9BetNNl3ELrsdq-hqcsLqyAmoM,12712
 mcp_vector_search/cli/commands/config.py,sha256=EHLqToCXrZs3gjIAg7pV8Bq8yVslUXWC4AnTcZQgSPQ,11337
@@ -14,6 +15,7 @@ mcp_vector_search/cli/commands/index.py,sha256=LsFCfqfXWd5s11wE_21mpsTitmsKsdGUh
 mcp_vector_search/cli/commands/init.py,sha256=vKg4JlWaPipa9Nca-ruLs8ZZ5tXbczDQrPjHzp9zN1A,24816
 mcp_vector_search/cli/commands/install.py,sha256=sE5mjv2pCDp2tvMj4UqfKLHpSt8Yedcb_CirWLoedDw,10375
 mcp_vector_search/cli/commands/mcp.py,sha256=gpt9hfSmfpcr4rdis2DsenhNnGW5a0B8Xmb3RVEEtuY,17822
+mcp_vector_search/cli/commands/reset.py,sha256=MwAbpqWYoXBHGzks0HDQclwN0qvUUZyPafOYrDOHQSo,14066
 mcp_vector_search/cli/commands/search.py,sha256=UmMtRs15ZO5Bzc_DKWgBRoGwZgm9XXn6Lppsl1o-1I0,16785
 mcp_vector_search/cli/commands/status.py,sha256=CqD3W4wI70o6c2XJiq0c7W0maQshWrsYQkeMyI6S13U,16600
 mcp_vector_search/cli/commands/watch.py,sha256=2pyWRoo4fIppFnyQ4sW4IBLHmpb_IwnTjRnzHkVBPcQ,8927
@@ -23,20 +25,20 @@ mcp_vector_search/config/settings.py,sha256=v1bc2K2yTwDzQKiy_BQhTWCP7FinSWX99vQG
 mcp_vector_search/core/__init__.py,sha256=bWKtKmmaFs7gG5XPCbrx77UYIVeO1FF8wIJxpj1dLNw,48
 mcp_vector_search/core/auto_indexer.py,sha256=0S4lZXaUgqEytMSA2FxQsh5hN7V1mbSLYVzEf_dslYQ,10307
 mcp_vector_search/core/connection_pool.py,sha256=Yo-gUQQbHawtuvh6OcJiAlbbvWQGQBd31QZOvs498fg,11224
-mcp_vector_search/core/database.py,sha256=afYg_AcLY6gcNV6yJ79UUa9zk5OULHcS-s8t3O5LY_Q,26691
+mcp_vector_search/core/database.py,sha256=fo1hp0gs4BXquVuYm3O932f1dRF9N3NAg7HdiXzvDAQ,35178
 mcp_vector_search/core/embeddings.py,sha256=wSMUNxZcuGPMxxQ1AbKqA1a3-0c6AiOqmuuI7OqTyaQ,10578
-mcp_vector_search/core/exceptions.py,sha256=9cW1E2MdWnx9o9gaFBk5XaOwIbWeKGheM_jG7cCZJ3k,1505
+mcp_vector_search/core/exceptions.py,sha256=3bCjT8wmrLz_0e_Tayr90049zNTKYFWZa19kl0saKz8,1597
 mcp_vector_search/core/factory.py,sha256=GnsCBcRndBaUBWSXwtt8QKInAo-rGGBTSOKznUFETwA,10016
 mcp_vector_search/core/git_hooks.py,sha256=xOfPpzgKoNTwM-vbhAihUucgudBQk45bCAVR5zJOFlQ,10878
 mcp_vector_search/core/indexer.py,sha256=NroJxIoAQg1Egv_hZK76co13pbJrBxZ-IN6ZWDFu9W0,15645
 mcp_vector_search/core/models.py,sha256=fnZxvUkd9Afxmdwtw2BJX7uik6rQTwuWBTTqTeqDi0A,6697
 mcp_vector_search/core/project.py,sha256=RNeLBZZw6SO5mXqCwYfhStTGuVgeMq1US5UftG0SBYk,10069
 mcp_vector_search/core/scheduler.py,sha256=PBSlu-ieDYCXOMGYY7QKv9UReFEDPHNmwnUv_xb4vxg,11761
-mcp_vector_search/core/search.py,sha256=qViLXKQuxJEHejtuQDiZOF-sd0IY59xsztxI6hRjDzg,28350
+mcp_vector_search/core/search.py,sha256=5xBl73xxQC0NGAHO0EyvKq39ZNVeW4MVpCrjl_U8UhA,29570
 mcp_vector_search/core/watcher.py,sha256=-DFRCnuUfcqcTrkZPQqfJSvxKAxnpt-axgEj1V-B0O4,10862
 mcp_vector_search/mcp/__init__.py,sha256=gfKR0QV7Jqvj5y0LMBe9gSghd5_rPsvm_rml0ryQtoY,158
 mcp_vector_search/mcp/__main__.py,sha256=vhAUa4S8hoXqfJt4w0yX5z2h5GoPAar8iFqgIW-WdbY,575
-mcp_vector_search/mcp/server.py,sha256=mzlM2RGAoSV-bj6CWOGA86VTBv6weUQPlhVETKwSj80,27020
+mcp_vector_search/mcp/server.py,sha256=ZzLvqHnkIvWNkhqIMPXGpafgS38tS8XtmEmq_i7doHo,28547
 mcp_vector_search/parsers/__init__.py,sha256=nk4clWDWQURMxzC1ev8O_vGlfraHlXqizTDXgFqIP5U,46
 mcp_vector_search/parsers/base.py,sha256=-zBY9T0modfegowaNyf5_upkS3ImR4TgrRwoSLuAiDw,5421
 mcp_vector_search/parsers/javascript.py,sha256=P7fT_tXCzUuXATTkTx_DyD4EuG0_KjIDlay09MhkKTE,9824
@@ -47,8 +49,8 @@ mcp_vector_search/utils/__init__.py,sha256=Eq6lY-oPMfCt-GpPUbg9QbmTHuQVmTaVDBMU2
 mcp_vector_search/utils/gitignore.py,sha256=U1-1FERSYnDbxkH8JGG_azLxLasqkAh1urRUbZskmRU,8208
 mcp_vector_search/utils/timing.py,sha256=THC7mfbTYnUpnnDcblgQacYMzbEkfFoIShx6plmhCgg,11285
 mcp_vector_search/utils/version.py,sha256=d7fS-CLemxb8UzZ9j18zH0Y0Ud097ljKKYYOPulnGPE,1138
-mcp_vector_search-0.4.12.dist-info/METADATA,sha256=opAJJIZHYh57dju7UAooK4ijFMZ5PjkQ0TvjEdlJ68Y,15890
-mcp_vector_search-0.4.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mcp_vector_search-0.4.12.dist-info/entry_points.txt,sha256=dw8_HpBvwhauz6bkMbs3QM6dbstV1mPGo9DcNpVM-bE,69
-mcp_vector_search-0.4.12.dist-info/licenses/LICENSE,sha256=FqZUgGJH_tZKZLQsMCpXaLawRyLmyFKRVfMwYyEcyTs,1072
-mcp_vector_search-0.4.12.dist-info/RECORD,,
+mcp_vector_search-0.4.14.dist-info/METADATA,sha256=EbalUrvvEgqQn5hGu1sD0WyDnL3EFQmZB2meZzmNRdA,15890
+mcp_vector_search-0.4.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_vector_search-0.4.14.dist-info/entry_points.txt,sha256=y3Ygtc_JiBchNEIL-tPABo7EbzBExGAxwGdkkeP5D2I,86
+mcp_vector_search-0.4.14.dist-info/licenses/LICENSE,sha256=FqZUgGJH_tZKZLQsMCpXaLawRyLmyFKRVfMwYyEcyTs,1072
+mcp_vector_search-0.4.14.dist-info/RECORD,,

mcp_vector_search-0.4.14.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mcp-vector-search = mcp_vector_search.cli.main:cli_with_suggestions

mcp_vector_search-0.4.12.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-mcp-vector-search = mcp_vector_search.cli.main:app