> ## Documentation Index
> Fetch the complete documentation index at: https://langchain-5e9cc07a-preview-docscl-1781043860-248c713.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# MemoryVectorStore integration
> Integrate with the MemoryVectorStore using LangChain JavaScript.
LangChain offers is an in-memory, ephemeral vectorstore that stores embeddings in-memory and does an exact, linear search for the most similar embeddings. The default similarity metric is cosine similarity, but can be changed to any of the similarity metrics supported by [ml-distance](https://mljs.github.io/distance/modules/similarity.html).
As it is intended for demos, it does not yet support ids or deletion.
This guide provides a quick overview for getting started with `MemoryVectorStore` [vector stores](/oss/javascript/integrations/vectorstores).
## Overview
### Integration details
| Class | Package | PY support | Version |
| :------------------ | :----------------------------------------------------- | :--------: | :------------------------------------------------------------------------------------: |
| `MemoryVectorStore` | [`langchain`](https://www.npmjs.com/package/langchain) | ❌ |  |
## Setup
To use in-memory vector stores, you'll need to install the `langchain` package:
This guide will also use [OpenAI embeddings](/oss/javascript/integrations/embeddings/openai), which require you to install the `@langchain/openai` integration package. You can also use [other supported embeddings models](/oss/javascript/integrations/embeddings) if you wish.
```bash npm theme={null}
npm install langchain @langchain/openai @langchain/core
```
```bash yarn theme={null}
yarn add langchain @langchain/openai @langchain/core
```
```bash pnpm theme={null}
pnpm add langchain @langchain/openai @langchain/core
```
### Credentials
There are no required credentials to use in-memory vector stores.
If you are using OpenAI embeddings for this guide, you'll need to set your OpenAI key as well:
```typescript theme={null}
process.env.OPENAI_API_KEY = "YOUR_API_KEY";
```
If you want to get automated tracing of your model calls you can also set your [LangSmith](/langsmith/home) API key by uncommenting below:
```typescript theme={null}
// process.env.LANGSMITH_TRACING="true"
// process.env.LANGSMITH_API_KEY="your-api-key"
```
## Instantiation
```typescript theme={null}
import { MemoryVectorStore } from "@langchain/classic/vectorstores/memory";
import { OpenAIEmbeddings } from "@langchain/openai";
const embeddings = new OpenAIEmbeddings({
model: "text-embedding-3-small",
});
const vectorStore = new MemoryVectorStore(embeddings);
```
## Manage vector store
### Add items to vector store
```typescript theme={null}
import type { Document } from "@langchain/core/documents";
const document1: Document = {
pageContent: "The powerhouse of the cell is the mitochondria",
metadata: { source: "https://example.com" }
};
const document2: Document = {
pageContent: "Buildings are made out of brick",
metadata: { source: "https://example.com" }
};
const document3: Document = {
pageContent: "Mitochondria are made out of lipids",
metadata: { source: "https://example.com" }
};
const documents = [document1, document2, document3];
await vectorStore.addDocuments(documents);
```
## Query vector store
Once your vector store has been created and the relevant documents have been added you will most likely wish to query it during the running of your chain or agent.
### Query directly
Performing a simple similarity search can be done as follows:
```typescript theme={null}
const filter = (doc) => doc.metadata.source === "https://example.com";
const similaritySearchResults = await vectorStore.similaritySearch("biology", 2, filter)
for (const doc of similaritySearchResults) {
console.log(`* ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);
}
```
```text theme={null}
* The powerhouse of the cell is the mitochondria [{"source":"https://example.com"}]
* Mitochondria are made out of lipids [{"source":"https://example.com"}]
```
The filter is optional, and must be a predicate function that takes a document as input, and returns `true` or `false` depending on whether the document should be returned.
If you want to execute a similarity search and receive the corresponding scores you can run:
```typescript theme={null}
const similaritySearchWithScoreResults = await vectorStore.similaritySearchWithScore("biology", 2, filter)
for (const [doc, score] of similaritySearchWithScoreResults) {
console.log(`* [SIM=${score.toFixed(3)}] ${doc.pageContent} [${JSON.stringify(doc.metadata)}]`);
}
```
```text theme={null}
* [SIM=0.165] The powerhouse of the cell is the mitochondria [{"source":"https://example.com"}]
* [SIM=0.148] Mitochondria are made out of lipids [{"source":"https://example.com"}]
```
### Query by turning into retriever
You can also transform the vector store into a [retriever](/oss/javascript/langchain/retrieval) for easier usage in your chains:
```typescript theme={null}
const retriever = vectorStore.asRetriever({
// Optional filter
filter: filter,
k: 2,
});
await retriever.invoke("biology");
```
```javascript theme={null}
[
Document {
pageContent: 'The powerhouse of the cell is the mitochondria',
metadata: { source: 'https://example.com' },
id: undefined
},
Document {
pageContent: 'Mitochondria are made out of lipids',
metadata: { source: 'https://example.com' },
id: undefined
}
]
```
### Maximal marginal relevance
This vector store also supports maximal marginal relevance (MMR), a technique that first fetches a larger number of results (given by `searchKwargs.fetchK`), with classic similarity search, then reranks for diversity and returns the top `k` results. This helps guard against redundant information:
```typescript theme={null}
const mmrRetriever = vectorStore.asRetriever({
searchType: "mmr",
searchKwargs: {
fetchK: 10,
},
// Optional filter
filter: filter,
k: 2,
});
await mmrRetriever.invoke("biology");
```
```javascript theme={null}
[
Document {
pageContent: 'The powerhouse of the cell is the mitochondria',
metadata: { source: 'https://example.com' },
id: undefined
},
Document {
pageContent: 'Buildings are made out of brick',
metadata: { source: 'https://example.com' },
id: undefined
}
]
```
### Usage for retrieval-augmented generation
For guides on how to use this vector store for retrieval-augmented generation (RAG), see the following sections:
* [Build a RAG app with LangChain](/oss/javascript/langchain/rag).
* [Agentic RAG](/oss/javascript/langgraph/agentic-rag)
* [Retrieval docs](/oss/javascript/langchain/retrieval)
***
***
[Connect these docs](/use-these-docs) to Claude, VSCode, and more via MCP for real-time answers.
[Edit this page on GitHub](https://github.com/langchain-ai/docs/edit/main/src/oss/javascript/integrations/vectorstores/memory.mdx) or [file an issue](https://github.com/langchain-ai/docs/issues/new/choose).