---
title: "Feature vectors for serving"
description: "Use get_feature_vector() to retrieve specific features for real-time inference."
---

# Feature vectors for serving

> For the complete documentation index see: [llms.txt](https://aerospike.com/docs/llms.txt)
> 
> All documentation pages available in markdown.

In Part 1, the `Entity` class already defined `get_feature_vector()`, so you do not need to jump back and edit earlier cells here. This page focuses on how that method works in serving and how to validate its behavior.

## Use `get_feature_vector`

Unlike the other Entity methods that use the Spark connector for batch reads, `get_feature_vector` uses the Aerospike Python client. It accepts the `as_client` connection you created on the previous page.

`get_feature_vector` looks up one record by primary key and calls `as_client.select(...)` to return only the bins in `feature_list`.

1.  Run `Cell 19` to retrieve one driver’s feature vector.

Cell 19: Retrieve one driver’s feature vector

```python
feature_columns = ["ds_decl_rate", "ds_avg_rating", "da_trips_today"]

features = Entity.get_feature_vector(as_client, "driver", "driver_042", feature_columns)

print(f"Features for driver_042: {features}")
```

Expected output

```plaintext
Features for driver_042: {'ds_decl_rate': 0.061, 'ds_avg_rating': 4.72, 'da_trips_today': 11}
```

-   `as_client`: Aerospike Python client connection
-   `etype`: entity type (for example, `"driver"`)
-   `eid`: entity ID (for example, `"driver_042"`)
-   `feature_list`: bins to retrieve (for example, `["ds_decl_rate", "ds_avg_rating", "da_trips_today"]`)
-   Returns `{feature_name: value}`, or `None` if the entity doesn’t exist

## Test with known drivers

Try a few drivers to see the range of feature values. Recall from Part 2 that drivers with `ds_decl_rate >= 0.10` were labeled as higher decline risk.

1.  Run `Cell 20` to retrieve feature vectors for test drivers.

Cell 20: Retrieve feature vectors for test drivers

```python
feature_columns = ["ds_decl_rate", "ds_avg_rating", "da_trips_today"]

test_drivers = ["driver_005", "driver_042", "driver_087"]

for driver_id in test_drivers:

    fv = Entity.get_feature_vector(as_client, "driver", driver_id, feature_columns)

    if fv is None:

        print(f"{driver_id}: not found")

        continue

    risk = "higher" if fv["ds_decl_rate"] >= 0.10 else "typical"

    print(f"{driver_id}: decline_rate={fv['ds_decl_rate']:.3f}, "

          f"rating={fv['ds_avg_rating']:.2f}, "

          f"trips_today={fv['da_trips_today']}  ({risk} risk)")
```

Expected output

```plaintext
driver_005: decline_rate=0.048, rating=4.81, trips_today=3  (typical risk)

driver_042: decline_rate=0.061, rating=4.72, trips_today=11  (typical risk)

driver_087: decline_rate=0.167, rating=4.22, trips_today=9  (higher risk)
```

Your values will differ, but you should see a mix of typical and higher-risk drivers based on the threshold.

## Measure retrieval time

Run 100 individual lookups (one per driver) to get a stable latency measurement. Each lookup retrieves the same 3-feature vector for one driver.

1.  Run `Cell 21` to benchmark 100 feature vector retrievals.

Cell 21: Benchmark 100 feature vector retrievals

```python
import time

feature_columns = ["ds_decl_rate", "ds_avg_rating", "da_trips_today"]

timings = []

for i in range(1, 101):

    driver_id = f"driver_{i:03d}"

    start = time.perf_counter()

    Entity.get_feature_vector(as_client, "driver", driver_id, feature_columns)

    elapsed = (time.perf_counter() - start) * 1000

    timings.append(elapsed)

timings.sort()

print("Feature retrieval benchmark: 100 lookups (3 features each)")

print(f"  p50: {timings[49]:.2f} ms")

print(f"  p95: {timings[94]:.2f} ms")

print(f"  p99: {timings[98]:.2f} ms")
```

Expected output

```plaintext
Feature retrieval benchmark: 100 lookups (3 features each)

  p50: 0.22 ms

  p95: 0.38 ms

  p99: 0.45 ms
```

Retrieval stays sub-millisecond across the sample. Each call is a single key lookup, and Aerospike returns the requested bins directly.

You now have a fast feature retrieval method. Next, you’ll connect it to the trained model to make predictions.

::: undefined
-   I understand how get\_feature\_vector() performs low-latency feature reads.
-   I can retrieve a driver’s features by ID in under a millisecond.
:::

[Previous  
The Aerospike Python client](https://aerospike.com/docs/develop/model-serving/step/1/part/0/aerospike-client) [Next  
Prediction pipeline](https://aerospike.com/docs/develop/model-serving/step/2/part/0/prediction-pipeline)