Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.cyborg.co/llms.txt

Use this file to discover all available pages before exploring further.

The Client class provides an interface to initialize, create, load and list Encrypted Indexes. Encrypted Indexes, in turn, expose data-related functionality such as upserting, querying, and deleting.

​
Creating the Client

To create the client, you must define the backing store locations which it will use. At minimum, you must set an index_location (where the index will reside) and a config_location (where the index metadata will reside). For example: 
import cyborg_vector_search_py as cvs
import secrets

# Using `memory` storage for this example
# `redis` and `postgres` are also supported

index_location = cvs.DBConfig("memory")  # Where encrypted index is stored (for queries)
config_location = cvs.DBConfig("memory") # Where encrypted index config is stored (for config/loading)

# Create a client
client = cvs.Client(index_location, config_location)
Bear in mind that all contents stored in the backing stores is end-to-end encrypted, meaning that no index contents will be stored in plaintext. For performance reasons, you may wish to use a “fast” backing store option for index_location, such as Redis.

​
Creating the Client with Item Storage

If you wish to store encrypted items in the index, you will also need to set a item_location: 
import cyborg_vector_search_py as cvs

# Using `redis` storage for the index and config
# Using `postgres` storage for the items
index_location = cvs.DBConfig(location="redis", connection_string="redis://localhost")
config_location = cvs.DBConfig(location="redis", connection_string="redis://localhost")
item_location = cvs.DBConfig(location="postgres", table_name="item_table", connection_string="host=localhost dbname=postgres")

# Construct the Client object
client = cvs.Client(index_location=index_location, 
                            config_location=config_location,
                            item_location=item_location)
Item contents will be encrypted prior to being uploaded to the backing store. In most applications, these are accessed less frequently than the index, so a “slower” backing store option can be used, such as PostgreSQL.

​
Setting Device Configurations

Cyborg Vector Search can be accelerated in two ways:
  • CPU Multithreading (via OpenMP) -> can scale with the number of CPU cores available
  • GPU Acceleration (via CUDA & cuVS) -> can increase the speed of certain operations (e.g., ingestion) by an order of magnitude.
You can control either of these with the optional cpu_threads and gpu_accelerate flags: 
# ... existing setup
client = cvs.Client(index_location=index_location, 
                            config_location=config_location,
                            item_location=item_location,
                            cpu_threads=4,
                            gpu_accelerate=False)
gpu_accelerate can only be set to True if running on a CUDA-enabled system with the CUDA driver installed.
By default, cpu_threads will use all available cores, and gpu_accelerate will be set to False.

​
API Reference

For more information on the Client class, refer to the API Reference:

Python API Reference

API reference for Client in Python

C++ API Reference

API reference for cyborg::Client in C++