CyborgDB Embedded Quickstart

# Install CyborgDB:
pip install cyborgdb-core

# For automatic embedding generation, install with:
pip install cyborgdb-core[embeddings]

# For LangChain integration, install with:
pip install cyborgdb-core[langchain]

# Or with all extras:
pip install cyborgdb-core[all]

# Ensure that Conan is installed

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

# Install CyborgDB:
conan install cyborgdb_core -r cyborgdb

import cyborgdb_core as cyborgdb
import secrets

# Using `rocksdb` for simple persistent local storage
# `redis`, `postgres`, `memory`, and `threadsafememory` are also supported

index_location = cyborgdb.DBConfig("rocksdb")  # Where encrypted index is stored (for queries)
config_location = cyborgdb.DBConfig("rocksdb") # Where encrypted index config is stored (for config/loading)
items_location = cyborgdb.DBConfig("rocksdb")  # Where item contents are stored (for upsert/get)

# Get your API key (use get_demo_api_key() for evaluation, or your own key)
api_key = cyborgdb.get_demo_api_key()

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

#include "cyborgdb_core/client.hpp"
#include "cyborgdb_core/encrypted_index.hpp"
#include <array>
#include <string>
#include <openssl/rand.h>

// Using `rocksdb` for simple persistent local storage
// `redis`, `postgres`, `memory`, and `threadsafememory` are also supported

cyborg::DBConfig index_location(cyborg::Location::kRocksDB);  // Where encrypted index is stored (for queries)
cyborg::DBConfig config_location(cyborg::Location::kRocksDB); // Where encrypted index config is stored (for config/loading)
cyborg::DBConfig contents_location(cyborg::Location::kRocksDB);  // Where item contents are stored (for upsert/get)

// Get your API key
std::string api_key = "your_api_key_here";  // Replace with your actual API key

// Create a client
cyborg::Client client(api_key, index_location, config_location, contents_location, 0, cyborg::kNone);

# ... Continuing from the previous step

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

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

/// ... Continuing from the previous step

// Generate a 32-byte random encryption key
std::array<uint8_t, 32> index_key;
if (RAND_bytes(index_key.data(), index_key.size()) != 1) {
    throw std::runtime_error("Failed to generate secure random key");
}

// Create an encrypted index
auto index = client.CreateIndex("my_index", index_key);

# ... Continuing from the previous step

# Add items to the encrypted index
items = [
    {"id": "item_1", "vector": [0.1, 0.2, 0.3, 0.4], "contents": "Hello!"},
    {"id": "item_2", "vector": [0.5, 0.6, 0.7, 0.8], "contents": "Bonjour!"},
    {"id": "item_3", "vector": [0.9, 0.10, 0.11, 0.12], "contents": "Hola!"}
]

index.upsert(items)

// ... Continuing from the previous step

// Add items to the encrypted index
std::vector<std::string> ids = {"item_1", "item_2", "item_3"};
cyborg::Array2D<float> 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}};
std::vector<std::vector<uint8_t>> contents = {
    std::vector<uint8_t>{'H', 'e', 'l', 'l', 'o', '!'},
    std::vector<uint8_t>{'B', 'o', 'n', 'j', 'o', 'u', 'r', '!'},
    std::vector<uint8_t>{'H', 'o', 'l', 'a', '!'}
};

index->Upsert(ids, vectors, contents);

# ... Continuing from the previous step

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

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

// ... Continuing from the previous step
cyborg::Array2D<float> query_vectors{{0.1, 0.2, 0.3, 0.4}};

// Query using the standard params
cyborg::QueryResults results = index->Query(query_vectors);

// Print the results
auto view = results[0];
for (uint32_t i = 0; i < view.num_results; ++i) {
    std::cout << "ID: " << view.ids[i] << ", Distance: " << view.distances[i] << std::endl;
}

# ... Continuing from the previous step

# Retrieve items from the encrypted index
ids = ["item_1", "item_2", "item_3"]
items = index.get(ids)

# Print the items
for item in items:
    print(f"ID: {item['id']}, Vector: {item['vector']}, Contents: {item['contents']}")

// ... Continuing from the previous step

// Retrieve items from the encrypted index
std::vector<std::string> ids = {"item_1", "item_2", "item_3"};
std::vector<cyborg::ItemFields> include = {cyborg::ItemFields::kContents};
std::vector<cyborg::Item> items = index->Get(ids, include);

// Print the items
for (const auto& item : items) {
    std::cout << "ID: " << item.id << ", Contents: " << std::string(item.contents.begin(), item.contents.end()) << std::endl;
}