langchain.js
    Preparing search index...

    Class MemoryVectorStore

    In-memory, ephemeral vector store.

    Setup: Install langchain:

    npm install langchain
    Instantiate 
    import { MemoryVectorStore } from 'langchain/vectorstores/memory';
    // Or other embeddings
    import { OpenAIEmbeddings } from '@langchain/openai';

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

    const vectorStore = new MemoryVectorStore(embeddings);

    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];

    await vectorStore.addDocuments(documents);

    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 (View Summary)

    Index

    Constructors

    constructor

    Properties

    FilterType memoryVectors similarity

    Methods

    _queryVectors _vectorstoreType addDocuments addVectors maxMarginalRelevanceSearch similaritySearchVectorWithScore fromDocuments fromExistingIndex fromTexts

    Constructors

    Properties

    FilterType: (doc: Document) => boolean
    memoryVectors: MemoryVector[] = []
    similarity: (a: number[], b: number[]) => number

    Type Declaration

      • (a: number[], b: number[]): number

      • Returns the average of cosine distances between vectors a and b

        Parameters

        • a: number[]

          first vector

        • b: number[]

          second vector

        Returns number

    Methods

    Protected_queryVectors

    • _queryVectors(
          query: number[],
          k: number,
          filter?: (doc: Document) => boolean,
      ): Promise<
          {
              content: string;
              embedding: number[];
              id: undefined
              | string;
              index: number;
              metadata: Record<string, any>;
              similarity: number;
          }[],
      >

      Parameters

      • query: number[]
      • k: number
      • Optionalfilter: (doc: Document) => boolean

      Returns Promise<
          {
              content: string;
              embedding: number[];
              id: undefined
              | string;
              index: number;
              metadata: Record<string, any>;
              similarity: number;
          }[],
      >

    _vectorstoreType

    • _vectorstoreType(): string

      Returns string

    • Method to add documents to the memory vector store. It extracts the text from each document, generates embeddings for them, and adds the resulting vectors to the store.

      Parameters

      • documents: Document[]

        Array of Document instances to be added to the store.

      Returns Promise<void>

      Promise that resolves when all documents have been added.

    • Method to add vectors to the memory vector store. It creates MemoryVector instances for each vector and document pair and adds them to the store.

      Parameters

      • vectors: number[][]

        Array of vectors to be added to the store.

      • documents: Document[]

        Array of Document instances corresponding to the vectors.

      Returns Promise<void>

      Promise that resolves when all vectors have been added.

    • Parameters

      • query: string
      • options: MaxMarginalRelevanceSearchOptions<this["FilterType"]>

      Returns Promise<DocumentInterface[]>

    • Method to perform a similarity search in the memory vector store. It calculates the similarity between the query vector and each vector in the store, sorts the results by similarity, and returns the top k results along with their scores.

      Parameters

      • query: number[]

        Query vector to compare against the vectors in the store.

      • k: number

        Number of top results to return.

      • Optionalfilter: (doc: Document) => boolean

        Optional filter function to apply to the vectors before performing 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 MemoryVectorStore instance from an array of Document instances. It adds the documents to the store.

      Parameters

      • docs: Document[]

        Array of Document instances to be added to the store.

      • embeddings: EmbeddingsInterface

        Embeddings instance used to generate embeddings for the documents.

      • OptionaldbConfig: MemoryVectorStoreArgs

        Optional MemoryVectorStoreArgs to configure the MemoryVectorStore instance.

      Returns Promise<MemoryVectorStore>

      Promise that resolves with a new MemoryVectorStore instance.

    • Static method to create a MemoryVectorStore instance from an existing index. It creates a new MemoryVectorStore instance without adding any documents or vectors.

      Parameters

      • embeddings: EmbeddingsInterface

        Embeddings instance used to generate embeddings for the documents.

      • OptionaldbConfig: MemoryVectorStoreArgs

        Optional MemoryVectorStoreArgs to configure the MemoryVectorStore instance.

      Returns Promise<MemoryVectorStore>

      Promise that resolves with a new MemoryVectorStore instance.

    • Static method to create a MemoryVectorStore instance from an array of texts. It creates a Document for each text and metadata pair, and adds them to the store.

      Parameters

      • texts: string[]

        Array of texts to be added to the store.

      • metadatas: object | object[]

        Array or single object of metadata corresponding to the texts.

      • embeddings: EmbeddingsInterface

        Embeddings instance used to generate embeddings for the texts.

      • OptionaldbConfig: MemoryVectorStoreArgs

        Optional MemoryVectorStoreArgs to configure the MemoryVectorStore instance.

      Returns Promise<MemoryVectorStore>

      Promise that resolves with a new MemoryVectorStore instance.

    Settings

    Member Visibility

    On This Page

    Constructor args
    Constructors
    Properties
    Methods