PGXN

PostgreSQL Extension Network

vector

This Release

vector0.8.1

Date

2025-09-05

Status

Stable

Other Releases

Abstract

Open-source vector similarity search for Postgres

Description

Supports L2 distance, inner product, and cosine distance

Released By

ankane

License

PostgreSQL

Resources

Special Files

Tags

Extensions

vector0.8.1: Open-source vector similarity search for Postgres

Documentation

CHANGELOG: CHANGELOG

README

pgvector

pgvector

Open-source vector similarity search for Postgres

Store your vectors with the rest of your data. Supports:

exact and approximate nearest neighbor search
single-precision, half-precision, binary, and sparse vectors
L2 distance, inner product, cosine distance, L1 distance, Hamming distance, and Jaccard distance
anylanguage with a Postgres client

PlusACID compliance, point-in-time recovery, JOINs, and all of the othergreat features of Postgres

Installation

Linux and Mac

Compile and install the extension (supports Postgres 13+)

cd /tmpgit clone --branch v0.8.1 https://github.com/pgvector/pgvector.gitcd pgvectormakemake install # may need sudo

See theinstallation notes if you run into issues

You can also install it withDocker,Homebrew,PGXN,APT,Yum,pkg, orconda-forge, and it comes preinstalled withPostgres.app and manyhosted providers. There are also instructions forGitHub Actions.

Windows

EnsureC++ support in Visual Studio is installed and runx64 Native Tools Command Prompt for VS [version] as administrator. Then usenmake to build:

set "PGROOT=C:\Program Files\PostgreSQL\17"cd %TEMP%git clone --branch v0.8.1 https://github.com/pgvector/pgvector.gitcd pgvectornmake /F Makefile.winnmake /F Makefile.win install

See theinstallation notes if you run into issues

You can also install it withDocker orconda-forge.

Getting Started

Enable the extension (do this once in each database where you want to use it)

CREATE EXTENSION vector;

Create a vector column with 3 dimensions

CREATE TABLE items (id bigserial PRIMARY KEY, embedding vector(3));

Insert vectors

INSERT INTO items (embedding) VALUES ('[1,2,3]'), ('[4,5,6]');

Get the nearest neighbors by L2 distance

SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;

