以编程方式使用文档

概述

向量存储 嵌入的 数据并执行相似性搜索。

flowchart LR

    subgraph "📥 Indexing phase (store)"
        A[📄 Documents] --> B[🔢 Embedding model]
        B --> C[🔘 Embedding vectors]
        C --> D[(Vector store)]
    end

    subgraph "📤 Query phase (retrieval)"
        E[❓ Query text] --> F[🔢 Embedding model]
        F --> G[🔘 Query vector]
        G --> H[🔍 Similarity search]
        H --> D
        D --> I[📄 Top-k results]
    end

    classDef process fill:#E5F4FF,stroke:#006DDD,stroke-width:2px,color:#030710
    class A,B,C,D,E,F,G,H,I process

接口

LangChain 为向量存储提供了统一接口，允许您：

  • - add_documents - 向存储添加文档。
  • - delete - 按 ID 删除存储的文档。
  • - similarity_search - 查询语义相似的文档。

这种抽象允许您在不更改应用程序逻辑的情况下切换不同的实现。

初始化

要初始化向量存储，请为其提供嵌入模型：

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

添加文档

添加 Document 对象（包含 page_content 和可选元数据）如下：

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

删除文档

通过指定 ID 删除：

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

相似性搜索

使用以下方式发出语义查询 similarity_search，返回最接近的嵌入文档：

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

许多向量存储支持以下参数：

  • * k — 返回结果数量
  • * filter — 基于元数据的条件过滤

相似性指标和索引

嵌入相似性可以使用以下方式计算：

  • * **余弦相似性**
  • * **欧几里得距离**
  • * **点积**

高效搜索通常采用 HNSW（分层可导航小世界）等索引方法，尽管具体细节取决于向量存储。

元数据过滤

通过元数据（如来源、日期）进行过滤可以优化搜索结果：

vector_store.similarity_search(
  "query",
  k=3,
  filter={"source": "tweets"}
)
对基于元数据过滤的支持因实现而异。 请查看所选向量存储的文档以了解详情。

热门集成

选择嵌入模型：

OpenAI

pip install -qU langchain-openai
uv add langchain-openai
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
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
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")

Google Vertex

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="llama3")

Cohere

pip install -qU langchain-cohere
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
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
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
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
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")

IBM watsonx

pip install -qU langchain-ibm
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="",
)

Fake

pip install -qU langchain-core
from langchain_core.embeddings import DeterministicFakeEmbedding

embeddings = DeterministicFakeEmbedding(size=4096)

xAI

pip install -qU langchain-xai
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
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
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")

选择向量存储：

In-memory

pip install -qU langchain-core
uv add langchain-core
from langchain_core.vectorstores import InMemoryVectorStore

vector_store = InMemoryVectorStore(embeddings)

Amazon OpenSearch

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

安装软件包并使用以下方式在本地启动 Elasticsearch start-local script:

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

这将创建一个 elastic-start-local 文件夹。要启动 Elasticsearch：

cd elastic-start-local
./start.sh

Elasticsearch 将在以下地址可用 http://localhost:9200。用于 elastic 用户的密码和 API 密钥存储在 .env 文件中的 elastic-start-local folder.

from langchain_elasticsearch import ElasticsearchStore

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

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",
)

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
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
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"
)
向量存储按 ID 删除过滤按向量搜索带分数搜索异步通过标准测试多租户添加文档中的 ID
AstraDBVectorStore✅✅✅✅✅✅✅✅
AzureCosmosDBNoSqlVectorStore✅✅✅✅❌✅✅✅
AzureCosmosDBMongoVCoreVectorStore✅✅✅✅❌✅✅✅
AsyncCockroachDBVectorStore✅✅✅✅✅✅✅✅
CouchbaseSearchVectorStore✅✅✅✅✅❌✅✅
DatabricksVectorSearch✅✅✅✅✅❌❌✅
ElasticsearchStore✅✅✅✅✅❌❌✅
InMemoryVectorStore✅✅❌✅✅❌❌✅
LambdaDB✅✅✅✅✅✅❌✅
Milvus✅✅✅✅✅✅✅✅
Moorcheh✅✅✅✅✅✅✅✅
MongoDBAtlasVectorSearch✅✅✅✅✅✅✅✅
openGauss✅✅✅✅❌✅❌✅
PineconeVectorStore✅✅✅❌✅❌❌✅
QdrantVectorStore✅✅✅✅✅❌✅✅
RedisVectorStore✅✅✅✅❌❌❌✅
Weaviate✅✅✅✅✅❌✅✅
SQLServer✅✅✅✅❌❌❌✅
ValkeyVectorStore✅✅✅✅❌❌❌✅
ZeusDB✅✅✅✅✅✅❌✅
Oracle AI Database✅✅✅✅✅✅❌✅

所有向量存储

Activeloop Deep Lake

Alibaba Cloud MySQL

Astra DB Vector Store

Azure Cosmos DB Mongo vCore

Azure Cosmos DB No SQL

Azure Database for PostgreSQL - Flexible Server

CockroachDB

Couchbase

Databricks

IBM Db2

Amazon Document DB

Elasticsearch

Gel

Google AlloyDB

Google BigQuery Vector Search

Google Cloud SQL for MySQL

Google Cloud SQL for PostgreSQL

Firestore

Google Memorystore for Redis

Google Spanner

Google Bigtable

Google Vertex AI Feature Store

Google Vertex AI Vector Search

Kinetica

LambdaDB

Lindorm

Amazon MemoryDB

Milvus

Moorcheh

MongoDB Atlas

Oceanbase

openGauss

Oracle AI Database

PGVectorStore

Pinecone

Pinecone (sparse)

Qdrant

Redis

SAP HANA Cloud Vector Engine

SQLServer

SurrealDB

Teradata VectorStore

Valkey

VDMS

veDB for MySQL

Volcengine RDS for MySQL

Weaviate

YDB

ZeusDB