Vector store integrations

Overview

A vector stores embedded data and performs similarity search.

Interface

LangChain provides a unified interface for vector stores, allowing you to:

add_documents - Add documents to the store.
delete - Remove stored documents by ID.
similarity_search - Query for semantically similar documents.

This abstraction lets you switch between different implementations without altering your application logic.

Initialization

To initialize a vector store, provide it with an embedding model:

from langchain_core.vectorstores import InMemoryVectorStore
vector_store = InMemoryVectorStore(embedding=SomeEmbeddingModel())

Adding documents

Add Document objects (holding page_content and optional metadata) like so:

vector_store.add_documents(documents=[doc1, doc2], ids=["id1", "id2"])

Deleting documents

Delete by specifying IDs:

vector_store.delete(ids=["id1"])

Similarity search

Issue a semantic query using similarity_search, which returns the closest embedded documents:

similar_docs = vector_store.similarity_search("your query here")

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:

vector_store.similarity_search(
  "query",
  k=3,
  filter={"source": "tweets"}
)

Top integrations

Select embedding model:

OpenAI

pip install -qU langchain-openai

uv add langchain-openai

import getpass
import os

if not os.environ.get("OPENAI_API_KEY"):
  os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter API key for OpenAI: ")

from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(model="text-embedding-3-large")

Azure

pip install -qU langchain-azure-ai

import getpass
import os

if not os.environ.get("AZURE_OPENAI_API_KEY"):
  os.environ["AZURE_OPENAI_API_KEY"] = getpass.getpass("Enter API key for Azure: ")

from langchain_openai import AzureOpenAIEmbeddings

embeddings = AzureOpenAIEmbeddings(
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    azure_deployment=os.environ["AZURE_OPENAI_DEPLOYMENT_NAME"],
    openai_api_version=os.environ["AZURE_OPENAI_API_VERSION"],
)

Google Gemini

pip install -qU langchain-google-genai

import getpass
import os

if not os.environ.get("GOOGLE_API_KEY"):
  os.environ["GOOGLE_API_KEY"] = getpass.getpass("Enter API key for Google Gemini: ")

from langchain_google_genai import GoogleGenerativeAIEmbeddings

embeddings = GoogleGenerativeAIEmbeddings(model="models/gemini-embedding-001")

Gemini Enterprise Agent Platform

pip install -qU langchain-google-vertexai

from langchain_google_vertexai import VertexAIEmbeddings

embeddings = VertexAIEmbeddings(model="text-embedding-005")

AWS

pip install -qU langchain-aws

from langchain_aws import BedrockEmbeddings

embeddings = BedrockEmbeddings(model_id="amazon.titan-embed-text-v2:0")

HuggingFace

pip install -qU langchain-huggingface

from langchain_huggingface import HuggingFaceEmbeddings

embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")

Ollama

pip install -qU langchain-ollama

from langchain_ollama import OllamaEmbeddings

embeddings = OllamaEmbeddings(model="nomic-embed-text")

Cohere

pip install -qU langchain-cohere

import getpass
import os

if not os.environ.get("COHERE_API_KEY"):
  os.environ["COHERE_API_KEY"] = getpass.getpass("Enter API key for Cohere: ")

from langchain_cohere import CohereEmbeddings

embeddings = CohereEmbeddings(model="embed-english-v3.0")

Mistral AI

pip install -qU langchain-mistralai

import getpass
import os

if not os.environ.get("MISTRALAI_API_KEY"):
  os.environ["MISTRALAI_API_KEY"] = getpass.getpass("Enter API key for MistralAI: ")

from langchain_mistralai import MistralAIEmbeddings

embeddings = MistralAIEmbeddings(model="mistral-embed")

Nomic

pip install -qU langchain-nomic

import getpass
import os

if not os.environ.get("NOMIC_API_KEY"):
  os.environ["NOMIC_API_KEY"] = getpass.getpass("Enter API key for Nomic: ")

from langchain_nomic import NomicEmbeddings

embeddings = NomicEmbeddings(model="nomic-embed-text-v1.5")

NVIDIA

pip install -qU langchain-nvidia-ai-endpoints

import getpass
import os

if not os.environ.get("NVIDIA_API_KEY"):
  os.environ["NVIDIA_API_KEY"] = getpass.getpass("Enter API key for NVIDIA: ")

from langchain_nvidia_ai_endpoints import NVIDIAEmbeddings