Also supports inner product (<#>), cosine distance (<=>), and L1 distance (<+>)

Note:<#> returns the negative inner product since Postgres only supportsASC order index scans on operators

Storing

Create a new table with a vector column

CREATE TABLE items (id bigserial PRIMARY KEY, embedding vector(3));

Or add a vector column to an existing table

ALTER TABLE items ADD COLUMN embedding vector(3);

Also supportshalf-precision,binary, andsparse vectors

Insert vectors

INSERT INTO items (embedding) VALUES ('[1,2,3]'), ('[4,5,6]');

Or load vectors in bulk usingCOPY (example)

COPY items (embedding) FROM STDIN WITH (FORMAT BINARY);

Upsert vectors

INSERT INTO items (id, embedding) VALUES (1, '[1,2,3]'), (2, '[4,5,6]')    ON CONFLICT (id) DO UPDATE SET embedding = EXCLUDED.embedding;

Update vectors

UPDATE items SET embedding = '[1,2,3]' WHERE id = 1;

Delete vectors

DELETE FROM items WHERE id = 1;

Querying

Get the nearest neighbors to a vector

SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;

Supported distance functions are:

<-> - L2 distance
<#> - (negative) inner product
<=> - cosine distance
<+> - L1 distance
<~> - Hamming distance (binary vectors)
<%> - Jaccard distance (binary vectors)

Get the nearest neighbors to a row

SELECT * FROM items WHERE id != 1 ORDER BY embedding <-> (SELECT embedding FROM items WHERE id = 1) LIMIT 5;

Get rows within a certain distance

SELECT * FROM items WHERE embedding <-> '[3,1,2]' < 5;

Note: Combine withORDER BY andLIMIT to use an index

Distances

Get the distance

SELECT embedding <-> '[3,1,2]' AS distance FROM items;

For inner product, multiply by -1 (since<#> returns the negative inner product)

SELECT (embedding <#> '[3,1,2]') * -1 AS inner_product FROM items;

For cosine similarity, use 1 - cosine distance

SELECT 1 - (embedding <=> '[3,1,2]') AS cosine_similarity FROM items;

Aggregates

Average vectors

SELECT AVG(embedding) FROM items;

Average groups of vectors

SELECT category_id, AVG(embedding) FROM items GROUP BY category_id;

Indexing

By default, pgvector performs exact nearest neighbor search, which provides perfect recall.

You can add an index to use approximate nearest neighbor search, which trades some recall for speed. Unlike typical indexes, you will see different results for queries after adding an approximate index.

Supported index types are:

HNSW

An HNSW index creates a multilayer graph. It has better query performance than IVFFlat (in terms of speed-recall tradeoff), but has slower build times and uses more memory. Also, an index can be created without any data in the table since there isn’t a training step like IVFFlat.

Add an index for each distance function you want to use.

L2 distance

CREATE INDEX ON items USING hnsw (embedding vector_l2_ops);

Note: Usehalfvec_l2_ops forhalfvec andsparsevec_l2_ops forsparsevec (and similar with the other distance functions)

Inner product

CREATE INDEX ON items USING hnsw (embedding vector_ip_ops);

Cosine distance

CREATE INDEX ON items USING hnsw (embedding vector_cosine_ops);

L1 distance

CREATE INDEX ON items USING hnsw (embedding vector_l1_ops);

Hamming distance

CREATE INDEX ON items USING hnsw (embedding bit_hamming_ops);

Jaccard distance

CREATE INDEX ON items USING hnsw (embedding bit_jaccard_ops);

Supported types are:

vector - up to 2,000 dimensions
halfvec - up to 4,000 dimensions
bit - up to 64,000 dimensions
sparsevec - up to 1,000 non-zero elements

Index Options

Specify HNSW parameters

m - the max number of connections per layer (16 by default)
ef_construction - the size of the dynamic candidate list for constructing the graph (64 by default)

CREATE INDEX ON items USING hnsw (embedding vector_l2_ops) WITH (m = 16, ef_construction = 64);

A higher value ofef_construction provides better recall at the cost of index build time / insert speed.

Query Options

Specify the size of the dynamic candidate list for search (40 by default)

SET hnsw.ef_search = 100;

A higher value provides better recall at the cost of speed.

UseSET LOCAL inside a transaction to set it for a single query

BEGIN;SET LOCAL hnsw.ef_search = 100;SELECT ...COMMIT;

Index Build Time

Indexes build significantly faster when the graph fits intomaintenance_work_mem

SET maintenance_work_mem = '8GB';

A notice is shown when the graph no longer fits

NOTICE:  hnsw graph no longer fits into maintenance_work_mem after 100000 tuplesDETAIL:  Building will take significantly more time.HINT:  Increase maintenance_work_mem to speed up builds.

Note: Do not setmaintenance_work_mem so high that it exhausts the memory on the server

Like other index types, it’s faster to create an index after loading your initial data

You can also speed up index creation by increasing the number of parallel workers (2 by default)

SET max_parallel_maintenance_workers = 7; -- plus leader

For a large number of workers, you may need to increasemax_parallel_workers (8 by default)

Theindex options also have a significant impact on build time (use the defaults unless seeing low recall)

Indexing Progress

Checkindexing progress

SELECT phase, round(100.0 * blocks_done / nullif(blocks_total, 0), 1) AS "%" FROM pg_stat_progress_create_index;

The phases for HNSW are:

initializing
loading tuples

IVFFlat

An IVFFlat index divides vectors into lists, and then searches a subset of those lists that are closest to the query vector. It has faster build times and uses less memory than HNSW, but has lower query performance (in terms of speed-recall tradeoff).

Three keys to achieving good recall are:

Create the indexafter the table has some data
Choose an appropriate number of lists - a good place to start isrows / 1000 for up to 1M rows andsqrt(rows) for over 1M rows
When querying, specify an appropriate number ofprobes (higher is better for recall, lower is better for speed) - a good place to start issqrt(lists)

Add an index for each distance function you want to use.

L2 distance

CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 100);

Note: Usehalfvec_l2_ops forhalfvec (and similar with the other distance functions)

Inner product

CREATE INDEX ON items USING ivfflat (embedding vector_ip_ops) WITH (lists = 100);

Cosine distance

CREATE INDEX ON items USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);

Hamming distance

CREATE INDEX ON items USING ivfflat (embedding bit_hamming_ops) WITH (lists = 100);

Supported types are:

vector - up to 2,000 dimensions
halfvec - up to 4,000 dimensions
bit - up to 64,000 dimensions

Query Options

Specify the number of probes (1 by default)

SET ivfflat.probes = 10;

A higher value provides better recall at the cost of speed, and it can be set to the number of lists for exact nearest neighbor search (at which point the planner won’t use the index)

UseSET LOCAL inside a transaction to set it for a single query

BEGIN;SET LOCAL ivfflat.probes = 10;SELECT ...COMMIT;

Index Build Time

Speed up index creation on large tables by increasing the number of parallel workers (2 by default)

SET max_parallel_maintenance_workers = 7; -- plus leader

For a large number of workers, you may also need to increasemax_parallel_workers (8 by default)

Indexing Progress

Checkindexing progress

SELECT phase, round(100.0 * tuples_done / nullif(tuples_total, 0), 1) AS "%" FROM pg_stat_progress_create_index;

The phases for IVFFlat are:

initializing
performing k-means
assigning tuples
loading tuples

Note:% is only populated during theloading tuples phase

Filtering

There are a few ways to index nearest neighbor queries with aWHERE clause.

SELECT * FROM items WHERE category_id = 123 ORDER BY embedding <-> '[3,1,2]' LIMIT 5;

A good place to start is creating an index on the filter column. This can provide fast, exact nearest neighbor search in many cases. Postgres has a number ofindex types for this: B-tree (default), hash, GiST, SP-GiST, GIN, and BRIN.

CREATE INDEX ON items (category_id);

For multiple columns, consider amulticolumn index.

CREATE INDEX ON items (location_id, category_id);

Exact indexes work well for conditions that match a low percentage of rows. Otherwise,approximate indexes can work better.

CREATE INDEX ON items USING hnsw (embedding vector_l2_ops);

With approximate indexes, filtering is appliedafter the index is scanned. If a condition matches 10% of rows, with HNSW and the defaulthnsw.ef_search of 40, only 4 rows will match on average. For more rows, increasehnsw.ef_search.

SET hnsw.ef_search = 200;

Starting with 0.8.0, you can enableiterative index scans, which will automatically scan more of the index when needed.

SET hnsw.iterative_scan = strict_order;

If filtering by only a few distinct values, considerpartial indexing.

CREATE INDEX ON items USING hnsw (embedding vector_l2_ops) WHERE (category_id = 123);

If filtering by many different values, considerpartitioning.

CREATE TABLE items (embedding vector(3), category_id int) PARTITION BY LIST(category_id);

Iterative Index Scans

With approximate indexes, queries with filtering can return less results since filtering is appliedafter the index is scanned. Starting with 0.8.0, you can enable iterative index scans, which will automatically scan more of the index until enough results are found (or it reacheshnsw.max_scan_tuples orivfflat.max_probes).

Iterative scans can use strict or relaxed ordering.

Strict ensures results are in the exact order by distance

SET hnsw.iterative_scan = strict_order;

Relaxed allows results to be slightly out of order by distance, but provides better recall

SET hnsw.iterative_scan = relaxed_order;# orSET ivfflat.iterative_scan = relaxed_order;

With relaxed ordering, you can use amaterialized CTE to get strict ordering

WITH relaxed_results AS MATERIALIZED (    SELECT id, embedding <-> '[1,2,3]' AS distance FROM items WHERE category_id = 123 ORDER BY distance LIMIT 5) SELECT * FROM relaxed_results ORDER BY distance + 0;

Note:+ 0 is needed for Postgres 17+

For queries that filter by distance, use a materialized CTE and place the distance filter outside of it for best performance (due to thecurrent behavior of the Postgres executor)

WITH nearest_results AS MATERIALIZED (    SELECT id, embedding <-> '[1,2,3]' AS distance FROM items ORDER BY distance LIMIT 5) SELECT * FROM nearest_results WHERE distance < 5 ORDER BY distance;

Note: Place any other filters inside the CTE

Iterative Scan Options

Since scanning a large portion of an approximate index is expensive, there are options to control when a scan ends.

HNSW

Specify the max number of tuples to visit (20,000 by default)

SET hnsw.max_scan_tuples = 20000;

Note: This is approximate and does not affect the initial scan

Specify the max amount of memory to use, as a multiple ofwork_mem (1 by default)

SET hnsw.scan_mem_multiplier = 2;

Note: Try increasing this if increasinghnsw.max_scan_tuples does not improve recall

IVFFlat

Specify the max number of probes

SET ivfflat.max_probes = 100;

Note: If this is lower thanivfflat.probes,ivfflat.probes will be used

Half-Precision Vectors

Use thehalfvec type to store half-precision vectors

CREATE TABLE items (id bigserial PRIMARY KEY, embedding halfvec(3));

Half-Precision Indexing

Index vectors at half precision for smaller indexes

CREATE INDEX ON items USING hnsw ((embedding::halfvec(3)) halfvec_l2_ops);

Get the nearest neighbors

SELECT * FROM items ORDER BY embedding::halfvec(3) <-> '[1,2,3]' LIMIT 5;

Binary Vectors

Use thebit type to store binary vectors (example)

CREATE TABLE items (id bigserial PRIMARY KEY, embedding bit(3));INSERT INTO items (embedding) VALUES ('000'), ('111');

Get the nearest neighbors by Hamming distance

SELECT * FROM items ORDER BY embedding <~> '101' LIMIT 5;

Also supports Jaccard distance (<%>)

Binary Quantization

Use expression indexing for binary quantization

CREATE INDEX ON items USING hnsw ((binary_quantize(embedding)::bit(3)) bit_hamming_ops);

Get the nearest neighbors by Hamming distance

SELECT * FROM items ORDER BY binary_quantize(embedding)::bit(3) <~> binary_quantize('[1,-2,3]') LIMIT 5;

Re-rank by the original vectors for better recall

SELECT * FROM (    SELECT * FROM items ORDER BY binary_quantize(embedding)::bit(3) <~> binary_quantize('[1,-2,3]') LIMIT 20) ORDER BY embedding <=> '[1,-2,3]' LIMIT 5;

Sparse Vectors

Use thesparsevec type to store sparse vectors

CREATE TABLE items (id bigserial PRIMARY KEY, embedding sparsevec(5));

Insert vectors

INSERT INTO items (embedding) VALUES ('{1:1,3:2,5:3}/5'), ('{1:4,3:5,5:6}/5');

The format is{index1:value1,index2:value2}/dimensions and indices start at 1 like SQL arrays

Get the nearest neighbors by L2 distance

SELECT * FROM items ORDER BY embedding <-> '{1:3,3:1,5:2}/5' LIMIT 5;

Hybrid Search

Use together with Postgresfull-text search for hybrid search.

SELECT id, content FROM items, plainto_tsquery('hello search') query    WHERE textsearch @@ query ORDER BY ts_rank_cd(textsearch, query) DESC LIMIT 5;

You can useReciprocal Rank Fusion or across-encoder to combine results.

Indexing Subvectors

Use expression indexing to index subvectors

CREATE INDEX ON items USING hnsw ((subvector(embedding, 1, 3)::vector(3)) vector_cosine_ops);

Get the nearest neighbors by cosine distance

SELECT * FROM items ORDER BY subvector(embedding, 1, 3)::vector(3) <=> subvector('[1,2,3,4,5]'::vector, 1, 3) LIMIT 5;

Re-rank by the full vectors for better recall

SELECT * FROM (    SELECT * FROM items ORDER BY subvector(embedding, 1, 3)::vector(3) <=> subvector('[1,2,3,4,5]'::vector, 1, 3) LIMIT 20) ORDER BY embedding <=> '[1,2,3,4,5]' LIMIT 5;

Performance

Tuning

Use a tool likePgTune to set initial values for Postgres server parameters. For instance,shared_buffers should typically be 25% of the server’s memory. You can find the config file with:

SHOW config_file;

And check individual settings with:

SHOW shared_buffers;

Be sure to restart Postgres for changes to take effect.

Loading

UseCOPY for bulk loading data (example).

COPY items (embedding) FROM STDIN WITH (FORMAT BINARY);

Add any indexesafter loading the initial data for best performance.

Indexing

See index build time forHNSW andIVFFlat.

In production environments, create indexes concurrently to avoid blocking writes.

CREATE INDEX CONCURRENTLY ...

Querying

UseEXPLAIN ANALYZE to debug performance.

EXPLAIN ANALYZE SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;

Exact Search

To speed up queries without an index, increasemax_parallel_workers_per_gather.

SET max_parallel_workers_per_gather = 4;

If vectors are normalized to length 1 (likeOpenAI embeddings), use inner product for best performance.

SELECT * FROM items ORDER BY embedding <#> '[3,1,2]' LIMIT 5;

Approximate Search

To speed up queries with an IVFFlat index, increase the number of inverted lists (at the expense of recall).

CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 1000);

