zeusdb-vector-database 0.1.2__cp311-cp311-macosx_11_0_arm64.whl → 0.2.0__cp311-cp311-macosx_11_0_arm64.whl

zeusdb_vector_database/__init__.py

@@ -1,7 +1,7 @@
 """
 ZeusDB Vector Database Module
 """
-__version__ = "0.1.2"
+__version__ = "0.2.0"
 
 from .vector_database import VectorDatabase # imports the VectorDatabase class from the vector_database.py file
 

zeusdb_vector_database/vector_database.py

@@ -1,16 +1,24 @@
 """
 vector_database.py
 
-Factory for creating vector indexes with support for multiple types.
+Factory for creating vector indexes with support for multiple types and quantization.
 Currently supports HNSW (Hierarchical Navigable Small World) with extensible design.
 """
-from typing import Callable, Dict, Any
+from typing import Callable, Dict, Any, Optional, TypedDict
 from .zeusdb_vector_database import HNSWIndex
 # from .zeusdb_vector_database import HNSWIndex, IVFIndex, LSHIndex, AnnoyIndex, FlatIndex # Future support planned
 
+class MemoryInfo(TypedDict):
+    """Type definition for quantization memory information."""
+    centroid_storage_mb: float
+    compression_ratio: float
+    centroids_per_subvector: int
+    total_centroids: int
+    calculated_training_size: int
+
 class VectorDatabase:
     """
-    Factory for creating various types of vector indexes.
+    Factory for creating various types of vector indexes with optional quantization.
     Each index type is registered via _index_constructors.
     """
 
@@ -26,12 +34,13 @@ class VectorDatabase:
         """Initialize the vector database factory."""
         pass
 
-    def create(self, index_type: str = "hnsw", **kwargs) -> Any:
+    def create(self, index_type: str = "hnsw", quantization_config: Optional[Dict[str, Any]] = None, **kwargs) -> Any:
         """
-        Create a vector index of the specified type.
+        Create a vector index of the specified type with optional quantization.
 
         Args:
             index_type: The type of index to create (case-insensitive: "hnsw", "ivf", etc.)
+            quantization_config: Optional quantization configuration dictionary
             **kwargs: Parameters specific to the chosen index type (validated by Rust backend)
 
             For "hnsw", supported parameters are:
@@ -41,22 +50,55 @@ class VectorDatabase:
                 - ef_construction (int): Construction candidate list size (default: 200)
                 - expected_size (int): Expected number of vectors (default: 10000)
 
+            Quantization config format:
+                {
+                    'type': 'pq',              # Currently only 'pq' (Product Quantization) supported
+                    'subvectors': 8,           # Number of subvectors (must divide dim evenly, default: 8)
+                    'bits': 8,                 # Bits per subvector (1-8, controls centroids, default: 8)
+                    'training_size': None,     # Auto-calculated based on subvectors & bits (or specify manually)
+                    'max_training_vectors': None  # Optional limit on training vectors used
+                }
+
+            Note: Quantization reduces memory usage (typically 4-32x compression) but may 
+            slightly degrade recall accuracy. Training triggers automatically on the first 
+            .add() call that reaches the training_size threshold.
+
         Returns:
             An instance of the created vector index.
 
         Examples:
-            # HNSW index with defaults
+            # HNSW index with defaults (no quantization)
             vdb = VectorDatabase()
             index = vdb.create("hnsw", dim=1536)
             
-            # HNSW index with custom parameters
-            index = vdb.create("hnsw", dim=768, m=16, ef_construction=200, space="cosine", expected_size=10000)
+            # HNSW index with Product Quantization (auto-calculated training size)
+            quantization_config = {
+                'type': 'pq',
+                'subvectors': 8,
+                'bits': 8
+            }
+            index = vdb.create(
+                index_type="hnsw", 
+                dim=1536, 
+                quantization_config=quantization_config
+            )
             
-            # Future IVF index
-            # index = vdb.create("ivf", dim=1536, nlist=100, nprobe=10)
+            # Memory-optimized configuration with manual training size
+            memory_optimized_config = {
+                'type': 'pq',
+                'subvectors': 16,         # More subvectors = better compression
+                'bits': 6,                # Fewer bits = less memory per centroid
+                'training_size': 75000    # Override auto-calculation
+            }
+            index = vdb.create(
+                index_type="hnsw",
+                dim=1536,
+                quantization_config=memory_optimized_config,
+                expected_size=1000000     # Large dataset
+            )
 
         Raises:
-            ValueError: If index_type is not supported.
+            ValueError: If index_type is not supported or quantization config is invalid.
             RuntimeError: If index creation fails due to backend validation.
         """
         index_type = (index_type or "").strip().lower()
