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

# Getters

## GetIndexName

Returns the unique name of the index.

```go theme={null}
func (e *EncryptedIndex) GetIndexName() string
```

**Returns**: `string` - The index name as specified during creation

**Example**:

```go theme={null}
indexName := index.GetIndexName()
fmt.Printf("Working with index: %s\n", indexName)
```

***

## GetIndexType

Returns the algorithm type of the index.

```go theme={null}
func (e *EncryptedIndex) GetIndexType() string
```

**Returns**: `string` - Index type ("ivfflat", "ivfpq", or "ivfsq")

**Example**:

```go theme={null}
indexType := index.GetIndexType()
fmt.Printf("Index type: %s\n", indexType)

// Use type for conditional logic
switch indexType {
case "ivfflat":
    fmt.Println("Using IVFFlat (IVF with flat search) index")
case "ivfpq":
    fmt.Println("Using IVFPQ (IVF with Product Quantization) index")
case "ivfsq":
    fmt.Println("Using IVFSQ (IVF with Scalar Quantization) index")
}
```

***

## IsTrained

Checks whether the index has been optimized through training. This method makes an API call to get the current training status from the server.

```go theme={null}
func (e *EncryptedIndex) IsTrained(ctx context.Context) (bool, error)
```

**Parameters**:

* `ctx`: `context.Context` - Context for cancellation and timeouts

**Returns**:

* `bool` - `true` if the index has been trained, `false` otherwise
* `error` - Any error encountered during the status check

**Example**:

```go theme={null}
ctx := context.Background()
trained, err := index.IsTrained(ctx)
if err != nil {
    log.Printf("Failed to check training status: %v", err)
    return
}

if trained {
    fmt.Println("Index is trained and optimized")
} else {
    fmt.Println("Index may benefit from training")
    // Optionally trigger training
    params := cyborgdb.TrainParams{}
    err := index.Train(ctx, params)
    if err != nil {
        log.Printf("Training failed: %v", err)
    }
}
```

***

## GetIndexConfig

Returns the detailed configuration of the index.

```go theme={null}
func (e *EncryptedIndex) GetIndexConfig() internal.IndexConfig
```

**Returns**: `internal.IndexConfig` - The index configuration, or empty if not available

**Note**: For indexes loaded via `LoadIndex()`, the configuration may be incomplete.

**Example**:

```go theme={null}
config := index.GetIndexConfig()

// Access configuration based on index type
switch index.GetIndexType() {
case "ivfsq":
    if config.IndexIVFSQModel != nil {
        fmt.Printf("IVFSQ Dimension: %d\n", config.IndexIVFSQModel.GetDimension())
    }
case "ivfflat":
    if config.IndexIVFFlatModel != nil {
        fmt.Printf("IVFFlat Dimension: %d\n", config.IndexIVFFlatModel.GetDimension())
    }
case "ivfpq":
    if config.IndexIVFPQModel != nil {
        fmt.Printf("IVFPQ Dimension: %d\n", config.IndexIVFPQModel.GetDimension())
        fmt.Printf("PQ Dimension: %d\n", config.IndexIVFPQModel.GetPqDim())
        fmt.Printf("PQ Bits: %d\n", config.IndexIVFPQModel.GetPqBits())
    }
}
```

***

## CheckTrainingStatus

Queries the server to check if the index is currently being trained and updates the cached training status.

```go theme={null}
func (e *EncryptedIndex) CheckTrainingStatus(ctx context.Context) (bool, error)
```

**Parameters**:

* `ctx`: `context.Context` - Context for cancellation and timeouts

**Returns**:

* `bool` - `true` if the index is currently being trained, `false` otherwise
* `error` - Any error encountered during the status check

**Note**: This method makes an API call and updates the cached `IsTrained()` value if training has completed.

**Example**:

```go theme={null}
isTraining, err := index.CheckTrainingStatus(context.Background())
if err != nil {
    log.Printf("Failed to check training status: %v", err)
    return
}

if isTraining {
    fmt.Println("Index is currently being trained")
    // Wait for training to complete
    for isTraining {
        time.Sleep(10 * time.Second)
        isTraining, err = index.CheckTrainingStatus(context.Background())
        if err != nil {
            log.Printf("Error checking training status: %v", err)
            break
        }
        fmt.Println("Still training...")
    }
    fmt.Println("Training completed!")
} else {
    trained, err := index.IsTrained(context.Background())
    if err != nil {
        log.Printf("Failed to check training status: %v", err)
        return
    }
    if trained {
        fmt.Println("Index is trained")
    } else {
        fmt.Println("Index is not trained and not currently training")
    }
}
```