Vacuuming

Vacuuming can take a while for HNSW indexes. Speed it up by reindexing first.

REINDEX INDEX CONCURRENTLY index_name;VACUUM table_name;

Monitoring

Monitor performance withpg_stat_statements (be sure to add it toshared_preload_libraries).

CREATE EXTENSION pg_stat_statements;

Get the most time-consuming queries with:

SELECT query, calls, ROUND((total_plan_time + total_exec_time) / calls) AS avg_time_ms,    ROUND((total_plan_time + total_exec_time) / 60000) AS total_time_min    FROM pg_stat_statements ORDER BY total_plan_time + total_exec_time DESC LIMIT 20;

Monitor recall by comparing results from approximate search with exact search.

BEGIN;SET LOCAL enable_indexscan = off; -- use exact searchSELECT ...COMMIT;

Scaling

Scale pgvector the same way you scale Postgres.

Scale vertically by increasing memory, CPU, and storage on a single instance. Use existing tools totune parameters andmonitor performance.

Scale horizontally withreplicas, or useCitus or another approach for sharding (example).

Languages

Use pgvector from any language with a Postgres client. You can even generate and store vectors in one language and query them in another.

Language	Libraries / Examples
C	pgvector-c
C++	pgvector-cpp
C#, F#, Visual Basic	pgvector-dotnet
Crystal	pgvector-crystal
D	pgvector-d
Dart	pgvector-dart
Elixir	pgvector-elixir
Erlang	pgvector-erlang
Fortran	pgvector-fortran
Gleam	pgvector-gleam
Go	pgvector-go
Haskell	pgvector-haskell
Java, Kotlin, Groovy, Scala	pgvector-java
JavaScript, TypeScript	pgvector-node
Julia	Pgvector.jl
Lisp	pgvector-lisp
Lua	pgvector-lua
Nim	pgvector-nim
OCaml	pgvector-ocaml
Perl	pgvector-perl
PHP	pgvector-php
Python	pgvector-python
R	pgvector-r
Raku	pgvector-raku
Ruby	pgvector-ruby,Neighbor
Rust	pgvector-rust
Swift	pgvector-swift
Zig	pgvector-zig

