langchain.js
    Preparing search index...

    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
    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", num: 4 } };
    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 filter operators

    Available filter operators: in, notIn, lte, lt, gte, gt, neq

    const resultsWithFilters = await vectorStore.similaritySearch("thud", 1, {
      baz: {
        in: ["bar", "car"],
      },
      num: {
        lte: 10
      }
    });

    for (const doc of resultsWithFilters) {
      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 (View Summary)

    Index

    Constructors

    constructor

    Properties

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

    Accessors

    computedCollectionTableName computedOperatorString computedTableName

    Methods

    _initializeClient _vectorstoreType addDocuments addVectors createHnswIndex delete end ensureCollectionTableInDatabase ensureTableInDatabase getOrCreateCollection maxMarginalRelevanceSearch similaritySearchVectorWithScore fromDocuments fromTexts initialize

    Constructors

    • Parameters

      Returns PGVectorStore

    Properties

    Optional_verbose

    _verbose?: boolean
    chunkSize: number = 500
    client?: PoolClient
    collectionMetadata: null | Metadata
    collectionName: string = "langchain"
    collectionTableName?: string
    contentColumnName: string
    distanceStrategy?: DistanceStrategy = "cosine"
    extensionSchemaName: null | string
    filter?: MetadataFilter
    FilterType: MetadataFilter
    idColumnName: string
    metadataColumnName: string
    pool: Pool
    schemaName: null | string
    skipInitializationCheck: boolean
    tableName: string
    vectorColumnName: string

    Accessors

    • get computedCollectionTableName(): string

      Returns string

    • get computedOperatorString(): string

      Returns string

    • get computedTableName(): string

      Returns string

    Methods

    Protected_initializeClient

    • _initializeClient(): Promise<void>

      Returns Promise<void>

    _vectorstoreType

    • _vectorstoreType(): string

      Returns string

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

      Parameters

      • documents: Document[]

        Array of Document instances.

      • Optionaloptions: { ids?: string[] }

        Optional arguments for adding documents

      Returns Promise<void>

      Promise that resolves when the documents have been added.

    • 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[]

        Array of Document instances.

      • Optionaloptions: { ids?: string[] }

        Optional arguments for adding documents

      Returns Promise<void>

      Promise that resolves when the vectors have been added.

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

      Parameters

      • config: {
            dimensions: number;
            distanceFunction?: string;
            efConstruction?: number;
            m?: number;
            namespace?: string;
        }

      Returns Promise<void>

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

    • 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?: MetadataFilter; ids?: string[] }

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

      Returns Promise<void>

      Promise that resolves when the documents have been deleted.

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

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

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

    • Closes all the clients in the pool and terminates the pool.

      Returns Promise<void>

      Promise that resolves when all clients are closed and the pool is terminated.

    • 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.

    • 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.

    • 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.

    • 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<this["FilterType"]>
        • k=4

          Number of documents to return.

        • fetchK=20

          Number of documents to fetch before passing to the MMR algorithm.

        • lambda=0.5

          Number between 0 and 1 that determines the degree of diversity among the results, where 0 corresponds to maximum diversity and 1 to minimum diversity.

      Returns Promise<Document[]>

      List of documents selected by maximal marginal relevance.

    • 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: MetadataFilter

        Optional filter to apply to the search.

      Returns Promise<[Document, number][]>

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

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

      Parameters

      • docs: Document[]

        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.

    • 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.

    • Static method to create a new PGVectorStore instance from a connection. It creates a table if one does not exist, and calls connect to return a new instance of PGVectorStore.

      Parameters

      • embeddings: EmbeddingsInterface

        Embeddings instance.

      • config: PGVectorStoreArgs & { dimensions?: number }

      Returns Promise<PGVectorStore>

      A new instance of PGVectorStore.

    Settings

    Member Visibility

    On This Page

    Constructor args
    Constructors
    Properties
    Accessors
    Methods