embeddings = NVIDIAEmbeddings(model="NV-Embed-QA")

Voyage AI

pip install -qU langchain-voyageai

import getpass
import os

if not os.environ.get("VOYAGE_API_KEY"):
  os.environ["VOYAGE_API_KEY"] = getpass.getpass("Enter API key for Voyage AI: ")

from langchain_voyageai import VoyageAIEmbeddings

embeddings = VoyageAIEmbeddings(model="voyage-3")

For more information, see the Voyage AI documentation.

IBM watsonx

pip install -qU langchain-ibm

import getpass
import os

if not os.environ.get("WATSONX_APIKEY"):
  os.environ["WATSONX_APIKEY"] = getpass.getpass("Enter API key for IBM watsonx: ")

from langchain_ibm import WatsonxEmbeddings

embeddings = WatsonxEmbeddings(
    model_id="ibm/slate-125m-english-rtrvr",
    url="https://us-south.ml.cloud.ibm.com",
    project_id="<WATSONX PROJECT_ID>",
)

Fake

pip install -qU langchain-core

from langchain_core.embeddings import DeterministicFakeEmbedding

embeddings = DeterministicFakeEmbedding(size=4096)

xAI

pip install -qU langchain-xai

import getpass
import os

if not os.environ.get("XAI_API_KEY"):
  os.environ["XAI_API_KEY"] = getpass.getpass("Enter API key for xAI: ")

from langchain.chat_models import init_chat_model

model = init_chat_model("grok-2", model_provider="xai")

Perplexity

pip install -qU langchain-perplexity

import getpass
import os

if not os.environ.get("PPLX_API_KEY"):
  os.environ["PPLX_API_KEY"] = getpass.getpass("Enter API key for Perplexity: ")

from langchain.chat_models import init_chat_model

model = init_chat_model("llama-3.1-sonar-small-128k-online", model_provider="perplexity")

DeepSeek

pip install -qU langchain-deepseek

import getpass
import os

if not os.environ.get("DEEPSEEK_API_KEY"):
  os.environ["DEEPSEEK_API_KEY"] = getpass.getpass("Enter API key for DeepSeek: ")

from langchain.chat_models import init_chat_model

model = init_chat_model("deepseek-chat", model_provider="deepseek")

Select vector store:

In-memory

pip install -qU langchain-core

uv add langchain-core

from langchain_core.vectorstores import InMemoryVectorStore

vector_store = InMemoryVectorStore(embeddings)

Amazon OpenSearch

pip

pip install -qU boto3

from opensearchpy import RequestsHttpConnection

service = "es"  # must set the service as 'es'
region = "us-east-2"
credentials = boto3.Session(
    aws_access_key_id="xxxxxx", aws_secret_access_key="xxxxx"
).get_credentials()
awsauth = AWS4Auth("xxxxx", "xxxxxx", region, service, session_token=credentials.token)

vector_store = OpenSearchVectorSearch.from_documents(
    docs,
    embeddings,
    opensearch_url="host url",
    http_auth=awsauth,
    timeout=300,
    use_ssl=True,
    verify_certs=True,
    connection_class=RequestsHttpConnection,
    index_name="test-index",
)

Astra DB

pip install -qU langchain-astradb

uv add langchain-astradb

from langchain_astradb import AstraDBVectorStore

vector_store = AstraDBVectorStore(
    embedding=embeddings,
    api_endpoint=ASTRA_DB_API_ENDPOINT,
    collection_name="astra_vector_langchain",
    token=ASTRA_DB_APPLICATION_TOKEN,
    namespace=ASTRA_DB_NAMESPACE,
)

Azure Cosmos DB NoSQL

pip install -qU langchain-azure-cosmosdb azure-cosmos

uv add langchain-azure-cosmosdb azure-cosmos

from langchain_azure_cosmosdb import AzureCosmosDBNoSqlVectorSearch

vector_search = AzureCosmosDBNoSqlVectorSearch.from_documents(
    documents=docs,
    embedding=openai_embeddings,
    cosmos_client=cosmos_client,
    database_name=database_name,
    container_name=container_name,
    vector_embedding_policy=vector_embedding_policy,
    full_text_policy=full_text_policy,
    indexing_policy=indexing_policy,
    cosmos_container_properties=cosmos_container_properties,
    cosmos_database_properties={},
    full_text_search_enabled=True,
)

Azure Cosmos DB Mongo vCore

pip install -qU langchain-azure-ai pymongo