Frequently Asked Questions

How many vectors can be stored in a single table?

A non-partitioned table has a limit of 32 TB by default in Postgres. A partitioned table can have thousands of partitions of that size.

Is replication supported?

Yes, pgvector uses the write-ahead log (WAL), which allows for replication and point-in-time recovery.

What if I want to index vectors with more than 2,000 dimensions?

You can usehalf-precision indexing to index up to 4,000 dimensions orbinary quantization to index up to 64,000 dimensions. Another option isdimensionality reduction.

Can I store vectors with different dimensions in the same column?

You can usevector as the type (instead ofvector(n)).

CREATE TABLE embeddings (model_id bigint, item_id bigint, embedding vector, PRIMARY KEY (model_id, item_id));

However, you can only create indexes on rows with the same number of dimensions (usingexpression andpartial indexing):

CREATE INDEX ON embeddings USING hnsw ((embedding::vector(3)) vector_l2_ops) WHERE (model_id = 123);

and query with:

SELECT * FROM embeddings WHERE model_id = 123 ORDER BY embedding::vector(3) <-> '[3,1,2]' LIMIT 5;

Can I store vectors with more precision?

You can use thedouble precision[] ornumeric[] type to store vectors with more precision.

CREATE TABLE items (id bigserial PRIMARY KEY, embedding double precision[]);-- use {} instead of [] for Postgres arraysINSERT INTO items (embedding) VALUES ('{1,2,3}'), ('{4,5,6}');