@@ -65,9 +107,16 @@ class VectorDatabase:
             available = ', '.join(sorted(self._index_constructors.keys()))
             raise ValueError(f"Unknown index type '{index_type}'. Available: {available}")
         
+        # Centralize dim early to ensure consistency
+        dim = kwargs.get('dim', 1536)
+        
+        # Validate and process quantization config
+        if quantization_config is not None:
+            quantization_config = self._validate_quantization_config(quantization_config, dim)
+        
         # Apply index-specific defaults
         if index_type == "hnsw":
-            kwargs.setdefault("dim", 1536)
+            kwargs.setdefault("dim", dim)
             kwargs.setdefault("space", "cosine")
             kwargs.setdefault("m", 16)
             kwargs.setdefault("ef_construction", 200)
@@ -76,11 +125,188 @@ class VectorDatabase:
         constructor = self._index_constructors[index_type]
         
         try:
-            return constructor(**kwargs)
+            # Always pass quantization_config parameter
+            clean_config = None
+            if quantization_config is not None:
+                # Clean quantization_config before passing to Rust (remove internal keys)
+                clean_config = {k: v for k, v in quantization_config.items() if not k.startswith('_')}
+            
+            return constructor(quantization_config=clean_config, **kwargs)
         except Exception as e:
             raise RuntimeError(f"Failed to create {index_type.upper()} index: {e}") from e
