Class PostgresVectorStore

Google Cloud SQL for PostgreSQL vector store integration.

Setup: Install @langchain/google-cloud-sql-pg

npm install @langchain/google-cloud-sql-pg
Instantiate 
import { Column, PostgresEngine, PostgresEngineArgs, PostgresVectorStore, VectorStoreTableArgs } from "@langchain/google-cloud-sql-pg";
// Or other embeddings
import { OpenAIEmbeddings } from '@langchain/openai';


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

const pgArgs: PostgresEngineArgs = {
    user: "db-user",
    password: "password"
}
// Create a shared connection pool
const engine: PostgresEngine = await PostgresEngine.fromInstance(
 "project-id",
 "region",
 "instance-name",
 "database-name",
 pgArgs
);
// (Optional) Specify metadata columns for filtering
// All other metadata will be added to JSON
const vectorStoreTableArgs: VectorStoreTableArgs = {
  metadataColumns: [new Column("baz", "TEXT")],
};
// Create a vector store table
await engine.initVectorstoreTable("my-table", 768, vectorStoreTableArgs);
// Customize the vector store
const pvectorArgs: PostgresVectorStoreArgs = {
    idColumn: "ID_COLUMN",
    contentColumn: "CONTENT_COLUMN",
    embeddingColumn: "EMBEDDING_COLUMN",
    metadataColumns: ["baz"]
}

const vectorStore = await PostgresVectorStore.initialize(engine, embeddingService, "my-table", pvectorArgs);

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

Constructors

constructor

Properties

FilterType contentColumn distanceStrategy embeddingColumn embeddings engine fetchK idColumn indexQueryOptions k lambdaMult metadataColumns metadataJsonColumn schemaName tableName

Methods

addDocuments addVectors applyVectorIndex asRetriever delete dropVectorIndex isValidIndex maxMarginalRelevanceSearch reIndex similaritySearch similaritySearchVectorWithScore similaritySearchWithScore toJSON toJSONNotImplemented fromDocuments fromTexts initialize

Constructors

constructor

Properties

FilterType

FilterType: string

contentColumn

contentColumn: string

distanceStrategy

distanceStrategy: DistanceStrategy

embeddingColumn

embeddingColumn: string

embeddings

embeddings: EmbeddingsInterface

Embeddings interface for generating vector embeddings from text queries, enabling vector-based similarity searches.

engine

engine: PostgresEngine

fetchK

fetchK: number

idColumn

idColumn: string

indexQueryOptions

indexQueryOptions: undefined | QueryOptions

k

k: number

lambdaMult

lambdaMult: number

metadataColumns

metadataColumns: string[]

metadataJsonColumn

metadataJsonColumn: string

schemaName

schemaName: string

tableName

tableName: string

Methods

addDocuments

  • addDocuments(documents, options?): Promise<void | string[]>

  • Adds documents to the vector store, embedding them first through the embeddings instance.

    Parameters

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

      Array of documents to embed and add.

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

      Optional configuration for embedding and storing documents.

      • Optionalids?: string[]

    Returns Promise<void | string[]>

    A promise resolving to an array of document IDs or void, based on implementation.

    Abstract

addVectors

  • addVectors(vectors, documents, options?): Promise<void | string[]>

  • Adds precomputed vectors and corresponding documents to the vector store.

    Parameters

    • vectors: number[][]

      An array of vectors representing each document.

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

      Array of documents associated with each vector.

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

      Optional configuration for adding vectors, such as indexing.

      • Optionalids?: string[]

    Returns Promise<void | string[]>

    A promise resolving to an array of document IDs or void, based on implementation.

    Abstract

applyVectorIndex

