> ## 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.

# Create Client

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](../get-started/about#backing-stores) 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:

<CodeGroup>
  ```python Python theme={null}
  # Import cyborgdb_core or cyborgdb_lite:
  import cyborgdb_core as cyborgdb
  import cyborgdb_lite as cyborgdb
  import secrets

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

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

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

  ```cpp C++ theme={null}
  #include "cyborgdb_core/client.hpp"
  #include "cyborgdb_core/encrypted_index.hpp"
  #include <array>
  #include <random>

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

  cyborg::DBConfig index_location(Location::kMemory);  // Where encrypted index is stored (for queries)
  cyborg::DBConfig config_location(Location::kMemory); // Where encrypted index config is stored (for config/loading)

  // Create a client
  cyborg::Client client(index_location, config_location);
  ```
</CodeGroup>

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`:

<CodeGroup>
  ```python Python theme={null}
  # Import cyborgdb_core or cyborgdb_lite:
  import cyborgdb_core as cyborgdb
  import cyborgdb_lite as cyborgdb

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

  # Construct the Client object
  client = cyborgdb.Client(index_location=index_location, 
                              config_location=config_location,
                              item_location=item_location)
  ```

  ```cpp C++ theme={null}
  #include "cyborgdb_core/client.hpp"

  // Using `redis` storage for the index and config
  // Using `postgres` storage for the items
  cyborg::DBConfig index_location(Location::kRedis, "redis://localhost");
  cyborg::DBConfig config_location(Location::kRedis, "redis://localhost");
  cyborg::DBConfig item_location(Location::kPostgres, "host=localhost dbname=postgres");

  // Construct the Client object
  cyborg::Client client(index_location, config_location, item_location);
  ```
</CodeGroup>

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

CyborgDB 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:

<CodeGroup>
  ```python Python theme={null}
  # ... existing setup
  client = cyborgdb.Client(index_location=index_location, 
                              config_location=config_location,
                              item_location=item_location,
                              cpu_threads=4,
                              gpu_accelerate=False)
  ```

  ```cpp C++ theme={null}
  // ... existing setup
  cyborg::Client client(index_location, config_location, item_location, 4, false);
  ```
</CodeGroup>

<Info>`gpu_accelerate` can only be set to `True` if running on a CUDA-enabled system with the CUDA driver installed.</Info>

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:

<CardGroup cols={2}>
  <Card title="Python API Reference" href="../../api-reference/python/client" icon="python">
    API reference for `Client` in Python
  </Card>

  <Card title="C++ API Reference" href="../../api-reference/cpp/client" icon="brackets-curly">
    API reference for `cyborg::Client` in C++
  </Card>
</CardGroup>