+
+
+
+    def _validate_quantization_config(self, config: Dict[str, Any], dim: int) -> Dict[str, Any]:
+        """
+        Validate and normalize quantization configuration.
+        
+        Args:
+            config: Raw quantization configuration
+            dim: Vector dimension for validation
+            
+        Returns:
+            Validated and normalized configuration
+            
+        Raises:
+            ValueError: If configuration is invalid
+        """
+        if not isinstance(config, dict):
+            raise ValueError("quantization_config must be a dictionary")
+        
+        # Create a copy to avoid modifying the original
+        validated_config = config.copy()
+        
+        # Validate quantization type
+        qtype = validated_config.get('type', '').lower()
+        if qtype != 'pq':
+            raise ValueError(f"Unsupported quantization type: '{qtype}'. Currently only 'pq' is supported.")
+        
+        validated_config['type'] = 'pq'
+        
+        # Validate subvectors
+        subvectors = validated_config.get('subvectors', 8)
+        if not isinstance(subvectors, int) or subvectors <= 0:
+            raise ValueError(f"subvectors must be a positive integer, got {subvectors}")
+        
+        if dim % subvectors != 0:
+            raise ValueError(
+                f"subvectors ({subvectors}) must divide dimension ({dim}) evenly. "
+                f"Consider using subvectors: {self._suggest_subvector_divisors(dim)}"
+            )
+        
+        if subvectors > dim:
+            raise ValueError(f"subvectors ({subvectors}) cannot exceed dimension ({dim})")
+        
+        validated_config['subvectors'] = subvectors
+        
+        # Validate bits per subvector
+        bits = validated_config.get('bits', 8)
+        if not isinstance(bits, int) or bits < 1 or bits > 8:
+            raise ValueError(f"bits must be an integer between 1 and 8, got {bits}")
+        
+        validated_config['bits'] = bits
+        
+        # Calculate smart training size if not provided
+        training_size = validated_config.get('training_size')
+        if training_size is None:
+            training_size = self._calculate_smart_training_size(subvectors, bits)
+        else:
+            if not isinstance(training_size, int) or training_size < 1000:
+                raise ValueError(f"training_size must be at least 1000 for stable k-means clustering, got {training_size}")
+        
+        validated_config['training_size'] = training_size
+        
+        # Validate max training vectors if provided
+        max_training_vectors = validated_config.get('max_training_vectors')
+        if max_training_vectors is not None:
+            if not isinstance(max_training_vectors, int) or max_training_vectors < training_size:
+                raise ValueError(
+                    f"max_training_vectors ({max_training_vectors}) must be >= training_size ({training_size})"
+                )
+            validated_config['max_training_vectors'] = max_training_vectors
+        
+        # Calculate and warn about memory usage
+        self._check_memory_usage(validated_config, dim)
+        
+        return validated_config
+
+    def _calculate_smart_training_size(self, subvectors: int, bits: int) -> int:
+        """
+        Calculate optimal training size based on quantization parameters.
+        
+        Args:
+            subvectors: Number of subvectors
+            bits: Bits per subvector
             
+        Returns:
+            Recommended training size for stable k-means clustering
+        """
+        # Statistical requirement: need enough samples per centroid for stable clustering
+        # Training is done per subvector, so we need (2^bits * min_samples) total
+        centroids_per_subvector = 2 ** bits
+        min_samples_per_centroid = 20  # Statistical guideline for k-means stability
+        
+        # Calculate minimum samples needed for stable clustering across all subvectors
+        statistical_minimum = centroids_per_subvector * min_samples_per_centroid
+        
+        # Practical bounds
+        reasonable_minimum = 10000    # Always need at least this for diversity
+        reasonable_maximum = 200000   # Diminishing returns beyond this point
+        
+        return min(max(statistical_minimum, reasonable_minimum), reasonable_maximum)
+
+    def _suggest_subvector_divisors(self, dim: int) -> str:
+        """Suggest valid subvector counts that divide the dimension evenly."""
+        divisors = []
+        for i in range(1, min(33, dim + 1)):  # Common subvector counts up to 32
+            if dim % i == 0:
+                divisors.append(str(i))
+        return ', '.join(divisors[:8])  # Show first 8 suggestions
+
+    def _check_memory_usage(self, config: Dict[str, Any], dim: int) -> None:
+        """
+        Calculate and warn about memory usage for the quantization configuration.
+        
+        Args:
+            config: Validated quantization configuration
+            dim: Vector dimension
+        """
+        subvectors = config['subvectors']
+        bits = config['bits']
+        sub_dim = dim // subvectors
+        
+        # Calculate centroid storage requirements
+        num_centroids_per_subvector = 2 ** bits
+        total_centroids = subvectors * num_centroids_per_subvector
+        centroid_memory_mb = (total_centroids * sub_dim * 4) / (1024 * 1024)  # 4 bytes per float32
+        
+        # Calculate compression ratio
+        original_bytes_per_vector = dim * 4  # float32
+        compressed_bytes_per_vector = subvectors  # 1 byte per subvector code
+        compression_ratio = original_bytes_per_vector / compressed_bytes_per_vector
+        
+        # Add memory info to config for user reference (internal)
+        memory_info: MemoryInfo = {
+            'centroid_storage_mb': round(centroid_memory_mb, 2),
+            'compression_ratio': round(compression_ratio, 1),
+            'centroids_per_subvector': num_centroids_per_subvector,
+            'total_centroids': total_centroids,
+            'calculated_training_size': config['training_size']
+        }
+        config['__memory_info__'] = memory_info        
+        # Warn about large memory usage
+        if centroid_memory_mb > 100:
+            import warnings
+            warnings.warn(
+                f"Large centroid storage required: {centroid_memory_mb:.1f}MB. "
+                f"Consider reducing bits ({bits}) or subvectors ({subvectors}) for memory efficiency.",
+                UserWarning,
+                stacklevel=2
+            )
+        
+        # Warn about low compression
+        if compression_ratio < 4:
+            import warnings
+            warnings.warn(
+                f"Low compression ratio: {compression_ratio:.1f}x. "
+                f"Consider increasing subvectors ({subvectors}) or reducing bits ({bits}) for better compression.",
+                UserWarning,
+                stacklevel=2
+            )
+        
+        # Warn about extremely high compression
+        if compression_ratio > 50:
+            import warnings
+            warnings.warn(
+                f"Very high compression ratio: {compression_ratio:.1f}x may significantly impact recall quality. "
+                f"Consider reducing subvectors ({subvectors}) or increasing bits ({bits}) for better accuracy.",
+                UserWarning,
+                stacklevel=2
+            )
+
     @classmethod
     def available_index_types(cls) -> list[str]:
         """Return list of all supported index types."""
         return sorted(cls._index_constructors.keys())
+    