asRetriever

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

  • Creates a VectorStoreRetriever instance with flexible configuration options.

    Parameters

    • OptionalkOrFields: number | Partial<VectorStoreRetrieverInput<PostgresVectorStore>>

      If a number is provided, it sets the k parameter (number of items to retrieve).

      • If an object is provided, it should contain various configuration options.
    • Optionalfilter: string

      Optional filter criteria to limit the items retrieved based on the specified filter type.

    • Optionalcallbacks: Callbacks

      Optional callbacks that may be triggered at specific stages of the retrieval process.

    • Optionaltags: string[]

      Tags to categorize or label the VectorStoreRetriever. Defaults to an empty array if not provided.

    • Optionalmetadata: Record<string, unknown>

      Additional metadata as key-value pairs to add contextual information for the retrieval process.

    • Optionalverbose: boolean

      If true, enables detailed logging for the retrieval process. Defaults to false.

    Returns VectorStoreRetriever<PostgresVectorStore>

    • A configured VectorStoreRetriever instance based on the provided parameters.

    Example

    Basic usage with a k value:

    const retriever = myVectorStore.asRetriever(5);

    Usage with a configuration object:

    const retriever = myVectorStore.asRetriever({
      k: 10,
      filter: myFilter,
      tags: ['example', 'test'],
      verbose: true,
      searchType: 'mmr',
      searchKwargs: { alpha: 0.5 },
    });

delete

  • delete(params): Promise<void>

  • Deletes documents from the vector store based on the specified ids.

    Parameters

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

      Flexible key-value pairs defining conditions for document deletion.

      • Optionalids?: string[]

    Returns Promise<void>

    A promise that resolves once the deletion is complete.

dropVectorIndex

isValidIndex

maxMarginalRelevanceSearch

  • maxMarginalRelevanceSearch(query, options): Promise<Document<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<string>

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

    • List of documents selected by maximal marginal relevance.

reIndex

similaritySearch

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

  • Searches for documents similar to a text query by embedding the query and performing a similarity search on the resulting vector.

    Parameters

    • query: string

      Text query for finding similar documents.

    • Optionalk: number

      Number of similar results to return. Defaults to 4.

    • Optionalfilter: string

      Optional filter based on FilterType.

    • Optional_callbacks: Callbacks

      Optional callbacks for monitoring search progress

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

    A promise resolving to an array of DocumentInterface instances representing similar documents.

similaritySearchVectorWithScore

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

  • Performs a similarity search using a vector query and returns results along with their similarity scores.

    Parameters

    • embedding: number[]
    • k: number

      Number of similar results to return.

    • Optionalfilter: string

      Optional filter based on FilterType to restrict results.

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

    A promise resolving to an array of tuples containing documents and their similarity scores.

    Abstract

similaritySearchWithScore

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

  • Searches for documents similar to a text query by embedding the query, and returns results with similarity scores.

    Parameters

    • query: string

      Text query for finding similar documents.

    • Optionalk: number

      Number of similar results to return. Defaults to 4.

    • Optionalfilter: string

      Optional filter based on FilterType.

    • Optional_callbacks: Callbacks

      Optional callbacks for monitoring search progress

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

    A promise resolving to an array of tuples, each containing a document and its similarity score.

toJSON

  • toJSON(): Serialized

  • Returns Serialized

toJSONNotImplemented

StaticfromDocuments

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

  • Creates a VectorStore instance from an array of documents, using the specified embeddings and database configuration.

    Subclasses must implement this method to define how documents are embedded and stored. Throws an error if not overridden.

    Parameters

    • docs: Document<Record<string, any>>[]
    • embeddings: EmbeddingsInterface
    • dbConfig: dbConfigArgs

    Returns Promise<VectorStore>

    A promise that resolves to a new VectorStore instance.

    Throws

    Throws an error if this method is not overridden by a subclass.

StaticfromTexts

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

  • Creates a VectorStore instance from an array of text strings and optional metadata, using the specified embeddings and database configuration.

    Subclasses must implement this method to define how text and metadata are embedded and stored in the vector store. Throws an error if not overridden.

    Parameters

    • texts: string[]
    • metadatas: object | object[]
    • embeddings: EmbeddingsInterface
    • dbConfig: dbConfigArgs

    Returns Promise<VectorStore>

    A promise that resolves to a new VectorStore instance.

    Throws

    Throws an error if this method is not overridden by a subclass.

Staticinitialize

Settings

Member Visibility

On This Page

Constructors
Properties
Methods