Optionally, add acheck constraint to ensure data can be converted to thevector type and has the expected dimensions.

ALTER TABLE items ADD CHECK (vector_dims(embedding::vector) = 3);

Useexpression indexing to index (at a lower precision):

CREATE INDEX ON items USING hnsw ((embedding::vector(3)) vector_l2_ops);

and query with:

SELECT * FROM items ORDER BY embedding::vector(3) <-> '[3,1,2]' LIMIT 5;

Do indexes need to fit into memory?

No, but like other index types, you’ll likely see better performance if they do. You can get the size of an index with:

SELECT pg_size_pretty(pg_relation_size('index_name'));

Troubleshooting

Why isn’t a query using an index?

The query needs to have anORDER BY andLIMIT, and theORDER BY must be the result of a distance operator (not an expression) in ascending order.

-- indexORDER BY embedding <=> '[3,1,2]' LIMIT 5;-- no indexORDER BY 1 - (embedding <=> '[3,1,2]') DESC LIMIT 5;

You can encourage the planner to use an index for a query with:

BEGIN;SET LOCAL enable_seqscan = off;SELECT ...COMMIT;

Also, if the table is small, a table scan may be faster.

Why isn’t a query using a parallel table scan?

The planner doesn’t considerout-of-line storage in cost estimates, which can make a serial scan look cheaper. You can reduce the cost of a parallel scan for a query with:

BEGIN;SET LOCAL min_parallel_table_scan_size = 1;SET LOCAL parallel_setup_cost = 1;SELECT ...COMMIT;

or choose to store vectors inline:

ALTER TABLE items ALTER COLUMN embedding SET STORAGE PLAIN;

Why are there less results for a query after adding an HNSW index?

Results are limited by the size of the dynamic candidate list (hnsw.ef_search), which is 40 by default. There may be even less results due to dead tuples or filtering conditions in the query. Enablingiterative index scans can help address this.

Also, note thatNULL vectors are not indexed (as well as zero vectors for cosine distance).

Why are there less results for a query after adding an IVFFlat index?

The index was likely created with too little data for the number of lists. Drop the index until the table has more data.

DROP INDEX index_name;

Results can also be limited by the number of probes (ivfflat.probes). Enablingiterative index scans can address this.

Also, note thatNULL vectors are not indexed (as well as zero vectors for cosine distance).

Reference

Vector Type

Each vector takes4 * dimensions + 8 bytes of storage. Each element is a single-precision floating-point number (like thereal type in Postgres), and all elements must be finite (noNaN,Infinity or-Infinity). Vectors can have up to 16,000 dimensions.

Vector Operators

Operator	Description	Added
+	element-wise addition
-	element-wise subtraction
*	element-wise multiplication	0.5.0
\|\|	concatenate	0.7.0
<->	Euclidean distance
<#>	negative inner product
<=>	cosine distance
<+>	taxicab distance	0.7.0

Vector Functions

Function	Description	Added
binary_quantize(vector) → bit	binary quantize	0.7.0
cosine_distance(vector, vector) → double precision	cosine distance
inner_product(vector, vector) → double precision	inner product
l1_distance(vector, vector) → double precision	taxicab distance	0.5.0
l2_distance(vector, vector) → double precision	Euclidean distance
l2_normalize(vector) → vector	Normalize with Euclidean norm	0.7.0
subvector(vector, integer, integer) → vector	subvector	0.7.0
vector_dims(vector) → integer	number of dimensions
vector_norm(vector) → double precision	Euclidean norm

Vector Aggregate Functions

Function	Description	Added
avg(vector) → vector	average
sum(vector) → vector	sum	0.5.0

Halfvec Type

Each half vector takes2 * dimensions + 8 bytes of storage. Each element is a half-precision floating-point number, and all elements must be finite (noNaN,Infinity or-Infinity). Half vectors can have up to 16,000 dimensions.

Halfvec Operators

Operator	Description	Added
+	element-wise addition	0.7.0
-	element-wise subtraction	0.7.0
*	element-wise multiplication	0.7.0
\|\|	concatenate	0.7.0
<->	Euclidean distance	0.7.0
<#>	negative inner product	0.7.0
<=>	cosine distance	0.7.0
<+>	taxicab distance	0.7.0

Halfvec Functions

Function	Description	Added
binary_quantize(halfvec) → bit	binary quantize	0.7.0
cosine_distance(halfvec, halfvec) → double precision	cosine distance	0.7.0
inner_product(halfvec, halfvec) → double precision	inner product	0.7.0
l1_distance(halfvec, halfvec) → double precision	taxicab distance	0.7.0
l2_distance(halfvec, halfvec) → double precision	Euclidean distance	0.7.0
l2_norm(halfvec) → double precision	Euclidean norm	0.7.0
l2_normalize(halfvec) → halfvec	Normalize with Euclidean norm	0.7.0
subvector(halfvec, integer, integer) → halfvec	subvector	0.7.0
vector_dims(halfvec) → integer	number of dimensions	0.7.0

Halfvec Aggregate Functions

Function	Description	Added
avg(halfvec) → halfvec	average	0.7.0
sum(halfvec) → halfvec	sum	0.7.0

Bit Type