uv add pymongo

from langchain_azure_ai.vectorstores.azure_cosmos_db_mongo_vcore import (
    AzureCosmosDBMongoVCoreVectorSearch,
)

vectorstore = AzureCosmosDBMongoVCoreVectorSearch.from_documents(
    docs,
    openai_embeddings,
    collection=collection,
    index_name=INDEX_NAME,
)

Chroma

pip install -qU langchain-chroma

uv add langchain-chroma

from langchain_chroma import Chroma

vector_store = Chroma(
    collection_name="example_collection",
    embedding_function=embeddings,
    persist_directory="./chroma_langchain_db",  # Where to save data locally, remove if not necessary
)

CockroachDB

pip install -qU langchain-cockroachdb

uv add langchain-cockroachdb

from langchain_cockroachdb import AsyncCockroachDBVectorStore, CockroachDBEngine

CONNECTION_STRING = "cockroachdb://user:pass@host:26257/db?sslmode=verify-full"

engine = CockroachDBEngine.from_connection_string(CONNECTION_STRING)
await engine.ainit_vectorstore_table(
    table_name="vectors",
    vector_dimension=1536,
)

vector_store = AsyncCockroachDBVectorStore(
    engine=engine,
    embeddings=embeddings,
    collection_name="vectors",
)

Elasticsearch

Install the package and start Elasticsearch locally using the start-local script:

pip install -qU langchain-elasticsearch
curl -fsSL https://elastic.co/start-local | sh

This creates an elastic-start-local folder. To start Elasticsearch:

cd elastic-start-local
./start.sh

Elasticsearch will be available at http://localhost:9200. The password for the elastic user and API key are stored in the .env file in the elastic-start-local folder.

from langchain_elasticsearch import ElasticsearchStore

vector_store = ElasticsearchStore(
    index_name="langchain-demo",
    embedding=embeddings,
    es_url="http://localhost:9200",
)

Google AlloyDB

pip install -qU langchain-google-alloydb-pg

uv add langchain-google-alloydb-pg

from langchain_google_alloydb_pg import AlloyDBEngine, AlloyDBVectorStore

engine = AlloyDBEngine.from_instance(
    project_id="my-project",
    region="us-central1",
    cluster="my-cluster",
    instance="my-instance",
    database="my-database",
)

vector_store = AlloyDBVectorStore.create_sync(
    engine=engine,
    table_name="my_vectors",
    embedding_service=embeddings
)

Milvus

pip install -qU langchain-milvus

uv add langchain-milvus

from langchain_milvus import Milvus

URI = "./milvus_example.db"

vector_store = Milvus(
    embedding_function=embeddings,
    connection_args={"uri": URI},
    index_params={"index_type": "FLAT", "metric_type": "L2"},
)

MongoDB

pip install -qU langchain-mongodb

from langchain_mongodb import MongoDBAtlasVectorSearch

vector_store = MongoDBAtlasVectorSearch(
    embedding=embeddings,
    collection=MONGODB_COLLECTION,
    index_name=ATLAS_VECTOR_SEARCH_INDEX_NAME,
    relevance_score_fn="cosine",
)

For more information, see the MongoDB LangChain integration docs.

PGVector

pip install -qU langchain-postgres

uv add langchain-postgres

from langchain_postgres import PGVector

vector_store = PGVector(
    embeddings=embeddings,
    collection_name="my_docs",
    connection="postgresql+psycopg://..."
)

PGVectorStore

pip install -qU langchain-postgres

uv add langchain-postgres

from langchain_postgres import PGEngine, PGVectorStore

pg_engine = PGEngine.from_connection_string(
    url="postgresql+psycopg://..."
)

vector_store = PGVectorStore.create_sync(
    engine=pg_engine,
    table_name='test_table',
    embedding_service=embedding
)

Pinecone

pip install -qU langchain-pinecone

uv add langchain-pinecone

from langchain_pinecone import PineconeVectorStore
from pinecone import Pinecone

pc = Pinecone(api_key=...)
index = pc.Index(index_name)

vector_store = PineconeVectorStore(embedding=embeddings, index=index)

Qdrant

pip install -qU langchain-qdrant

uv add langchain-qdrant

from qdrant_client.models import Distance, VectorParams
from langchain_qdrant import QdrantVectorStore
from qdrant_client import QdrantClient

client = QdrantClient(":memory:")

vector_size = len(embeddings.embed_query("sample text"))

