ApsaraDB RDS:Use PASE for efficient vector search

IVFFlat

IVFFlat is a simplified version of the IVFADC algorithm.

1. IVFFlat uses k-means to divide vectors into clusters. Each cluster has a centroid.

2. It finds the n centroids nearest to the query vector.

3. It searches all vectors in those n clusters and returns the k nearest results.

Skipping distant clusters speeds up the query but can reduce recall — vectors similar to the query may fall outside the selected clusters. A larger n improves recall at the cost of more computation.

IVFFlat differs from IVFADC in the second phase. IVFADC uses product quantization to skip brute-force traversal, which is faster but less precise. IVFFlat uses brute-force search within the selected clusters, giving you direct control over the precision–speed tradeoff.

HNSW

HNSW is a graph-based ANN algorithm.

1. HNSW builds a hierarchical structure of layers (graphs). Each layer is a coarser view of the layer below it.

2. A search starts at a random element in the top layer.

3. HNSW finds the neighbors of the current element, adds them to a fixed-length candidate list sorted by distance, and continues expanding neighbors. When the list stabilizes, the top element becomes the entry point for the next layer down.

4. This repeats until the bottom layer is searched.

HNSW uses the Navigable Small World (NSW) algorithm — originally designed for single-layer graphs — to construct each layer, enabling faster traversal than clustering-based methods.

Background knowledge of machine learning and ANN search algorithms is assumed throughout this topic.

Step 1: Enable the extension

CREATE EXTENSION pase;

Step 2: Calculate vector similarity (optional quick test)

Use the <?> operator to compute similarity between two vectors before creating an index.

PASE-type construction:

SELECT ARRAY[2, 1, 1]::float4[] <?> pase(ARRAY[3, 1, 1]::float4[]) AS distance;
SELECT ARRAY[2, 1, 1]::float4[] <?> pase(ARRAY[3, 1, 1]::float4[], 0) AS distance;
SELECT ARRAY[2, 1, 1]::float4[] <?> pase(ARRAY[3, 1, 1]::float4[], 0, 1) AS distance;

String-based construction:

SELECT ARRAY[2, 1, 1]::float4[] <?> '3,1,1'::pase AS distance;
SELECT ARRAY[2, 1, 1]::float4[] <?> '3,1,1:0'::pase AS distance;
SELECT ARRAY[2, 1, 1]::float4[] <?> '3,1,1:0:1'::pase AS distance;

The <?> operator takes a float4[] on the left and a PASE value on the right. Both vectors must have the same number of dimensions, or PASE returns a similarity calculation error.

In the PASE constructor (float4[], second_param, similarity_method):

• Second parameter: reserved; set to 0

• Similarity method: 0 = Euclidean distance, 1 = dot product (also called inner product)

If using the dot product or cosine similarity method, normalize the input vectors first. A normalized vector satisfies such that . For a normalized vector, the dot product equals the cosine value. ApsaraDB RDS for PostgreSQL supports the Euclidean distance method directly; use the dot product method only after normalizing vectors.

Step 3: Create an index

CREATE INDEX ivfflat_idx ON table_name
USING
  pase_ivfflat(column_name)
WITH
  (clustering_type = 1, distance_type = 0, dimension = 256, base64_encoded = 0, clustering_params = "10,100");

CREATE INDEX hnsw_idx ON table_name
USING
  pase_hnsw(column_name)
WITH
  (dim = 256, base_nb_num = 16, ef_build = 40, ef_search = 200, base64_encoded = 0);

Step 4: Query vectors

SELECT id, vector <#> '1,1,1'::pase AS distance
FROM table_name
ORDER BY
  vector <#> '1,1,1:10:0'::pase
ASC LIMIT 10;

SELECT id, vector <?> '1,1,1'::pase AS distance
FROM table_name
ORDER BY
  vector <?> '1,1,1:100:0'::pase
ASC LIMIT 10;

Calculate dot product or cosine similarity

The dot product of a normalized vector equals its cosine value. This function uses an HNSW index to retrieve the top-k results by dot product:

CREATE OR REPLACE FUNCTION inner_product_search(
  query_vector text,
  ef          integer,
  k           integer,
  table_name  text
)
RETURNS TABLE (id integer, uid text, distance float4) AS $$
BEGIN
  RETURN QUERY EXECUTE format('
    SELECT a.id, a.vector <?> pase(ARRAY[%s], %s, 1) AS distance
    FROM (
      SELECT id, vector
      FROM %s
      ORDER BY vector <?> pase(ARRAY[%s], %s, 0) ASC
      LIMIT %s
    ) a
    ORDER BY distance DESC;',
    query_vector, ef, table_name, query_vector, ef, k
  );
END
$$ LANGUAGE plpgsql;

Use an external centroid file for IVFFlat

This is an advanced option. Upload an external centroid file to the server directory, then reference it in clustering_params when clustering_type = 0. The file format is:

Number of dimensions|Number of centroids|Centroid vector dataset

Example:

3|2|1,1,1,2,2,2