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

# Load an Existing Encrypted Index

If you've previously created an encrypted index, you can connect to it to add, query or delete data from it. You will need to know the index's name as well as its key to do so:

<Note>This is only applicable to the CyborgDB SDKs. The REST API is stateless, so you don't need to load indexes explicitly.</Note>

<CodeGroup>
  ```python Python SDK icon="python" theme={null}
  from cyborgdb import Client, IndexIVF

  # Create a client
  client = Client('http://localhost:8000', 'your-api-key')

  # Provide the same index key and config used when creating the index
  index_key = your_existing_32_byte_key  # Must be the same key used originally
  index_config = IndexIVF(
      type='ivf',
      dimension=768,
      n_lists=1024,
      metric='cosine'
  )

  # Connect to existing index (or create if it doesn't exist)
  index = client.create_index("my_index", index_key, index_config)
  ```

  ```javascript JavaScript SDK icon="js" theme={null}
  import { Client, IndexIVFModel } from 'cyborgdb';

  // Create a client
  const client = new Client('http://localhost:8000', 'your-api-key');

  // Provide the same index key and config used when creating the index  
  const indexKey = yourExisting32ByteKey;  // Must be the same key used originally
  const indexConfig = {
      type: 'ivf',
      dimension: 768,
      nLists: 1024,
      metric: 'cosine'
  };

  // Connect to existing index (or create if it doesn't exist)
  const index = await client.createIndex("my_index", indexKey, indexConfig);
  ```

  ```typescript TypeScript SDK icon="code" theme={null}
  import { Client, IndexIVFModel } from 'cyborgdb';

  // Create a client
  const client = new Client('http://localhost:8000', 'your-api-key');

  // Provide the same index key and config used when creating the index
  const indexKey = yourExisting32ByteKey;  // Must be the same key used originally
  const indexConfig: IndexIVFModel = {
      type: 'ivf',
      dimension: 768,
      nLists: 1024,
      metric: 'cosine'
  };

  // Connect to existing index (or create if it doesn't exist)
  const index = await client.createIndex("my_index", indexKey, indexConfig);
  ```

  ```bash cURL icon="rectangle-terminal" theme={null}
  # The REST API is stateless - no explicit "load" needed
  # Simply use the index_name and index_key in subsequent operations

  # Example: Query an existing index directly
  curl -X POST "http://localhost:8000/v1/vectors/query" \
       -H "X-API-Key: your-api-key" \
       -H "Content-Type: application/json" \
       -d '{
         "index_name": "my_index",
         "index_key": "your_64_character_hex_key_here",
         "query_vectors": [0.1, 0.2, 0.3, 0.4],
         "top_k": 5
       }'
  ```
</CodeGroup>

This connects to an existing encrypted index on the service. For more details on index types and configurations, see [Configure an Encrypted Index](./configure-index).

<Warning>You must provide the exact same index key and configuration that was used when the index was originally created.
For production use, we recommend that you use an HSM or KMS solution for key management.
For more details, see [Managing Encryption Keys](../advanced/managing-keys).</Warning>

## Key Points

* **Same Method**: Service SDKs use `createIndex()` for both creating new indexes and connecting to existing ones
* **Exact Match Required**: The index key and configuration must exactly match the original
* **Automatic Detection**: The service automatically determines whether to create or connect based on the index name
* **No Separate Load Method**: Unlike embedded SDKs, service SDKs don't have a separate `loadIndex()` method

## Index Caching

Index caching is handled automatically by the CyborgDB service. The service optimizes performance through:

* **Automatic Caching**: Frequently accessed indexes are cached automatically
* **Smart Eviction**: Least recently used indexes are evicted when memory is needed
* **Server-Side Optimization**: No client-side cache configuration required

## API Reference

For more information on loading an encrypted index, refer to the API reference:

<CardGroup cols={2}>
  <Card title="Python SDK Reference" href="../../python-sdk/client/load-index" icon="python">
    API reference for `load_index()` in Python
  </Card>

  <Card title="JS/TS SDK Reference" href="../../js-ts-sdk/client/load-index" icon="js">
    API reference for `load_index()` in JavaScript/TypeScript
  </Card>
</CardGroup>