Each bit vector takesdimensions / 8 + 8 bytes of storage. See thePostgres docs for more info.

Bit Operators

Operator	Description	Added
<~>	Hamming distance	0.7.0
<%>	Jaccard distance	0.7.0

Bit Functions

Function	Description	Added
hamming_distance(bit, bit) → double precision	Hamming distance	0.7.0
jaccard_distance(bit, bit) → double precision	Jaccard distance	0.7.0

Sparsevec Type

Each sparse vector takes8 * non-zero elements + 16 bytes of storage. Each element is a single-precision floating-point number, and all elements must be finite (noNaN,Infinity or-Infinity). Sparse vectors can have up to 16,000 non-zero elements.

Sparsevec Operators

Operator	Description	Added
<->	Euclidean distance	0.7.0
<#>	negative inner product	0.7.0
<=>	cosine distance	0.7.0
<+>	taxicab distance	0.7.0

Sparsevec Functions

Function	Description	Added
cosine_distance(sparsevec, sparsevec) → double precision	cosine distance	0.7.0
inner_product(sparsevec, sparsevec) → double precision	inner product	0.7.0
l1_distance(sparsevec, sparsevec) → double precision	taxicab distance	0.7.0
l2_distance(sparsevec, sparsevec) → double precision	Euclidean distance	0.7.0
l2_norm(sparsevec) → double precision	Euclidean norm	0.7.0
l2_normalize(sparsevec) → sparsevec	Normalize with Euclidean norm	0.7.0

Installation Notes - Linux and Mac

Postgres Location

If your machine has multiple Postgres installations, specify the path topg_config with:

export PG_CONFIG=/Library/PostgreSQL/17/bin/pg_config

Then re-run the installation instructions (runmake clean beforemake if needed). Ifsudo is needed formake install, use:

sudo --preserve-env=PG_CONFIG make install

A few common paths on Mac are:

EDB installer -/Library/PostgreSQL/17/bin/pg_config
Homebrew (arm64) -/opt/homebrew/opt/postgresql@17/bin/pg_config
Homebrew (x86-64) -/usr/local/opt/postgresql@17/bin/pg_config

Note: Replace17 with your Postgres server version

Missing Header

If compilation fails withfatal error: postgres.h: No such file or directory, make sure Postgres development files are installed on the server.

For Ubuntu and Debian, use:

sudo apt install postgresql-server-dev-17

Note: Replace17 with your Postgres server version

Missing SDK

If compilation fails and the output includeswarning: no such sysroot directory on Mac, your Postgres installation points to a path that no longer exists.

pg_config --cppflags

Reinstall Postgres to fix this.

Portability

By default, pgvector compiles with-march=native on some platforms for best performance. However, this can lead toIllegal instruction errors if trying to run the compiled extension on a different machine.

To compile for portability, use:

make OPTFLAGS=""

Installation Notes - Windows

Missing Header

If compilation fails withCannot open include file: 'postgres.h': No such file or directory, make surePGROOT is correct.

Mismatched Architecture

If compilation fails witherror C2196: case value '4' already used, make sure you’re using thex64 Native Tools Command Prompt. Then runnmake /F Makefile.win clean and re-run the installation instructions.

Missing Symbol

If linking fails withunresolved external symbol float_to_shortest_decimal_bufn with Postgres 17.0-17.2, upgrade to Postgres 17.3+.

Permissions

If installation fails withAccess is denied, re-run the installation instructions as an administrator.

Additional Installation Methods

Docker

Get theDocker image with:

docker pull pgvector/pgvector:pg17-trixie

This adds pgvector to thePostgres image (replace17 with your Postgres server version, and run it the same way).

Supported tags are:

pg17-trixie,0.8.1-pg17-trixie
pg17-bookworm,0.8.1-pg17-bookworm,pg17,0.8.1-pg17
pg16-trixie,0.8.1-pg16-trixie
pg16-bookworm,0.8.1-pg16-bookworm,pg16,0.8.1-pg16
pg15-trixie,0.8.1-pg15-trixie
pg15-bookworm,0.8.1-pg15-bookworm,pg15,0.8.1-pg15
pg14-trixie,0.8.1-pg14-trixie
pg14-bookworm,0.8.1-pg14-bookworm,pg14,0.8.1-pg14
pg13-trixie,0.8.1-pg13-trixie
pg13-bookworm,0.8.1-pg13-bookworm,pg13,0.8.1-pg13

You can also build the image manually:

