Class PGVectorStore

PGVector vector store integration.

Setup: Install @langchain/community and pg.

If you wish to generate ids, you should also install the uuid package.

npm install @langchain/community pg uuid

Constructor args

Instantiate 
import {
  PGVectorStore,
  DistanceStrategy,
} from "@langchain/community/vectorstores/pgvector";

// Or other embeddings
import { OpenAIEmbeddings } from "@langchain/openai";
import { PoolConfig } from "pg";

const embeddings = new OpenAIEmbeddings({
  model: "text-embedding-3-small",
});

// Sample config
const config = {
  postgresConnectionOptions: {
    type: "postgres",
    host: "127.0.0.1",
    port: 5433,
    user: "myuser",
    password: "ChangeMe",
    database: "api",
  } as PoolConfig,
  tableName: "testlangchainjs",
  columns: {
    idColumnName: "id",
    vectorColumnName: "vector",
    contentColumnName: "content",
    metadataColumnName: "metadata",
  },
  // supported distance strategies: cosine (default), innerProduct, or euclidean
  distanceStrategy: "cosine" as DistanceStrategy,
};

const vectorStore = await PGVectorStore.initialize(embeddings, config);

Add documents 
import type { Document } from '@langchain/core/documents';

const document1 = { pageContent: "foo", metadata: { baz: "bar" } };
const document2 = { pageContent: "thud", metadata: { bar: "baz" } };
const document3 = { pageContent: "i will be deleted :(", metadata: {} };

const documents: Document[] = [document1, document2, document3];
const ids = ["1", "2", "3"];
await vectorStore.addDocuments(documents, { ids });

Delete documents 
await vectorStore.delete({ ids: ["3"] });

Similarity search 
const results = await vectorStore.similaritySearch("thud", 1);
for (const doc of results) {
  console.log(`* ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);
}
// Output: * thud [{"baz":"bar"}]

Similarity search with filter 
const resultsWithFilter = await vectorStore.similaritySearch("thud", 1, { baz: "bar" });

for (const doc of resultsWithFilter) {
  console.log(`* ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);
}
// Output: * foo [{"baz":"bar"}]

