cocoindex 0.2.23__cp311-abi3-win_amd64.whl → 0.3.1__cp311-abi3-win_amd64.whl

cocoindex/functions/colpali.py

@@ -2,7 +2,7 @@
 
 import functools
 from dataclasses import dataclass
-from typing import Any, Optional, TYPE_CHECKING, Literal
+from typing import Any, TYPE_CHECKING, Literal
 import numpy as np
 
 from .. import op
@@ -22,18 +22,11 @@ class ColPaliModelInfo:
     dimension: int
 
 
-@functools.lru_cache(maxsize=None)
+@functools.cache
 def _get_colpali_model_and_processor(model_name: str) -> ColPaliModelInfo:
     """Load and cache ColPali model and processor with shared device setup."""
     try:
-        from colpali_engine import (  # type: ignore[import-untyped]
-            ColPali,
-            ColPaliProcessor,
-            ColQwen2,
-            ColQwen2Processor,
-            ColSmol,
-            ColSmolProcessor,
-        )
+        import colpali_engine as ce  # type: ignore[import-untyped]
         import torch
     except ImportError as e:
         raise ImportError(
@@ -42,29 +35,30 @@ def _get_colpali_model_and_processor(model_name: str) -> ColPaliModelInfo:
         ) from e
 
     device = "cuda" if torch.cuda.is_available() else "cpu"
+    lower_model_name = model_name.lower()
 
     # Determine model type from name