if not client.collection_exists("test"):
    client.create_collection(
        collection_name="test",
        vectors_config=VectorParams(size=vector_size, distance=Distance.COSINE)
    )
vector_store = QdrantVectorStore(
    client=client,
    collection_name="test",
    embedding=embeddings,
)

Redis

pip install -qU langchain-redis

uv add langchain-redis

import os
from langchain_redis import RedisConfig, RedisVectorStore

config = RedisConfig(
    index_name="my_vectors",
    redis_url=os.getenv("REDIS_URL", "redis://localhost:6379"),
    distance_metric="COSINE"
)

vector_store = RedisVectorStore(embeddings=embeddings, config=config)

Oracle AI Database

pip install -qU langchain-oracledb

uv add langchain-oracledb

The langchain-community package is no longer maintained. Examples that import from langchain_community may be outdated or broken. Use with caution.

import oracledb
from langchain_oracledb.vectorstores import OracleVS
from langchain_oracledb.vectorstores.oraclevs import create_index
from langchain_community.vectorstores.utils import DistanceStrategy

username = "<username>"
password = "<password>"
dsn = "<hostname>:<port>/<service_name>"

connection = oracledb.connect(user=username, password=password, dsn=dsn)

vector_store = OracleVS(
    client=connection,
    embedding_function=embedding_model,
    table_name="VECTOR_SEARCH_DEMO",
    distance_strategy=DistanceStrategy.EUCLIDEAN_DISTANCE
)

turbopuffer

pip install -qU langchain-turbopuffer

uv add langchain-turbopuffer

from langchain_turbopuffer import TurbopufferVectorStore
from turbopuffer import Turbopuffer

tpuf = Turbopuffer(region="gcp-us-central1")
ns = tpuf.namespace("langchain-test")

vector_store = TurbopufferVectorStore(embedding=embeddings, namespace=ns)

Valkey

pip install -qU "langchain-aws[valkey]"

uv add langchain-aws --extra valkey

from langchain_aws.vectorstores import ValkeyVectorStore

vector_store = ValkeyVectorStore(
    embedding=embeddings,
    valkey_url="valkey://localhost:6379",
    index_name="my_index"
)

Weaviate

pip install -qU langchain-weaviate

uv add langchain-weaviate

import weaviate
from langchain_weaviate import WeaviateVectorStore

# Assumes a local Weaviate instance on http://localhost:8080 with gRPC on 50051.
# See the Weaviate guide for other deployment options (Weaviate Cloud, Docker, etc.).
weaviate_client = weaviate.connect_to_local()

vector_store = WeaviateVectorStore(
    client=weaviate_client,
    index_name="langchain_example",
    text_key="text",
    embedding=embeddings,
)

Vectorstore	Delete by ID	Filtering	Search by Vector	Search with score	Async	Passes Standard Tests	Multi Tenancy	IDs in add Documents	Downloads
`ValkeyVectorStore`	✅	✅	✅	✅	❌	❌	❌	✅
`MongoDBAtlasVectorSearch`	✅	✅	✅	✅	✅	✅	✅	✅
`QdrantVectorStore`	✅	✅	✅	✅	✅	❌	✅	✅
`AzureCosmosDBMongoVCoreVectorStore`	✅	✅	✅	✅	❌	✅	✅	✅
`DatabricksVectorSearch`	✅	✅	✅	✅	✅	❌	❌	✅
`PineconeVectorStore`	✅	✅	✅	❌	✅	❌	❌	✅
`Milvus`	✅	✅	✅	✅	✅	✅	✅	✅
`Weaviate`	✅	✅	✅	✅	✅	❌	✅	✅
`Oracle AI Database`	✅	✅	✅	✅	✅	✅	❌	✅
`AstraDBVectorStore`	✅	✅	✅	✅	✅	✅	✅	✅
`ElasticsearchStore`	✅	✅	✅	✅	✅	❌	❌	✅
`RedisVectorStore`	✅	✅	✅	✅	❌	❌	❌	✅
`Google AlloyDB`	✅	✅	✅	✅	✅	❌	❌	✅
`AzureCosmosDBNoSqlVectorStore`	✅	✅	✅	✅	❌	✅	✅	✅
`InMemoryVectorStore`	✅	✅	❌	✅	✅	❌	❌	✅	N/A

All vector stores

