---
title: Indexing Vectors
description: Vectors live alongside text and filters in the ParadeDB index
canonical: https://www.paradedb.com/docs/reference/indexing/indexing-vectors
---
This is a beta feature available in versions `0.25.0` and above. We strongly
recommend `0.27.0` or later for substantial vector search improvements. See
[How Vector Search Works](/concepts/vector/overview) for background.
Make sure the [pgvector](https://github.com/pgvector/pgvector) extension is
installed first. ParadeDB uses pgvector's vector types, but not its HNSW or
IVF indexes.
The ParadeDB index can index pgvector's `vector` type alongside your text and other columns. This lets you combine vector search with full text search and filters in a single index,
which can significantly improve latency/recall for selective queries.
## Creating the Index
The `mock_items` table comes with an `embedding` column of type `vector(8)` populated with sample embeddings.
In this example, `embedding` is added to the ParadeDB index with cosine similarity as the distance function.
```sql SQL
CREATE INDEX search_idx ON mock_items
USING paradedb (id, description, category, embedding vector_cosine_ops);
```
```ts Drizzle
import { indexing } from "@paradedb/drizzle-paradedb";
// In the pgTable definition:
(table) => [
indexing
.paradedbIndex("search_idx")
.on(
table.id,
table.description,
table.category,
indexing.vectorField(table.embedding, "cosine"),
),
];
```
```python Django
from django.db import connection
from paradedb.indexes import ParadeDBIndex
with connection.schema_editor() as schema_editor:
schema_editor.add_index(
MockItem,
ParadeDBIndex(
fields={
"id": {},
"description": {},
"category": {},
"embedding": {"metric": "cosine"},
},
name="search_idx",
),
)
```
```python SQLAlchemy
from sqlalchemy import Index
from paradedb.sqlalchemy import indexing
idx = Index(
"search_idx",
indexing.ParadeDBField(MockItem.id),
indexing.ParadeDBField(MockItem.description),
indexing.ParadeDBField(MockItem.category),
indexing.VectorField(MockItem.embedding, metric="cosine"),
postgresql_using="paradedb",
)
with engine.begin() as conn:
idx.create(conn)
```
```ruby Rails
ActiveRecord::Base.connection.add_paradedb_index(
:mock_items,
fields: {
id: {},
description: {},
category: {},
embedding: { metric: :cosine }
},
name: :search_idx
)
```
```cs EF Core
modelBuilder.Entity()
.HasParadeDbIndex("search_idx", e => e.Id)
.HasField(e => e.Description)
.HasField(e => e.Category)
.HasField(e => e.Embedding, VectorMetric.Cosine);
```
The desired distance function is encoded into the index definition, and cannot be changed without reindexing.
```sql SQL
embedding vector_l2_ops -- L2 (default)
embedding vector_cosine_ops -- cosine
embedding vector_ip_ops -- inner product
```
```ts Drizzle
indexing.vectorField(mockItems.embedding, "l2"); // L2 (default)
indexing.vectorField(mockItems.embedding, "cosine"); // cosine
indexing.vectorField(mockItems.embedding, "ip"); // inner product
```
```python Django
"embedding": {"metric": "l2"} # L2 (default)
"embedding": {"metric": "cosine"} # cosine
"embedding": {"metric": "ip"} # inner product
```
```python SQLAlchemy
indexing.VectorField(MockItem.embedding, metric="l2") # L2 (default)
indexing.VectorField(MockItem.embedding, metric="cosine") # cosine
indexing.VectorField(MockItem.embedding, metric="ip") # inner product
```
```ruby Rails
embedding: { metric: :l2 } # L2 (default)
embedding: { metric: :cosine } # cosine
embedding: { metric: :ip } # inner product
```
```cs EF Core
.HasField(e => e.Embedding, VectorMetric.L2) // L2 (default)
.HasField(e => e.Embedding, VectorMetric.Cosine) // cosine
.HasField(e => e.Embedding, VectorMetric.InnerProduct) // inner product
```
Only pgvector's `vector` type is supported. The `halfvec`, `sparsevec`, and
`bit` types are not yet indexable. Each ParadeDB index currently supports one
vector field, whose dimensions must be declared with `vector(N)`.
If you track index build progress with
[`pg_stat_progress_create_index`](https://www.postgresql.org/docs/current/progress-reporting.html#CREATE-INDEX-PROGRESS-REPORTING),
you may notice progress appear to "stop" at intervals. This is expected:
vectors are clustered with k-means at these points, which is computationally
expensive.
## Index Options
We recommend keeping the defaults, which work well for most workloads. The following options are available for development and debugging.
```sql SQL
CREATE INDEX search_idx ON mock_items
USING paradedb (id, description, category, embedding vector_cosine_ops)
WITH (target_leaf_size=400, replication=2);
```
```ts Drizzle
import { indexing } from "@paradedb/drizzle-paradedb";
indexing
.paradedbIndex("search_idx", {
targetLeafSize: 400,
})
.on(
mockItems.id,
mockItems.description,
mockItems.category,
indexing.vectorField(mockItems.embedding, "cosine"),
);
```
```python Django
from django.db import connection
from paradedb.indexes import ParadeDBIndex
with connection.schema_editor() as schema_editor:
schema_editor.add_index(
MockItem,
ParadeDBIndex(
fields={'id': {}, 'description': {}, 'category': {}, 'embedding': {'metric': 'cosine'}},
name="search_idx",
target_leaf_size=400,
),
)
```
```python SQLAlchemy
from sqlalchemy import Index
from paradedb.sqlalchemy import indexing
idx = Index(
"search_idx",
indexing.ParadeDBField(MockItem.id),
indexing.ParadeDBField(MockItem.description),
indexing.ParadeDBField(MockItem.category),
indexing.VectorField(MockItem.embedding, metric="cosine"),
postgresql_using="paradedb",
postgresql_with={'target_leaf_size': 400},
)
with engine.begin() as conn:
idx.create(conn)
```
```ruby Rails
ActiveRecord::Base.connection.add_paradedb_index(
:mock_items,
fields: {
id: {},
description: {},
category: {},
embedding: { metric: :cosine },
},
name: :search_idx,
index_options: { target_leaf_size: 400 }
)
```
```cs EF Core
modelBuilder.Entity()
.HasParadeDbIndex("search_idx", e => e.Id)
.HasField(e => e.Description)
.HasField(e => e.Category)
.HasField(e => e.Embedding, VectorMetric.Cosine);
```
Fraction of indexed vectors sampled for training whenever a segment is
clustered. `0` chooses the fraction automatically based on available memory.
The target number of indexed vectors in a cluster.
By default, cluster centroids are quantized. This makes them more compact and
faster to search.
ParadeDB uses boundary replication, which means that vectors sitting close to
two clusters are replicated across both. Replication improves recall. A higher
value replicates to more clusters, at the cost of longer index build times and
more storage.
ParadeDB uses two quantization layers by default, each receiving 1 bit per
dimension. Each layer can use up to 4 bits. Set `quantization = 0` to disable
quantization entirely. In our testing, the default `'[1,1]'` delivers the best
performance.