Cyborg Vector Search Quickstart

# Ensure that Python 3.11 or 3.12 is installed
# Or create a virtual environment with Python 3.11 or 3.12:
conda create -n cyborg-env python=3.12

# Activate the virtual environment:
conda activate cyborg-env

# Install Cyborg Vector Search:
pip install cyborg_vector_search_py -i https://dl.cloudsmith.io/<token>/cyborg/cyborg-vector-search/python/simple/

# Ensure that Conan is installed

# Add the repository to your Conan remotes:
conan remote add cyborg-vector-search https://dl.cloudsmith.io/<token>/cyborg/cyborg-vector-search/conan
conan remote login cyborg-vector-search -p <token> cyborg

# Install Cyborg Vector Search:
conan install cyborg_vector_search -r cyborg-vector-search

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)
items_location = cvs.DBConfig("memory")  # Where item contents are stored (for upsert/get)

# Create a client
client = cvs.Client(index_location, config_location, items_location)

#include "cyborg_vector_search/client.hpp"
#include "cyborg_vector_search/encrypted_index.hpp"
#include <array>
#include <random>

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

cyborg::LocationConfig index_location(Location::kMemory);  // Where encrypted index is stored (for queries)
cyborg::LocationConfig config_location(Location::kMemory); // Where encrypted index config is stored (for config/loading)
cyborg::LocationConfig items_location(Location::kMemory);  // Where item contents are stored (for upsert/get)

// Create a client
cyborg::Client client(index_location, config_location, items_location);

# ... Continuing from the previous step

# Create an IVFFlat index config (can also be IVF/IVFPQ)
# Using an example vector dimension of 128, and number of lists of 1024
index_config = cvs.IndexIVFFlat(dimension=128, n_lists=1024)

# Generate an encryption key for the index
index_key = secrets.token_bytes(32)

# Create an encrypted index
index = client.create_index("my_index", index_key, index_config)

/// ... Continuing from the previous step

// Create an IVFFlat index config (can also be IVF/IVFPQ)
// Using an example vector dimension of 128, and number of lists of 1024
cyborg::IndexIVFFlat index_config(dimension=128, n_lists=1024);

// Generate a 32-byte random encryption key
std::array<uint8_t, 32> index_key;
std::random_device rd;
std::generate(index_key.begin(), index_key.end(), [&]() { return rd() % 256; });

// Create an encrypted index
cyborg::EncryptedIndex index = client.CreateIndex("my_index", index_key, index_config);

# ... Continuing from the previous step

# Add items to the encrypted index
items = [
    {"id": 1, "vector": [0.1, 0.2, 0.3, 0.4], "item": "Hello!"},
    {"id": 2, "vector": [0.5, 0.6, 0.7, 0.8]}, "item": "Hello!",
    {"id": 3, "vector": [0.9, 0.10, 0.11, 0.12], "item": "Hello!"}
]

index.upsert(items)

// ... Continuing from the previous step

// Add items to the encrypted index
std::vector<uint64_t> ids = {1, 2, 3};
cyborg::Array2D vectors = {{0.1, 0.2, 0.3, 0.4}, {0.5, 0.6, 0.7, 0.8}, {0.9, 0.10, 0.11, 0.12}};

index.Upsert(vectors, ids);

# ... Continuing from the previous step

# Query the encrypted index
query_vector = [0.1, 0.2, 0.3, 0.4]
results = index.query(query_vector)

# Print the results
for result in results:
    print(f"ID: {result.id}, Distance: {result.distance}")

// ... Continuing from the previous step
std::vector<float> query_vector = {0.1, 0.2, 0.3, 0.4};
cyborg::QueryResults results = index.Query(query_vector);

// Print the results
for (const auto& result : results) {
    std::cout << "ID: " << result.id << ", Distance: " << result.distance << std::endl;
}

# ... Continuing from the previous step

# Retrieve items from the encrypted index
ids = [1, 2, 3]
items = index.get_items(ids)

# Print the items
for i in range(len(ids)):
    print(f"ID: {ids[i]}, Contents: {items[i]}")

// ... Continuing from the previous step

// Retrieve items from the encrypted index
std::vector<uint64_t> ids = {1, 2, 3};
cyborg::Array2D<uint8_t> items = index.GetItems(ids);

// Print the items
for (size_t i = 0; i < ids.size(); i++) {
    std::cout << "ID: " << ids[i] << ", Contents: " << items[i] << std::endl;
}