git clone --branch v0.8.1 https://github.com/pgvector/pgvector.gitcd pgvectordocker build --pull --build-arg PG_MAJOR=17 -t myuser/pgvector .

If you increasemaintenance_work_mem, make sure--shm-size is at least that size to avoid an error with parallel HNSW index builds.

docker run --shm-size=1g ...

Homebrew

With Homebrew Postgres, you can use:

brew install pgvector

Note: This only adds it to thepostgresql@17 andpostgresql@14 formulas

PGXN

Install from thePostgreSQL Extension Network with:

pgxn install vector

APT

Debian and Ubuntu packages are available from thePostgreSQL APT Repository. Follow thesetup instructions and run:

sudo apt install postgresql-17-pgvector

Note: Replace17 with your Postgres server version

Yum

RPM packages are available from thePostgreSQL Yum Repository. Follow thesetup instructions for your distribution and run:

sudo yum install pgvector_17# orsudo dnf install pgvector_17

Note: Replace17 with your Postgres server version

pkg

Install the FreeBSD package with:

pkg install postgresql17-pgvector

or the port with:

cd /usr/ports/databases/pgvectormake install

conda-forge

With Conda Postgres, install fromconda-forge with:

conda install -c conda-forge pgvector

This method iscommunity-maintained by@mmcauliffe

Postgres.app

Download thelatest release with Postgres 15+.

Hosted Postgres

pgvector is available onthese providers.

Upgrading

Install the latest version (use the same method as the original installation). Then in each database you want to upgrade, run:

ALTER EXTENSION vector UPDATE;

You can check the version in the current database with:

SELECT extversion FROM pg_extension WHERE extname = 'vector';

Thanks

Thanks to:

History

View thechangelog

Contributing

Everyone is encouraged to help improve this project. Here are a few ways you can help:

Report bugs
Fix bugs andsubmit pull requests
Write, clarify, or fix documentation
Suggest or add new features

To get started with development:

git clone https://github.com/pgvector/pgvector.gitcd pgvectormakemake install

To run all tests:

make installcheck        # regression testsmake prove_installcheck  # TAP tests

To run single tests:

make installcheck REGRESS=functions                            # regression testmake prove_installcheck PROVE_TESTS=test/t/001_ivfflat_wal.pl  # TAP test

To enable assertions:

make clean && PG_CFLAGS="-DUSE_ASSERT_CHECKING" make && make install

To enable benchmarking:

make clean && PG_CFLAGS="-DIVFFLAT_BENCH" make && make install

To show memory usage:

make clean && PG_CFLAGS="-DHNSW_MEMORY -DIVFFLAT_MEMORY" make && make install

To get k-means metrics:

make clean && PG_CFLAGS="-DIVFFLAT_KMEANS_DEBUG" make && make install

Resources for contributors

Movatterモバイル変換

PGXN

PostgreSQL Extension Network

vector

Extensions

Documentation

README

Contents

pgvector

Installation

Linux and Mac

Windows

Getting Started

Storing

Querying

Distances

Aggregates

Indexing

HNSW

Index Options

Query Options

Index Build Time

Indexing Progress

IVFFlat

Query Options

Index Build Time

Indexing Progress

Filtering

Iterative Index Scans

Iterative Scan Options

HNSW

IVFFlat

Half-Precision Vectors

Half-Precision Indexing

Binary Vectors

Binary Quantization

Sparse Vectors

Hybrid Search

Indexing Subvectors

Performance

Tuning

Loading

Indexing

Querying

Exact Search

Approximate Search

Vacuuming

Monitoring

Scaling

Languages

Frequently Asked Questions

How many vectors can be stored in a single table?

Is replication supported?

What if I want to index vectors with more than 2,000 dimensions?

Can I store vectors with different dimensions in the same column?

Can I store vectors with more precision?

Do indexes need to fit into memory?

Troubleshooting

Why isn’t a query using an index?

Why isn’t a query using a parallel table scan?

Why are there less results for a query after adding an HNSW index?

Why are there less results for a query after adding an IVFFlat index?

Reference

Vector Type

Vector Operators

Vector Functions

Vector Aggregate Functions

Halfvec Type

Halfvec Operators

Halfvec Functions

Halfvec Aggregate Functions

Bit Type

Bit Operators

Bit Functions

Sparsevec Type

Sparsevec Operators

Sparsevec Functions

Installation Notes - Linux and Mac

Postgres Location

Missing Header