Skip to main content

​
Overview

A vector store stores embedded data and performs similarity search.

​
Interface

LangChain provides a unified interface for vector stores, allowing you to:
  • addDocuments - Add documents to the store.
  • delete - Remove stored documents by ID.
  • similaritySearch - Query for semantically similar documents.
This abstraction lets you switch between different implementations without altering your application logic.

​
Initialization

Most vectorstores in LangChain accept an embedding model as an argument when initializing the vector store. 
import { OpenAIEmbeddings } from "@langchain/openai";
import { MemoryVectorStore } from "@langchain/classic/vectorstores/memory";

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

​
Adding docuemnts

You can add documents to the vector store by using the addDocuments function. 
import { Document } from "@langchain/core/documents";
const document = new Document({
  pageContent: "Hello world",
});
await vectorStore.addDocuments([document]);

​
Deleting documents

You can delete documents from the vector store by using the delete function. 
await vectorStore.delete({
  filter: {
    pageContent: "Hello world",
  },
});
Issue a semantic query using similaritySearch, which returns the closest embedded documents: 
const results = await vectorStore.similaritySearch("Hello world", 10);
Many vector stores support parameters like:
  • k — number of results to return
  • filter — conditional filtering based on metadata

​
Similarity metrics & indexing

Embedding similarity may be computed using:
  • Cosine similarity
  • Euclidean distance
  • Dot product
Efficient search often employs indexing methods such as HNSW (Hierarchical Navigable Small World), though specifics depend on the vector store.

​
Metadata filtering

Filtering by metadata (e.g., source, date) can refine search results: 
vectorStore.similaritySearch("query", 2, { source: "tweets" });

​
Top integrations

Select embedding model:
Install dependencies:
npm i @langchain/openai
Add environment variables:
OPENAI_API_KEY=your-api-key
Instantiate the model:
import { OpenAIEmbeddings } from "@langchain/openai";

const embeddings = new OpenAIEmbeddings({
  model: "text-embedding-3-large"
});
Install dependencies
npm i @langchain/openai
Add environment variables:
AZURE_OPENAI_API_INSTANCE_NAME=<YOUR_INSTANCE_NAME>
AZURE_OPENAI_API_KEY=<YOUR_KEY>
AZURE_OPENAI_API_VERSION="2024-02-01"
Instantiate the model:
import { AzureOpenAIEmbeddings } from "@langchain/openai";

const embeddings = new AzureOpenAIEmbeddings({
  azureOpenAIApiEmbeddingsDeploymentName: "text-embedding-ada-002"
});
Install dependencies:
npm i @langchain/aws
Add environment variables:
BEDROCK_AWS_REGION=your-region
Instantiate the model:
import { BedrockEmbeddings } from "@langchain/aws";

const embeddings = new BedrockEmbeddings({
  model: "amazon.titan-embed-text-v1"
});
Install dependencies:
npm i @langchain/google-genai
Add environment variables:
GOOGLE_API_KEY=your-api-key
Instantiate the model:
import { GoogleGenerativeAIEmbeddings } from "@langchain/google-genai";

const embeddings = new GoogleGenerativeAIEmbeddings({
  model: "text-embedding-004"
});
Install dependencies:
npm i @langchain/google-vertexai
Add environment variables:
GOOGLE_APPLICATION_CREDENTIALS=credentials.json
Instantiate the model:
import { VertexAIEmbeddings } from "@langchain/google-vertexai";

const embeddings = new VertexAIEmbeddings({
  model: "gemini-embedding-001"
});
Install dependencies:
npm i @langchain/mistralai
Add environment variables:
MISTRAL_API_KEY=your-api-key
Instantiate the model:
import { MistralAIEmbeddings } from "@langchain/mistralai";

const embeddings = new MistralAIEmbeddings({
  model: "mistral-embed"
});
Install dependencies:
npm i @langchain/cohere
Add environment variables:
COHERE_API_KEY=your-api-key
Instantiate the model:
import { CohereEmbeddings } from "@langchain/cohere";

const embeddings = new CohereEmbeddings({
  model: "embed-english-v3.0"
});
Install dependencies:
npm i @langchain/ollama
Instantiate the model:
import { OllamaEmbeddings } from "@langchain/ollama";

const embeddings = new OllamaEmbeddings({
  model: "llama2",
  baseUrl: "http://localhost:11434", // Default value
});
Select vector store: 
npm i langchain

import { MemoryVectorStore } from "@langchain/classic/vectorstores/memory";

const vectorStore = new MemoryVectorStore(embeddings);

npm i @langchain/community

import { Chroma } from "@langchain/community/vectorstores/chroma";

const vectorStore = new Chroma(embeddings, {
  collectionName: "a-test-collection",
});

npm i @langchain/community

import { FaissStore } from "@langchain/community/vectorstores/faiss";

const vectorStore = new FaissStore(embeddings, {});

npm i @langchain/mongodb

import { MongoDBAtlasVectorSearch } from "@langchain/mongodb"
import { MongoClient } from "mongodb";

const client = new MongoClient(process.env.MONGODB_ATLAS_URI || "");
const collection = client
  .db(process.env.MONGODB_ATLAS_DB_NAME)
  .collection(process.env.MONGODB_ATLAS_COLLECTION_NAME);

const vectorStore = new MongoDBAtlasVectorSearch(embeddings, {
  collection,
  indexName: "vector_index",
  textKey: "text",
  embeddingKey: "embedding",
});

npm i @langchain/community

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

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

npm i @langchain/pinecone

import { PineconeStore } from "@langchain/pinecone";
import { Pinecone as PineconeClient } from "@pinecone-database/pinecone";

const pinecone = new PineconeClient();
const vectorStore = new PineconeStore(embeddings, {
  pineconeIndex,
  maxConcurrency: 5,
});

npm i @langchain/qdrant

import { QdrantVectorStore } from "@langchain/qdrant";

const vectorStore = await QdrantVectorStore.fromExistingCollection(embeddings, {
  url: process.env.QDRANT_URL,
  collectionName: "langchainjs-testing",
});
LangChain.js integrates with a variety of vector stores. You can check out a full list below:

​
All vector stores

AnalyticDB

Astra DB

Azion EdgeSQL

Azure AI Search

Azure Cosmos DB for MongoDB vCore

Azure Cosmos DB for NoSQL

Cassandra

Chroma

ClickHouse

CloseVector

Cloudflare Vectorize

Convex

Couchbase

Elasticsearch

Faiss

Google Cloud SQL for PostgreSQL

Google Vertex AI Matching Engine

SAP HANA Cloud Vector Engine

HNSWLib

LanceDB

libSQL

MariaDB

In-memory

Milvus

Momento Vector Index (MVI)

MongoDB Atlas

MyScale

Neo4j Vector Index

Neon Postgres

OpenSearch

PGVector

Pinecone

Prisma

Qdrant

Redis

Rockset

SingleStore

Supabase

Tigris

Turbopuffer

TypeORM

Typesense

Upstash Vector

USearch

Vectara

Vercel Postgres

Voy

Weaviate

Xata

Zep Open Source

Zep Cloud

Edit the source of this page on GitHub.
Connect these docs programmatically to Claude, VSCode, and more via MCP for real-time answers.