Similarity search with score 
const resultsWithScore = await vectorStore.similaritySearchWithScore("qux", 1);
for (const [doc, score] of resultsWithScore) {
  console.log(`* [SIM=${score.toFixed(6)}] ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);
}
// Output: * [SIM=0.000000] qux [{"bar":"baz","baz":"bar"}]

As a retriever 
const retriever = vectorStore.asRetriever({
  searchType: "mmr", // Leave blank for standard similarity search
  k: 1,
});
const resultAsRetriever = await retriever.invoke("thud");
console.log(resultAsRetriever);

// Output: [Document({ metadata: { "baz":"bar" }, pageContent: "thud" })]

Hierarchy

  • VectorStore
    • PGVectorStore

Constructors

constructor

Properties

FilterType chunkSize client? collectionMetadata collectionName collectionTableName? contentColumnName distanceStrategy? embeddings extensionSchemaName filter? idColumnName metadataColumnName pool schemaName tableName vectorColumnName

Accessors

computedCollectionTableName computedOperatorString computedTableName

Methods

addDocuments addVectors asRetriever createHnswIndex delete end ensureCollectionTableInDatabase ensureTableInDatabase getOrCreateCollection maxMarginalRelevanceSearch? similaritySearch similaritySearchVectorWithScore similaritySearchWithScore toJSON toJSONNotImplemented fromDocuments fromTexts initialize

Constructors

constructor

Properties

FilterType

FilterType: Metadata

chunkSize

chunkSize: number = 500

Optionalclient

client?: PoolClient

collectionMetadata

collectionMetadata: null | Metadata

collectionName

collectionName: string = "langchain"

OptionalcollectionTableName

collectionTableName?: string

contentColumnName

contentColumnName: string

OptionaldistanceStrategy

distanceStrategy?: DistanceStrategy = "cosine"

embeddings

embeddings: EmbeddingsInterface

extensionSchemaName

extensionSchemaName: null | string

Optionalfilter

filter?: Metadata

idColumnName

idColumnName: string

metadataColumnName

metadataColumnName: string

pool

pool: Pool

schemaName

schemaName: null | string

tableName

tableName: string

vectorColumnName

vectorColumnName: string

Accessors

computedCollectionTableName

computedOperatorString

computedTableName

Methods

addDocuments

  • addDocuments(documents, options?): Promise<void>

  • Method to add documents to the vector store. It converts the documents into vectors, and adds them to the store.

    Parameters

    • documents: Document<Record<string, any>>[]

      Array of Document instances.

    • Optionaloptions: {
          ids?: string[];
      }

      Optional arguments for adding documents

      • Optionalids?: string[]

    Returns Promise<void>

    Promise that resolves when the documents have been added.

addVectors

  • addVectors(vectors, documents, options?): Promise<void>

  • Method to add vectors to the vector store. It converts the vectors into rows and inserts them into the database.

    Parameters

    • vectors: number[][]

      Array of vectors.

    • documents: Document<Record<string, any>>[]

      Array of Document instances.

    • Optionaloptions: {
          ids?: string[];
      }

      Optional arguments for adding documents

      • Optionalids?: string[]

    Returns Promise<void>

    Promise that resolves when the vectors have been added.

asRetriever

  • asRetriever(kOrFields?, filter?, callbacks?, tags?, metadata?, verbose?): VectorStoreRetriever<PGVectorStore>

  • Parameters

    • OptionalkOrFields: number | Partial<VectorStoreRetrieverInput<PGVectorStore>>
    • Optionalfilter: Metadata
    • Optionalcallbacks: Callbacks
    • Optionaltags: string[]
    • Optionalmetadata: Record<string, unknown>
    • Optionalverbose: boolean

    Returns VectorStoreRetriever<PGVectorStore>

createHnswIndex

  • createHnswIndex(config): Promise<void>

  • Method to create the HNSW index on the vector column.

    Parameters

    • config: {
          dimensions: number;
          distanceFunction?: string;
          efConstruction?: number;
          m?: number;
          namespace?: string;
      }
      • dimensions: number
      • OptionaldistanceFunction?: string
      • OptionalefConstruction?: number
      • Optionalm?: number
      • Optionalnamespace?: string

    Returns Promise<void>

    Promise that resolves with the query response of creating the index.

delete

  • delete(params): Promise<void>

  • Method to delete documents from the vector store. It deletes the documents that match the provided ids or metadata filter. Matches ids exactly and metadata filter according to postgres jsonb containment. Ids and filter are mutually exclusive.

    Parameters

    • params: {
          filter?: Metadata;
          ids?: string[];
      }

      Object containing either an array of ids or a metadata filter object.

      • Optionalfilter?: Metadata
      • Optionalids?: string[]

    Returns Promise<void>

    Promise that resolves when the documents have been deleted.

    Throws

    Error if neither ids nor filter are provided, or if both are provided.

    Example: Delete by ids

    await vectorStore.delete({ ids: ["id1", "id2"] });

    Example: Delete by filter

    await vectorStore.delete({ filter: { a: 1, b: 2 } });

end

ensureCollectionTableInDatabase

  • ensureCollectionTableInDatabase(): Promise<void>

  • Method to ensure the existence of the collection table in the database. It creates the table if it does not already exist.

    Returns Promise<void>

    Promise that resolves when the collection table has been ensured.

ensureTableInDatabase

  • ensureTableInDatabase(dimensions?): Promise<void>

  • Method to ensure the existence of the table in the database. It creates the table if it does not already exist.

    Parameters

    • Optionaldimensions: number

      Number of dimensions in your vector data type. For example, use 1536 for OpenAI's text-embedding-3-small. If not set, indexes like HNSW might not be used during query time.

    Returns Promise<void>

    Promise that resolves when the table has been ensured.

getOrCreateCollection

  • getOrCreateCollection(): Promise<string>

  • Inserts a row for the collectionName provided at initialization if it does not exist and returns the collectionId.

    Returns Promise<string>

    The collectionId for the given collectionName.

OptionalmaxMarginalRelevanceSearch

  • maxMarginalRelevanceSearch(query, options, _callbacks): Promise<DocumentInterface<Record<string, any>>[]>

  • Return documents selected using the maximal marginal relevance. Maximal marginal relevance optimizes for similarity to the query AND diversity among selected documents.

    Parameters

    • query: string

      Text to look up documents similar to.

    • options: MaxMarginalRelevanceSearchOptions<Metadata>
    • _callbacks: undefined | Callbacks

    Returns Promise<DocumentInterface<Record<string, any>>[]>

    • List of documents selected by maximal marginal relevance.

similaritySearch

  • similaritySearch(query, k?, filter?, _callbacks?): Promise<DocumentInterface<Record<string, any>>[]>

  • Parameters

    • query: string
    • Optionalk: number
    • Optionalfilter: Metadata
    • Optional_callbacks: Callbacks

    Returns Promise<DocumentInterface<Record<string, any>>[]>

similaritySearchVectorWithScore

  • similaritySearchVectorWithScore(query, k, filter?): Promise<[Document<Record<string, any>>, number][]>

  • Method to perform a similarity search in the vector store. It returns the k most similar documents to the query vector, along with their similarity scores.

    Parameters

    • query: number[]

      Query vector.

    • k: number

      Number of most similar documents to return.

    • Optionalfilter: Metadata

      Optional filter to apply to the search.

    Returns Promise<[Document<Record<string, any>>, number][]>

    Promise that resolves with an array of tuples, each containing a Document and its similarity score.

similaritySearchWithScore

  • similaritySearchWithScore(query, k?, filter?, _callbacks?): Promise<[DocumentInterface<Record<string, any>>, number][]>

  • Parameters

    • query: string
    • Optionalk: number
    • Optionalfilter: Metadata
    • Optional_callbacks: Callbacks

    Returns Promise<[DocumentInterface<Record<string, any>>, number][]>

toJSON

  • toJSON(): Serialized

  • Returns Serialized

toJSONNotImplemented

StaticfromDocuments

  • fromDocuments(docs, embeddings, dbConfig): Promise<PGVectorStore>

  • Static method to create a new PGVectorStore instance from an array of Document instances. It adds the documents to the store.

    Parameters

    • docs: Document<Record<string, any>>[]

      Array of Document instances.

    • embeddings: EmbeddingsInterface

      Embeddings instance.

    • dbConfig: PGVectorStoreArgs & {
          dimensions?: number;
      }

      PGVectorStoreArgs instance.

    Returns Promise<PGVectorStore>

    Promise that resolves with a new instance of PGVectorStore.

StaticfromTexts

  • fromTexts(texts, metadatas, embeddings, dbConfig): Promise<PGVectorStore>

  • Static method to create a new PGVectorStore instance from an array of texts and their metadata. It converts the texts into Document instances and adds them to the store.

    Parameters

    • texts: string[]

      Array of texts.

    • metadatas: object | object[]

      Array of metadata objects or a single metadata object.

    • embeddings: EmbeddingsInterface

      Embeddings instance.

    • dbConfig: PGVectorStoreArgs & {
          dimensions?: number;
      }

      PGVectorStoreArgs instance.

    Returns Promise<PGVectorStore>

    Promise that resolves with a new instance of PGVectorStore.

Staticinitialize

Settings

Member Visibility

On This Page

Constructor args
Constructors
Properties
Accessors
Methods