Vectorstore	Delete by ID	Filtering	Search by Vector	Search with score	Async	Passes Standard Tests	Multi Tenancy	IDs in add Documents	Downloads
`Feature Store on Gemini Enterprise Agent Platform`
`Google bigquery vector search`
`Vector Search on Gemini Enterprise Agent Platform`
`Amazon MemoryDB`
`ValkeyVectorStore`	✅	✅	✅	✅	❌	❌	❌	✅
`PGVector`
`PGVectorStore`
`MongoDBAtlasVectorSearch`	✅	✅	✅	✅	✅	✅	✅	✅
`Chroma`
`QdrantVectorStore`	✅	✅	✅	✅	✅	❌	✅	✅
`AzureCosmosDBMongoVCoreVectorStore`	✅	✅	✅	✅	❌	✅	✅	✅
`DatabricksVectorSearch`	✅	✅	✅	✅	✅	❌	❌	✅
`Pinecone (Sparse)`
`PineconeVectorStore`	✅	✅	✅	❌	✅	❌	❌	✅
`Milvus`	✅	✅	✅	✅	✅	✅	✅	✅
`Weaviate`	✅	✅	✅	✅	✅	❌	✅	✅
`Oracle AI Database`	✅	✅	✅	✅	✅	✅	❌	✅
`AstraDBVectorStore`	✅	✅	✅	✅	✅	✅	✅	✅
`Neo4j vector index`
`ElasticsearchStore`	✅	✅	✅	✅	✅	❌	❌	✅
`RedisVectorStore`	✅	✅	✅	✅	❌	❌	❌	✅
`Google AlloyDB`	✅	✅	✅	✅	✅	❌	❌	✅
`AzureCosmosDBNoSqlVectorStore`	✅	✅	✅	✅	❌	✅	✅	✅
`Sap hana cloud vector engine`
`Google cloud SQL for postgresql`
`Google firestore`
`SemanticaVectorStore`	❌
`Google spanner`
`AsyncCockroachDBVectorStore`
`AMUVectorStore`	✅
`OceanbaseVectorStore`
`IBM db2 vector store and vector search`
`InfinoVectorStore`	✅	✅	✅	✅	❌	✅	✅	✅
`OpensolrVectorStore`
`TeradataVectorStore`
`Azure database for postgresql - flexible server`
`CyborgVectorStore`	✅	✅	✅	✅	✅		✅
`SingleStoreVectorStore`	✅	✅	✅	✅	❌	✅	❌	✅
`YDB`
`CouchbaseSearchVectorStore`
`FalkorDBVector`		✅	✅
`Intel's visual data management system (VDMS)`
`SQLServer`
`VastDBVectorStore`	✅	✅	✅	✅	❌	✅	✅	✅
`Mariadb`
`SurrealDBVectorStore`
`PolarDBXVectorStore`	✅	✅	✅	✅	✅	✅	❌	✅
`MixpeekVectorStore`	✅	✅	✅	✅	✅	❌	❌	✅
`ShannonBaseVectorStore`
`InfinispanVectorStore`	✅	✅	✅	✅	❌	✅	❌	✅
`BigtableVectorStore`
`openGauss`
`ChronoVecVectorStore`
`Google memorystore for Redis`
`TypesenseVectorStore`	✅	✅	✅	✅	✅	✅	❌	✅
`PixeltableVectorStore`
`ZeusDB`
`LambdaDB`
`VectorPandaStore`	✅	✅	✅	✅	✅	✅	❌	✅
`turbopuffer`
`Kinetica vectorstore`
`Moorcheh`
`Vectara`
`Google cloud SQL for mysql`
`Gel`
`PolarDBPGVector`	✅	✅	✅	✅	✅	✅	❌	✅
`HouyiVectorStore`	✅	✅
`PolignVectorStore`	✅	✅	✅	✅	✅	✅	❌	✅
`Actian VectorAI DB`	✅	✅	✅	✅	✅			✅
`Activeloop Deep lake`
`Firebolt`
`SereneDB`	✅	✅	✅	✅	✅	✅	✅	✅
`DeweyVectorStore`
`Vedb for mysql`
`Volcengine rds for mysql`
`RostamVectorStore`
`LindormVectorStore`
`Alibaba cloud mysql`
`ChDBVectorStore`	✅	✅	✅	✅	✅	✅	❌	✅
`YantrikDBVectorStore`	✅		✅	✅	❌	✅	✅	✅
`FAISS`									N/A
`InMemoryVectorStore`	✅	✅	❌	✅	✅	❌	❌	✅	N/A