pgvector-node

Drizzle ORM 0.31.0+ provides built-in support for vector, halfvec, bit, and sparsevec types. It also includes distance functions like l2Distance and cosineDistance.

import { vector } from 'drizzle-orm/pg-core';
import { l2Distance } from 'drizzle-orm';

const items = pgTable('items', {
  id: serial('id').primaryKey(),
  embedding: vector('embedding', {dimensions: 3})
});

// Insert
await db.insert(items).values([{embedding: [1, 2, 3]}]);

// Query nearest neighbors
const allItems = await db.select()
  .from(items)
  .orderBy(l2Distance(items.embedding, [1, 2, 3]))
  .limit(5);

MikroORM supports pgvector via the VectorType and specialized distance functions like l2Distance.

import { VectorType } from 'pgvector/mikro-orm';
import { l2Distance } from 'pgvector/mikro-orm';

@Entity()
class Item {
  @PrimaryKey()
  id: number;

  @Property({type: VectorType})
  embedding: number[];
}

// Insert
em.create(Item, {embedding: [1, 2, 3]});

// Query nearest neighbors
const items = await em.createQueryBuilder(Item)
  .orderBy({[l2Distance('embedding', [1, 2, 3])]: 'ASC'})
  .limit(5)
  .getResult();

For Deno environments, import the library via npm:pgvector and use queryArray for vector operations.

import pgvector from 'npm:pgvector';

// Enable extension
await client.queryArray`CREATE EXTENSION IF NOT EXISTS vector`;

// Insert
const embedding = pgvector.toSql([1, 2, 3]);
await client.queryArray`INSERT INTO items (embedding) VALUES (${embedding})`;

// Query
const { rows } = await client.queryArray`SELECT * FROM items ORDER BY embedding <-> ${embedding} LIMIT 5`;

To use pgvector-node in your project, install the pgvector package using npm.

npm install pgvector

TypeORM 0.3.27+ has built-in support for pgvector. You can define vector columns using the @Column decorator with the type 'vector' and a specified length.

// Define an entity
@Entity()
class Item {
  @PrimaryGeneratedColumn()
  id: number

  @Column('vector', {length: 3})
  embedding: number[]
}

// Insert a vector
const itemRepository = AppDataSource.getRepository(Item);
await itemRepository.save({embedding: [1, 2, 3]});

// Get nearest neighbors using QueryBuilder
import pgvector from 'pgvector';
const items = await itemRepository
  .createQueryBuilder('item')
  .orderBy('embedding <-> :embedding')
  .setParameters({embedding: pgvector.toSql([1, 2, 3])})
  .limit(5)
  .getMany();

For pg-promise, import pgvector/pg-promise and use the connect option in the initialization to register types on the client.

import pgpromise from 'pg-promise';
import pgvector from 'pgvector/pg-promise';

const initOptions = {
  async connect(e) {
    await pgvector.registerTypes(e.client);
  }
};
const pgp = pgpromise(initOptions);
const db = pgp.connect();

// Enable extension
await db.none('CREATE EXTENSION IF NOT EXISTS vector');

// Insert a vector
await db.none('INSERT INTO items (embedding) VALUES ($1)', [pgvector.toSql([1, 2, 3])]);

// Get nearest neighbors
const result = await db.any('SELECT * FROM items ORDER BY embedding <-> $1 LIMIT 5', [pgvector.toSql([1, 2, 3])]);

With Postgres.js, import pgvector and use pgvector.toSql() to format arrays for insertion and distance queries within template literals.

import pgvector from 'pgvector';

// Enable extension
await sql`CREATE EXTENSION IF NOT EXISTS vector`;

// Create table
await sql`CREATE TABLE items (id bigserial PRIMARY KEY, embedding vector(3))`;

// Insert vectors
const newItems = [
  {embedding: pgvector.toSql([1, 2, 3])},
  {embedding: pgvector.toSql([4, 5, 6])}
];
await sql`INSERT INTO items ${ sql(newItems, 'embedding') }`;

// Get nearest neighbors
const embedding = pgvector.toSql([1, 2, 3]);
const items = await sql`SELECT * FROM items ORDER BY embedding <-> ${ embedding } LIMIT 5`;

// Add an approximate index
await sql`CREATE INDEX ON items USING hnsw (embedding vector_l2_ops)`;

To use pgvector with Slonik, import the library, enable the extension using sql.unsafe, and use pgvector.toSql() to format arrays for insertion or distance queries.

import pgvector from 'pgvector';

// Enable the extension
await pool.query(sql.unsafe`CREATE EXTENSION IF NOT EXISTS vector`);

// Create a table
await pool.query(sql.unsafe`CREATE TABLE items (id serial PRIMARY KEY, embedding vector(3))`);

// Insert a vector
const embedding = pgvector.toSql([1, 2, 3]);
await pool.query(sql.unsafe`INSERT INTO items (embedding) VALUES (${embedding})`);

// Get the nearest neighbors
const items = await pool.query(sql.unsafe`SELECT * FROM items ORDER BY embedding <-> ${embedding} LIMIT 5`);

// Add an approximate index
await pool.query(sql.unsafe`CREATE INDEX ON items USING hnsw (embedding vector_l2_ops)`);

When using Bun SQL, import pgvector and use pgvector.toSql() to prepare arrays for insertion or distance-based ordering.

import pgvector from 'pgvector';

// Insert multiple
const newItems = [
  {embedding: pgvector.toSql([1, 2, 3])},
  {embedding: pgvector.toSql([4, 5, 6])}
];
await sql`INSERT INTO items ${sql(newItems)}`;

// Query
const embedding = pgvector.toSql([1, 2, 3]);
const items = await sql`SELECT * FROM items ORDER BY embedding <-> ${embedding} LIMIT 5`.values();