{zeusdb_vector_database-0.1.2.dist-info → zeusdb_vector_database-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zeusdb-vector-database
-Version: 0.1.2
+Version: 0.2.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Dist: numpy>=2.2.6,<3.0.0
@@ -11,7 +11,7 @@ License-File: LICENSE
 License-File: NOTICE
 Summary: Blazing-fast vector DB with real-time similarity search and metadata filtering.
 Author-email: ZeusDB <contact@zeusdb.com>
-License: Apache-2.0
+License-Expression: Apache-2.0
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 Project-URL: Repository, https://github.com/zeusdb/zeusdb-vector-database
@@ -56,22 +56,30 @@ ZeusDB leverages the HNSW (Hierarchical Navigable Small World) algorithm for spe
 
 ## ⭐ Features
 
-🔍 Approximate Nearest Neighbor (ANN) search with HNSW
+🐍 User-friendly Python API for adding vectors and running similarity searches
 
-📋 Supports multiple distance metrics: `cosine`, `L1`, `L2` 
+🔥 High-performance Rust backend optimized for speed and concurrency
 
-🔥 High-performance Rust backend 
+🔍 Approximate Nearest Neighbor (ANN) search using HNSW for fast, accurate results
+
+📦 Product Quantization (PQ) for compact storage, faster distance computations, and scalability for Big Data
+
+📥 Flexible input formats, including native Python types and zero-copy NumPy arrays
+
+🗂️ Metadata-aware filtering for precise and contextual querying
 
-📥 Supports multiple input formats using a single, easy-to-use Python method
 
-🗂️ Metadata-aware filtering at query time
 
-🐍 Simple and intuitive Python API
+
+<!-- 
+📋 Supports multiple distance metrics: `cosine`, `L1`, `L2` 
+
+📥 Supports multiple input formats using a single, easy-to-use Python method
 
 ⚡ Smart multi-threaded inserts that automatically speed up large batch uploads
 
 🚀 Fast, concurrent searches so you can run multiple queries at the same time
-
+-->
 
 <br/>
 
@@ -215,10 +223,11 @@ index = vdb.create(
 |------------------|--------|-----------|-----------------------------------------------------------------------------|
 | `index_type`     | `str`  | `"hnsw"`  | The type of vector index to create. Currently supports `"hnsw"`. Future options include `"ivf"`, `"flat"`, etc. Case-insensitive. |
 | `dim`            | `int`  | `1536`    | Dimensionality of the vectors to be indexed. Each vector must have this length. The default dim=1536 is chosen to match the output dimensionality of OpenAI’s text-embedding-ada-002 model. |
-| `space`          | `str`  | `"cosine"`| Distance metric used for similarity search. Options include `"cosine"`. Additional metrics such as `"l2"`, and `"dot"` will be added in future versions. |
+| `space`          | `str`  | `"cosine"`| Distance metric used for similarity search. Options include `"cosine"`, `"L1"` and `"L2"`.|
 | `m`              | `int`  | `16`      | Number of bi-directional connections created for each new node. Higher `m` improves recall but increases index size and build time. |
 | `ef_construction`| `int`  | `200`     | Size of the dynamic list used during index construction. Larger values increase indexing time and memory, but improve quality. |
 | `expected_size`  | `int`  | `10000`   | Estimated number of elements to be inserted. Used for preallocating internal data structures. Not a hard limit. |
+| `quantization_config` | `dict` | `None` | Product Quantization configuration for memory-efficient vector compression. |
 
 <br/>
 
@@ -411,7 +420,7 @@ results = index.search(vector=query_vector, top_k=3)
 print(results)
 ```
 
-#### 🔍 Search Example 6 - Batch Search with with metadata filter
+#### 🔍 Search Example 6 - Batch Search with metadata filter
 
 Performs similarity search on multiple query vectors with metadata filtering, returning filtered results for each query.
 
@@ -555,6 +564,156 @@ print(partial)
 
 ⚠️ `get_records()` only returns results for IDs that exist in the index. Missing IDs are silently skipped.
 
+<br />
+
+
+## 🗜️ Product Quantization
+
+Product Quantization (PQ) is a vector compression technique that significantly reduces memory usage while preserving high search accuracy. Commonly used in HNSW-based vector databases, PQ works by dividing each vector into subvectors and quantizing them independently. This enables compression ratios of 4× to 256×, making it ideal for large-scale, high-dimensional datasets.
+
+ZeusDB Vector Database’s PQ implementation features:
+
+✅ Intelligent Training – PQ model trains automatically at defined thresholds
+
+✅ Efficient Memory Use – Store 4× to 256× more vectors in the same RAM footprint
+
+✅ Fast Approximate Search – Uses Asymmetric Distance Computation (ADC) for high-speed search computation
+
+✅ Seamless Operation – Index automatically switches from raw to quantized storage modes
+
+<br />
+
+### 📘 Quantization Configuration Parameters
+
+To enable PQ, pass a `quantization_config` dictionary to the `.create()` index method:
+
+| Parameter | Type | Description | Valid Range | Default |
+|-----------|------|-------------|-------------|---------|
+| `type` | `str` | Quantization algorithm type | `"pq"` | *required* |
+| `subvectors` | `int` | Number of vector subspaces (must divide dimension evenly) | 1 to dimension | `8` |
+| `bits` | `int` | Bits per quantized code (controls centroids per subvector) | 1-8 | `8` |
+| `training_size` | `int` | Minimum vectors needed for stable k-means clustering | ≥ 1000 | 1000 |
+| `max_training_vectors` | `int` | Maximum vectors used during training (optional limit) | ≥ training_size | `None` |
+
+
+<br/>
+
+
+### 🔧 Usage Example
+
+```python
+from zeusdb_vector_database import VectorDatabase
+import numpy as np
+
+# Create index with product quantization
+vdb = VectorDatabase()
+
+# Configure quantization for memory efficiency
+quantization_config = {
+    'type': 'pq',                  # `pq` for Product Quantization
+    'subvectors': 8,               # Divide 1536-dim vectors into 8 subvectors of 192 dims each
+    'bits': 8,                     # 256 centroids per subvector (2^8)
+    'training_size': 10000,        # Train when 10k vectors are collected
+    'max_training_vectors': 50000  # Use max 50k vectors for training
+}
+
+# Create index with quantization
+# This will automatically handle training when enough vectors are added
+index = vdb.create(
+    index_type="hnsw",
+    dim=1536,                                  # OpenAI `text-embedding-3-small` dimension
+    quantization_config=quantization_config    # Add the compression configuration
+)
+
+# Add vectors - training triggers automatically at threshold
+documents = [
+    {
+        "id": f"doc_{i}", 
+        "values": np.random.rand(1536).astype(float).tolist(),
+        "metadata": {"category": "tech", "year": 2026}
+    }
+    for i in range(15000) 
+]
+
+# Training will trigger automatically when 10k vectors are added
+result = index.add(documents)
+print(f"Added {result.total_inserted} vectors")
+
+# Check quantization status
+print(f"Training progress: {index.get_training_progress():.1f}%")
+print(f"Storage mode: {index.get_storage_mode()}")
+print(f"Is quantized: {index.is_quantized()}")
+
+# Get compression statistics
+quant_info = index.get_quantization_info()
+if quant_info:
+    print(f"Compression ratio: {quant_info['compression_ratio']:.1f}x")
+    print(f"Memory usage: {quant_info['memory_mb']:.1f} MB")
+
+# Search works seamlessly with quantized storage
+query_vector = np.random.rand(1536).astype(float).tolist()
+results = index.search(vector=query_vector, top_k=3)
+
+# Simply print raw results
+print(results)
+```
+
+Results
+```python
+[
+{'id': 'doc_9719', 'score': 0.5133496522903442, 'metadata': {'category': 'tech', 'year': 2026}},
+{'id': 'doc_8148', 'score': 0.5139288306236267, 'metadata': {'category': 'tech', 'year': 2026}}, 
+{'id': 'doc_7822', 'score': 0.5151920914649963, 'metadata': {'category': 'tech', 'year': 2026}}, 
+]
+```
+
+<br />
+
+### ⚙️ Configuration Guidelines
+
+For Balanced Memory & Accuracy (Recommended to start with)
+```python
+quantization_config = {
+    'type': 'pq',
+    'subvectors': 8,      # Balanced: moderate compression, good accuracy
+    'bits': 8,            # 256 centroids per subvector (high precision)
+    'training_size': 10000  # Or higher for large datasets
+}
+# Achieves ~16x–32x compression with strong recall for most applications
+```
+
+
+For Memory Optimization:
+```python
+quantization_config = {
+    'type': 'pq',
+    'subvectors': 16,      # More subvectors = better compression
+    'bits': 6,             # Fewer bits = less memory per centroid
+    'training_size': 20000
+}
+# Achieves ~32x compression ratio
+```
+
+For Accuracy Optimization:
+```python
+quantization_config = {
+    'type': 'pq',
+    'subvectors': 4,       # Fewer subvectors = better accuracy
+    'bits': 8,             # More bits = more precise quantization
+    'training_size': 50000 # More training data = better centroids
+}
+# Achieves ~4x compression ratio with minimal accuracy loss
+```
+
+### 📊 Performance Characteristics
+
+- Training: Occurs once when threshold is reached (typically 1-5 minutes for 50k vectors)
+- Memory Reduction: 4x-256x depending on configuration
+- Search Speed: Comparable or faster than raw vectors due to ADC optimization
+- Accuracy Impact: Typically 1-5% recall reduction with proper tuning
+
+Quantization is ideal for production deployments with large vector datasets (100k+ vectors) where memory efficiency is critical.
+
 
 <br/>
 

zeusdb_vector_database-0.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+zeusdb_vector_database-0.2.0.dist-info/METADATA,sha256=lWikG9QZDEEMRYY1zh45XBiTL7A8Mh4FTJ_cVN7TNfE,29736
+zeusdb_vector_database-0.2.0.dist-info/WHEEL,sha256=ZfdBJytWHFi2WZ1f_KKHwROhhQEId-N1oZJ4ZBt_MTs,104
+zeusdb_vector_database-0.2.0.dist-info/licenses/LICENSE,sha256=82Hi3E_KqpDOBk00HrY6fGiErqL3QJquGQ6dUu9wJzE,11336
+zeusdb_vector_database-0.2.0.dist-info/licenses/NOTICE,sha256=GDGZ9V3p4Uvaj-1RT9Pbeczps-rSeZz8q8wSxb_Q13o,971
+zeusdb_vector_database/__init__.py,sha256=w2XfHqGQVShv1zDZfvLY-sSw4zzV1kdAFLjSCdGWlkU,202
+zeusdb_vector_database/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+zeusdb_vector_database/vector_database.py,sha256=n1fiDvzpyyvLhOOaLfQSge9p4uhm8YWjX6i8m-rYoRI,13581
+zeusdb_vector_database/zeusdb_vector_database.cpython-311-darwin.so,sha256=qpthvkSYoXklnMg6VnYFNtX8cb-gCxxb7n09WhH9jjM,4116096
+zeusdb_vector_database-0.2.0.dist-info/RECORD,,

{zeusdb_vector_database-0.1.2.dist-info → zeusdb_vector_database-0.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.9.1)
+Generator: maturin (1.9.2)
 Root-Is-Purelib: false
 Tag: cp311-cp311-macosx_11_0_arm64

zeusdb_vector_database-0.1.2.dist-info/RECORD

@@ -1,9 +0,0 @@
-zeusdb_vector_database-0.1.2.dist-info/METADATA,sha256=0bduX_0CGyHp8S6Yl0k1Cd6ELU9XlnoZR6zg-OKTMq4,23893
-zeusdb_vector_database-0.1.2.dist-info/WHEEL,sha256=4POUqOUvk-fNEqEa1NBlmMsgWQGl6FnEg9vsbsvEmNM,104
-zeusdb_vector_database-0.1.2.dist-info/licenses/LICENSE,sha256=82Hi3E_KqpDOBk00HrY6fGiErqL3QJquGQ6dUu9wJzE,11336
-zeusdb_vector_database-0.1.2.dist-info/licenses/NOTICE,sha256=GDGZ9V3p4Uvaj-1RT9Pbeczps-rSeZz8q8wSxb_Q13o,971
-zeusdb_vector_database/__init__.py,sha256=k6Jt99gmCjTCce4CfzFmZcFt1JbICHK4ya5KDJwN3js,202
-zeusdb_vector_database/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zeusdb_vector_database/vector_database.py,sha256=7Gs9FiasO5suqc3E8mxxtW1ORIXBh-8AXvp0pQo1VYc,3463
-zeusdb_vector_database/zeusdb_vector_database.cpython-311-darwin.so,sha256=WxjyirwYhfOWZnt6WySKvkkYUjgnv2UGpUZyvlT-17I,3985776
-zeusdb_vector_database-0.1.2.dist-info/RECORD,,