-    if "colpali" in model_name.lower():
-        model = ColPali.from_pretrained(
+    if lower_model_name.startswith("colpali"):
+        model = ce.ColPali.from_pretrained(
             model_name, torch_dtype=torch.bfloat16, device_map=device
         )
-        processor = ColPaliProcessor.from_pretrained(model_name)
-    elif "colqwen" in model_name.lower():
-        model = ColQwen2.from_pretrained(
+        processor = ce.ColPaliProcessor.from_pretrained(model_name)
+    elif lower_model_name.startswith("colqwen2.5"):
+        model = ce.ColQwen2_5.from_pretrained(
             model_name, torch_dtype=torch.bfloat16, device_map=device
         )
-        processor = ColQwen2Processor.from_pretrained(model_name)
-    elif "colsmol" in model_name.lower():
-        model = ColSmol.from_pretrained(
+        processor = ce.ColQwen2_5_Processor.from_pretrained(model_name)
+    elif lower_model_name.startswith("colqwen"):
+        model = ce.ColQwen2.from_pretrained(
             model_name, torch_dtype=torch.bfloat16, device_map=device
         )
-        processor = ColSmolProcessor.from_pretrained(model_name)
+        processor = ce.ColQwen2Processor.from_pretrained(model_name)
     else:
         # Fallback to ColPali for backwards compatibility
-        model = ColPali.from_pretrained(
+        model = ce.ColPali.from_pretrained(
             model_name, torch_dtype=torch.bfloat16, device_map=device
         )
-        processor = ColPaliProcessor.from_pretrained(model_name)
+        processor = ce.ColPaliProcessor.from_pretrained(model_name)
 
     # Detect dimension
     dimension = _detect_colpali_dimension(model, processor, device)
@@ -130,6 +124,7 @@ class ColPaliEmbedImage(op.FunctionSpec):
 @op.executor_class(
     gpu=True,
     cache=True,
+    batching=True,
     behavior_version=1,
 )
 class ColPaliEmbedImageExecutor:
@@ -146,7 +141,7 @@ class ColPaliEmbedImageExecutor:
         dimension = self._model_info.dimension
         return Vector[Vector[np.float32, Literal[dimension]]]  # type: ignore
 
-    def __call__(self, img_bytes: bytes) -> Any:
+    def __call__(self, img_bytes_list: list[bytes]) -> Any:
         try:
             from PIL import Image
             import torch
@@ -160,8 +155,11 @@ class ColPaliEmbedImageExecutor:
         processor = self._model_info.processor
         device = self._model_info.device
 
-        pil_image = Image.open(io.BytesIO(img_bytes)).convert("RGB")
-        inputs = processor.process_images([pil_image]).to(device)
+        pil_images = [
+            Image.open(io.BytesIO(img_bytes)).convert("RGB")
+            for img_bytes in img_bytes_list
+        ]
+        inputs = processor.process_images(pil_images).to(device)
         with torch.no_grad():
             embeddings = model(**inputs)
 
@@ -171,10 +169,8 @@ class ColPaliEmbedImageExecutor:
                 f"Expected 3D tensor [batch, patches, hidden_dim], got shape {embeddings.shape}"
             )
 
-        # Keep patch-level embeddings: [batch, patches, hidden_dim] -> [patches, hidden_dim]
-        patch_embeddings = embeddings[0]  # Remove batch dimension
-
-        return patch_embeddings.cpu().to(torch.float32).numpy()
+        # [patches, hidden_dim]
+        return embeddings.cpu().to(torch.float32).numpy()
 
 
 class ColPaliEmbedQuery(op.FunctionSpec):
@@ -207,6 +203,7 @@ class ColPaliEmbedQuery(op.FunctionSpec):
     gpu=True,
     cache=True,
     behavior_version=1,
+    batching=True,
 )
 class ColPaliEmbedQueryExecutor:
     """Executor for ColVision query embedding (ColPali, ColQwen2, ColSmol, etc.)."""
@@ -222,7 +219,7 @@ class ColPaliEmbedQueryExecutor:
         dimension = self._model_info.dimension
         return Vector[Vector[np.float32, Literal[dimension]]]  # type: ignore
 
-    def __call__(self, query: str) -> Any:
+    def __call__(self, queries: list[str]) -> Any:
         try:
             import torch
         except ImportError as e:
@@ -234,7 +231,7 @@ class ColPaliEmbedQueryExecutor:
         processor = self._model_info.processor
         device = self._model_info.device
 
-        inputs = processor.process_queries([query]).to(device)
+        inputs = processor.process_queries(queries).to(device)
         with torch.no_grad():
             embeddings = model(**inputs)
 
@@ -244,7 +241,5 @@ class ColPaliEmbedQueryExecutor:
                 f"Expected 3D tensor [batch, tokens, hidden_dim], got shape {embeddings.shape}"
             )
 
-        # Keep token-level embeddings: [batch, tokens, hidden_dim] -> [tokens, hidden_dim]
-        token_embeddings = embeddings[0]  # Remove batch dimension
-
-        return token_embeddings.cpu().to(torch.float32).numpy()
+        # [tokens, hidden_dim]
+        return embeddings.cpu().to(torch.float32).numpy()

cocoindex/functions/sbert.py

@@ -31,6 +31,7 @@ class SentenceTransformerEmbed(op.FunctionSpec):
 @op.executor_class(
     gpu=True,
     cache=True,
+    batching=True,
     behavior_version=1,
     arg_relationship=(op.ArgRelationship.EMBEDDING_ORIGIN_TEXT, "text"),
 )
@@ -57,7 +58,9 @@ class SentenceTransformerEmbedExecutor:
         dim = self._model.get_sentence_embedding_dimension()
         return Vector[np.float32, Literal[dim]]  # type: ignore
 
-    def __call__(self, text: str) -> NDArray[np.float32]:
+    def __call__(self, text: list[str]) -> list[NDArray[np.float32]]:
         assert self._model is not None
-        result: NDArray[np.float32] = self._model.encode(text, convert_to_numpy=True)
-        return result
+        results: list[NDArray[np.float32]] = self._model.encode(
+            text, convert_to_numpy=True
+        )
+        return results

cocoindex/op.py

@@ -32,6 +32,7 @@ from .engine_value import (
 )
 from .typing import (
     KEY_FIELD_NAME,
+    AnalyzedListType,
     AnalyzedTypeInfo,
     StructSchema,
     StructType,
@@ -45,6 +46,7 @@ from .typing import (
     EnrichedValueType,
     decode_engine_field_schemas,
     FieldSchema,
+    ValueType,
 )
 from .runtime import to_async_call
 from .index import IndexOptions
@@ -149,6 +151,7 @@ class OpArgs:
     """
     - gpu: Whether the executor will be executed on GPU.
     - cache: Whether the executor will be cached.
+    - batching: Whether the executor will be batched.
     - behavior_version: The behavior version of the executor. Cache will be invalidated if it
       changes. Must be provided if `cache` is True.
     - arg_relationship: It specifies the relationship between an input argument and the output,
@@ -158,6 +161,7 @@ class OpArgs:
 
     gpu: bool = False
     cache: bool = False
+    batching: bool = False
     behavior_version: int | None = None
     arg_relationship: tuple[ArgRelationship, str] | None = None
 
@@ -168,6 +172,16 @@ class _ArgInfo:
     is_required: bool
 
 
+def _make_batched_engine_value_decoder(
+    field_path: list[str], src_type: ValueType, dst_type_info: AnalyzedTypeInfo
+) -> Callable[[Any], Any]:
+    if not isinstance(dst_type_info.variant, AnalyzedListType):
+        raise ValueError("Expected arguments for batching function to be a list type")
+    elem_type_info = analyze_type_info(dst_type_info.variant.elem_type)
+    base_decoder = make_engine_value_decoder(field_path, src_type, elem_type_info)
+    return lambda value: [base_decoder(v) for v in value]
+
+
 def _register_op_factory(
     category: OpCategory,
     expected_args: list[tuple[str, inspect.Parameter]],
@@ -181,6 +195,10 @@ def _register_op_factory(
     Register an op factory.
     """
 
+    if op_args.batching:
+        if len(expected_args) != 1:
+            raise ValueError("Batching is only supported for single argument functions")
+
     class _WrappedExecutor:
         _executor: Any
         _args_info: list[_ArgInfo]
@@ -208,7 +226,7 @@ def _register_op_factory(
             """
             self._args_info = []
             self._kwargs_info = {}
-            attributes = []
+            attributes = {}
             potentially_missing_required_arg = False
 
             def process_arg(
@@ -220,14 +238,17 @@ def _register_op_factory(
                 if op_args.arg_relationship is not None:
                     related_attr, related_arg_name = op_args.arg_relationship
                     if related_arg_name == arg_name:
-                        attributes.append(
-                            TypeAttr(related_attr.value, actual_arg.analyzed_value)
-                        )
+                        attributes[related_attr.value] = actual_arg.analyzed_value
                 type_info = analyze_type_info(arg_param.annotation)
                 enriched = EnrichedValueType.decode(actual_arg.value_type)
-                decoder = make_engine_value_decoder(
-                    [arg_name], enriched.type, type_info
-                )
+                if op_args.batching:
+                    decoder = _make_batched_engine_value_decoder(
+                        [arg_name], enriched.type, type_info
+                    )
+                else:
+                    decoder = make_engine_value_decoder(
+                        [arg_name], enriched.type, type_info
+                    )
                 is_required = not type_info.nullable
                 if is_required and actual_arg.value_type.get("nullable", False):
                     potentially_missing_required_arg = True
@@ -302,20 +323,32 @@ def _register_op_factory(
             if len(missing_args) > 0:
                 raise ValueError(f"Missing arguments: {', '.join(missing_args)}")
 
+            analyzed_expected_return_type = analyze_type_info(expected_return)
+            self._result_encoder = make_engine_value_encoder(
+                analyzed_expected_return_type
+            )
+
             base_analyze_method = getattr(self._executor, "analyze", None)
             if base_analyze_method is not None:
-                result_type = base_analyze_method()
+                analyzed_result_type = analyze_type_info(base_analyze_method())
             else:
-                result_type = expected_return
+                if op_args.batching:
+                    if not isinstance(
+                        analyzed_expected_return_type.variant, AnalyzedListType
+                    ):
+                        raise ValueError(
+                            "Expected return type for batching function to be a list type"
+                        )
+                    analyzed_result_type = analyze_type_info(
+                        analyzed_expected_return_type.variant.elem_type
+                    )
+                else:
+                    analyzed_result_type = analyzed_expected_return_type
             if len(attributes) > 0:
-                result_type = Annotated[result_type, *attributes]
-
-            analyzed_result_type_info = analyze_type_info(result_type)
-            encoded_type = encode_enriched_type_info(analyzed_result_type_info)
+                analyzed_result_type.attrs = attributes
             if potentially_missing_required_arg:
-                encoded_type["nullable"] = True
-
-            self._result_encoder = make_engine_value_encoder(analyzed_result_type_info)
+                analyzed_result_type.nullable = True
+            encoded_type = encode_enriched_type_info(analyzed_result_type)
 
             return encoded_type
 
@@ -359,7 +392,9 @@ def _register_op_factory(
 
     if category == OpCategory.FUNCTION:
         _engine.register_function_factory(
-            op_kind, _EngineFunctionExecutorFactory(spec_loader, _WrappedExecutor)
+            op_kind,
+            _EngineFunctionExecutorFactory(spec_loader, _WrappedExecutor),
+            op_args.batching,
         )
     else:
         raise ValueError(f"Unsupported executor type {category}")

cocoindex/runtime.py

@@ -6,8 +6,9 @@ manner.
 import threading
 import asyncio
 import inspect
-from typing import Any, Callable, Coroutine, TypeVar, Awaitable
+import warnings
 
+from typing import Any, Callable, Awaitable, TypeVar, Coroutine
 
 T = TypeVar("T")
 
@@ -24,15 +25,44 @@ class _ExecutionContext:
         """Get the event loop for the cocoindex library."""
         with self._lock:
             if self._event_loop is None:
-                self._event_loop = asyncio.new_event_loop()
-                threading.Thread(
-                    target=self._event_loop.run_forever, daemon=True
-                ).start()
+                loop = asyncio.new_event_loop()
+                self._event_loop = loop
+
+                def _runner(l: asyncio.AbstractEventLoop) -> None:
+                    asyncio.set_event_loop(l)
+                    l.run_forever()
+
+                threading.Thread(target=_runner, args=(loop,), daemon=True).start()
             return self._event_loop
 
     def run(self, coro: Coroutine[Any, Any, T]) -> T:
         """Run a coroutine in the event loop, blocking until it finishes. Return its result."""
-        return asyncio.run_coroutine_threadsafe(coro, self.event_loop).result()
+        try:
+            running_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            running_loop = None
+
+        loop = self.event_loop
+
+        if running_loop is not None:
+            if running_loop is loop:
+                raise RuntimeError(
+                    "CocoIndex sync API was called from inside CocoIndex's async context. "
+                    "Use the async variant of this method instead."
+                )
+            warnings.warn(
+                "CocoIndex sync API was called inside an existing event loop. "
+                "This may block other tasks. Prefer the async method.",
+                RuntimeWarning,
+                stacklevel=2,
+            )
+
+        fut = asyncio.run_coroutine_threadsafe(coro, loop)
+        try:
+            return fut.result()
+        except KeyboardInterrupt:
+            fut.cancel()
+            raise
 
 
 execution_context = _ExecutionContext()

cocoindex/subprocess_exec.py

@@ -19,7 +19,6 @@ import threading
 import asyncio
 import os
 import time
-import atexit
 from .user_app_loader import load_user_app
 from .runtime import execution_context
 import logging
@@ -32,39 +31,14 @@ WATCHDOG_INTERVAL_SECONDS = 10.0
 # ---------------------------------------------
 _pool_lock = threading.Lock()
 _pool: ProcessPoolExecutor | None = None
-_pool_cleanup_registered = False
 _user_apps: list[str] = []
 _logger = logging.getLogger(__name__)
 
 
-def shutdown_pool_at_exit() -> None:
-    """Best-effort shutdown of the global ProcessPoolExecutor on interpreter exit."""
-    global _pool, _pool_cleanup_registered  # pylint: disable=global-statement
-    with _pool_lock:
-        if _pool is not None:
-            try:
-                _pool.shutdown(wait=True, cancel_futures=True)
-            except Exception as e:
-                _logger.error(
-                    "Error during ProcessPoolExecutor shutdown at exit: %s",
-                    e,
-                    exc_info=True,
-                )
-            finally:
-                _pool = None
-                _pool_cleanup_registered = False
-
-
 def _get_pool() -> ProcessPoolExecutor:
-    global _pool, _pool_cleanup_registered  # pylint: disable=global-statement
+    global _pool  # pylint: disable=global-statement
     with _pool_lock:
         if _pool is None:
-            if not _pool_cleanup_registered:
-                # Register the shutdown at exit at creation time (rather than at import time)
-                # to make sure it's executed earlier in the shutdown sequence.
-                atexit.register(shutdown_pool_at_exit)
-                _pool_cleanup_registered = True
-
             # Single worker process as requested
             _pool = ProcessPoolExecutor(
                 max_workers=1,

{cocoindex-0.2.23.dist-info → cocoindex-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cocoindex
-Version: 0.2.23
+Version: 0.3.1
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent

{cocoindex-0.2.23.dist-info → cocoindex-0.3.1.dist-info}/RECORD

@@ -1,9 +1,9 @@
-cocoindex-0.2.23.dist-info/METADATA,sha256=FkEbYJPJxY3eXRX5B68d_a3GGAXMluA33FediNW8bgg,14427
-cocoindex-0.2.23.dist-info/WHEEL,sha256=QC3zdlgimDC1GtRrc0qfjqbzuc7G6nDvPrjaINbNOTw,95
-cocoindex-0.2.23.dist-info/entry_points.txt,sha256=_NretjYVzBdNTn7dK-zgwr7YfG2afz1u1uSE-5bZXF8,46
-cocoindex-0.2.23.dist-info/licenses/THIRD_PARTY_NOTICES.html,sha256=JkjceWLwTbf-svSD5D0wLkWQTF2nCHB_Ev3THD6IWOQ,750832
+cocoindex-0.3.1.dist-info/METADATA,sha256=XVa358pgFtptG2qP5yJTbxgzqFe_1XjVm0_69HXchTg,14426
+cocoindex-0.3.1.dist-info/WHEEL,sha256=QC3zdlgimDC1GtRrc0qfjqbzuc7G6nDvPrjaINbNOTw,95
+cocoindex-0.3.1.dist-info/entry_points.txt,sha256=_NretjYVzBdNTn7dK-zgwr7YfG2afz1u1uSE-5bZXF8,46
+cocoindex-0.3.1.dist-info/licenses/THIRD_PARTY_NOTICES.html,sha256=_9FT9tv3L_NmA0GOtdkqRZGf_4o5A16ui5YvPPi5-WM,750831
 cocoindex/__init__.py,sha256=MsjYflfJHL_sKL4OxcExfRwl57JFKwqvt9AWbiHsZ3Q,2744
-cocoindex/_engine.pyd,sha256=RfVCWs_NOrLRSwgDVkX7iAodLe4heB8W0pmMbXMc9Mk,77532160
+cocoindex/_engine.pyd,sha256=5SgV6FV9mGZGq6hw0cUg5I8f9lf9lWuGxf2CMwGAkq0,77837312
 cocoindex/auth_registry.py,sha256=HK1vfKQh_6z310c8kgFDIQf9RdoiA3vWUwvFYbgybr0,1384
 cocoindex/cli.py,sha256=1Q_c4FzW41FhlCrdJNNkD93Z4zP48hmFzsaU2FJ3wzc,25622
 cocoindex/engine_object.py,sha256=JH27f2MLNUw3HQy6JuCpvRhMxuKZBkxplLIo0m7PU04,10322
@@ -11,20 +11,20 @@ cocoindex/engine_value.py,sha256=CYS_rdJQZoLEcKVcUXupcH0u8k-6ce80Xrzd3rgUBJE,239
 cocoindex/flow.py,sha256=MznA23dsIOlu-1uEBe6XVTfYlDjvH3bvky1BCUEnEng,41357
 cocoindex/functions/__init__.py,sha256=AZ4f7dBVZMkWyR85z9Gy1AgOAB0f1tex62CMP8MDLX4,1061
 cocoindex/functions/_engine_builtin_specs.py,sha256=6ZV91MUosqGSolnKNUjyRHZ_oTOOsQ_jMMEBGZW1EYo,1852
-cocoindex/functions/colpali.py,sha256=kinPow46CSW0PW_-a5PT9JfsCxpvxZG4ZFzQ_OYt9GU,9115
-cocoindex/functions/sbert.py,sha256=5X381jQFqnmomj_943Xrhcs1sWecA1sWZfb4On8mONg,2225
+cocoindex/functions/colpali.py,sha256=Got7es-Em9KwWGwJAAXMJNFp1wFcbtEOj6vkV0cqSAA,8869
+cocoindex/functions/sbert.py,sha256=HPieCBNuKRaWRIBIH8hW4ACFtGN2rHpg6N7mfURpUcQ,2289
 cocoindex/index.py,sha256=C__LzwIC918VIDGsBsyLwvNBO-4BiC5Coq01Fp1zXkI,1032
 cocoindex/lib.py,sha256=cyKGdn8cfH9bkYfrnJ7dlUBO8OVZkKyrkYhWHsMFW_g,2365
 cocoindex/llm.py,sha256=zvdvdFPsLdkVVRdNawOubkEtvdKXI_BlfJIFcDu0S6o,922
-cocoindex/op.py,sha256=pMMgPJ7KVuU1ptTIDJB9yVEntaeOrZ4in16H0Zqa1JE,37100
+cocoindex/op.py,sha256=57OypW_F2j22xBM8W1iNVAX9iTQ4qs3cm-HqYoJ4lz0,38712
 cocoindex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cocoindex/query_handler.py,sha256=vsw-VQ-Fh0ekr4boKchI0wpKHqaiBoeNStClrW4Zwog,1401
-cocoindex/runtime.py,sha256=ZjyPmohIWGFDRaOdS0MgeVuf4Ra2Ggbp6xraxwvHFBo,1386
+cocoindex/runtime.py,sha256=h52Pj6kgHK6_87Rmm3D0HDvDQePPHCoktOk5az553KM,2372
 cocoindex/setting.py,sha256=oohs7H52_h1AulDcp96cS9SVAAm_uFaQyJYog9EvCj0,5131
 cocoindex/setup.py,sha256=KbJvmeFu0NbeoH-5iDmHZP86f26HIId8kHmGUNZAePI,3160
 cocoindex/sources/__init__.py,sha256=urtXAOyZFShYYZKpp2pISzoT4sHKFoX3_nYII3pAsHA,83
 cocoindex/sources/_engine_builtin_specs.py,sha256=J8RBT6b2WEL-varvTA-ti1aYcFfJ4WQ76JZdY7y4fYs,3714
-cocoindex/subprocess_exec.py,sha256=u_kF4C8dToPg-9a7NeFroR8pJCOFag_NT0icLe184QQ,10391
+cocoindex/subprocess_exec.py,sha256=HHYclyNvaG0IO2GpA3qGcbd874lYDX6EQn-AdmJ3Qqw,9317
 cocoindex/targets/__init__.py,sha256=6cO57jLhBloC1o-sBHG6OXfIgBdRQtz5RDi6FLqlQhU,83
 cocoindex/targets/_engine_builtin_specs.py,sha256=iDVooiyLlr9DFuUCDwYyjeaVOELgzay5U3ME8VdDHo8,3528
 cocoindex/targets/lancedb.py,sha256=RQZREffJMsO75W6SuvNnFBufMGEaJatHQa-f70dIUGc,16215
@@ -39,4 +39,4 @@ cocoindex/typing.py,sha256=dC8CmltIbT85TAgiFXwmHT_lePdiHRQLrURjgZWF6oo,24716
 cocoindex/user_app_loader.py,sha256=ZkvUG9aJNNECAjwTY0ZYtNpFd9dNBPVoPKGTtB7dSZg,1926
 cocoindex/utils.py,sha256=U3W39zD2uZpXX8v84tJD7sRmbC5ar3z_ljAP1cJrYXI,618
 cocoindex/validation.py,sha256=4ZjsW-SZT8X_TEEhEE6QG6D-8Oq_TkPAhTqP0mdFYSE,3194
-cocoindex-0.2.23.dist-info/RECORD,,
+cocoindex-0.3.1.dist-info/RECORD,,

{cocoindex-0.2.23.dist-info → cocoindex-0.3.1.dist-info}/licenses/THIRD_PARTY_NOTICES.html

@@ -2846,7 +2846,7 @@ Software.
                 <h3 id="Apache-2.0">Apache License 2.0</h3>
                 <h4>Used by:</h4>
                 <ul class="license-used-by">
-                    <li><a href=" https://crates.io/crates/cocoindex ">cocoindex 0.2.23</a></li>
+                    <li><a href=" https://crates.io/crates/cocoindex ">cocoindex 0.3.1</a></li>
                     <li><a href=" https://github.com/awesomized/crc-fast-rust ">crc-fast 1.3.0</a></li>
                     <li><a href=" https://github.com/qdrant/rust-client ">qdrant-client 1.15.0</a></li>
                 </ul>