LlamaIndex 与向量库/向量数据库有多个集成接入点：

1. LlamaIndex 可以把向量库本身当作索引。像其他索引一样，这个索引也能存放文档并用于回答查询。
2. LlamaIndex 可以从向量库加载数据，就像使用其他数据连接器一样。这些数据随后可以在 LlamaIndex 的数据结构中使用。

把向量库当作索引使用

LlamaIndex 还支持把各种向量库作为 VectorStoreIndex 的存储后端。

• Alibaba Cloud OpenSearch (AlibabaCloudOpenSearchStore). 快速上手.
• Amazon Neptune - Neptune Analytics (NeptuneAnalyticsVectorStore). 在 Neptune Analytics 中使用向量相似度.
• Apache Cassandra® and Astra DB through CQL (CassandraVectorStore). 安装 快速上手
• Astra DB (AstraDBVectorStore). 快速上手.
• AWS Document DB (AWSDocDbVectorStore). 快速上手.
• Azure AI Search (AzureAISearchVectorStore). 快速上手
• Azure Cosmos DB Mongo vCore(AzureCosmosDBMongoDBVectorSearch). 快速上手
• Azure Cosmos DB NoSql (AzureCosmosDBNoSqlVectorSearch). 快速上手
• Chroma (ChromaVectorStore) 安装
• ClickHouse (ClickHouseVectorStore) 安装
• Couchbase (CouchbaseSearchVectorStore) 安装
• DashVector (DashVectorStore). 安装.
• DeepLake (DeepLakeVectorStore) 安装
• DocArray (DocArrayHnswVectorStore, DocArrayInMemoryVectorStore). 安装/Python 客户端.
• Elasticsearch (ElasticsearchStore) 安装
• Epsilla (EpsillaVectorStore) 安装/快速上手
• Faiss (FaissVectorStore). 安装.
• Google AlloyDB for PostgreSQL (AlloyDBVectorStore). 快速上手.
• Google Cloud SQL for PostgreSQL (PostgresVectorStore). 快速上手
• Hnswlib (HnswlibVectorStore). 安装.
• txtai (TxtaiVectorStore). 安装.
• Jaguar (JaguarVectorStore). 安装.
• Lantern (LanternVectorStore). 快速上手.
• MariaDB (MariaDBVectorStore). MariaDB 向量概览
• Milvus (MilvusVectorStore). 安装
• MongoDB Atlas (MongoDBAtlasVectorSearch). 安装/快速上手.
• MyScale (MyScaleVectorStore). 快速上手. 安装/Python 客户端.
• Neo4j (Neo4jVectorIndex). 安装.
• OceanBase (OceanBaseVectorStore). OceanBase 概览. 快速上手. Python 客户端
• Opensearch (OpensearchVectorStore) 作为向量数据库的 Opensearch. 快速上手
• Pinecone (PineconeVectorStore). 安装/快速上手.
• Qdrant (QdrantVectorStore) 安装 Python 客户端
• LanceDB (LanceDBVectorStore) 安装/快速上手
• Redis (RedisVectorStore). 安装.
• Relyt (RelytVectorStore). 快速上手.
• Supabase (SupabaseVectorStore). 快速上手.
• Tablestore (Tablestore). Tablestore 概览. 快速上手. Python 客户端.
• TiDB (TiDBVectorStore). 快速上手. 安装. Python 客户端.
• TimeScale (TimescaleVectorStore). 安装.
• Upstash (UpstashVectorStore). 快速上手
• VectorX DB (VectorXVectorStore). 快速上手
• Vertex AI Vector Search (VertexAIVectorStore). 快速上手
• Volcengine MySQL (VolcengineMySQLVectorStore). 快速上手
• Weaviate (WeaviateVectorStore). 安装. Python 客户端.
• WordLift (WordliftVectorStore). 快速上手. Python 客户端.
• Zep (ZepVectorStore). 安装. Python 客户端.
• Zilliz (MilvusVectorStore). 快速上手

详细的 API 参考见这里。

与 LlamaIndex 中的其他索引（树形、关键词表、列表）类似，VectorStoreIndex 可以构建在任意一组文档之上。我们使用索引内的向量库来存放输入文本块的嵌入。

构建完成后，这个索引就可以用于查询。

默认向量库索引的构建与查询

默认情况下，VectorStoreIndex 使用在默认存储上下文中自动初始化的内存版 SimpleVectorStore。

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

# Load documents and build index
documents = SimpleDirectoryReader("../paul_graham_essay/data").load_data()
index = VectorStoreIndex.from_documents(documents)

# Query index
query_engine = index.as_query_engine()
response = query_engine.query("What did the author do growing up?")

自定义向量库索引的构建与查询

我们可以像下面这样在自定义向量库上查询：

from llama_index.core import (
    VectorStoreIndex,
    SimpleDirectoryReader,
    StorageContext,
)
from llama_index.vector_stores.deeplake import DeepLakeVectorStore

# construct vector store and customize storage context
storage_context = StorageContext.from_defaults(
    vector_store=DeepLakeVectorStore(dataset_path="<dataset_path>")
)

# Load documents and build index
documents = SimpleDirectoryReader("../paul_graham_essay/data").load_data()
index = VectorStoreIndex.from_documents(
    documents, storage_context=storage_context
)

# Query index
query_engine = index.as_query_engine()
response = query_engine.query("What did the author do growing up?")

下面展示更多示例，说明如何构建我们支持的各家向量库。

Alibaba Cloud OpenSearch

from llama_index.vector_stores.alibabacloud_opensearch import (
    AlibabaCloudOpenSearchStore,
    AlibabaCloudOpenSearchConfig,
)

config = AlibabaCloudOpenSearchConfig(
    endpoint="***",
    instance_id="***",
    username="your_username",
    password="your_password",
    table_name="llama",
)

vector_store = AlibabaCloudOpenSearchStore(config)

Google AlloyDB for PostgreSQL

终端窗口

pip install llama-index
pip install llama-index-alloydb-pg
pip install llama-index-llms-vertex
gcloud services enable aiplatform.googleapis.com

from llama_index_alloydb_pg import AlloyDBEngine, AlloyDBVectorStore
from llama_index.core import Settings
from llama_index.embeddings.vertex import VertexTextEmbedding
from llama_index.llms.vertex import Vertex
import google.auth

# Replace with your own AlloyDB info
engine = AlloyDBEngine.from_instance(
    project_id=PROJECT_ID,
    region=REGION,
    cluster=CLUSTER,
    instance=INSTANCE,
    database=DATABASE,
    user=USER,
    password=PASSWORD,
)

engine.init_vector_store_table(
    table_name=TABLE_NAME,
    vector_size=768,  # Vector size for VertexAI model(textembedding-gecko@latest)
)

vector_store = AlloyDBVectorStore.create_sync(
    engine=engine,
    table_name=TABLE_NAME,
)

Amazon Neptune - Neptune Analytics

from llama_index.vector_stores.neptune import NeptuneAnalyticsVectorStore

graph_identifier = ""
embed_dim = 1536

neptune_vector_store = NeptuneAnalyticsVectorStore(
    graph_identifier=graph_identifier, embedding_dimension=1536
)

Apache Cassandra®

from llama_index.vector_stores.cassandra import CassandraVectorStore
import cassio

# To use an Astra DB cloud instance through CQL:
cassio.init(database_id="1234abcd-...", token="AstraCS:...")

# For a Cassandra cluster:
from cassandra.cluster import Cluster

cluster = Cluster(["127.0.0.1"])
cassio.init(session=cluster.connect(), keyspace="my_keyspace")

# After the above `cassio.init(...)`, create a vector store:
vector_store = CassandraVectorStore(
    table="cass_v_table", embedding_dimension=1536
)

Astra DB

from llama_index.vector_stores.astra_db import AstraDBVectorStore

astra_db_store = AstraDBVectorStore(
    token="AstraCS:xY3b...",  # Your Astra DB token
    api_endpoint="https://012...abc-us-east1.apps.astra.datastax.com",  # Your Astra DB API endpoint
    collection_name="astra_v_table",  # Table name of your choice
    embedding_dimension=1536,  # Embedding dimension of the embeddings model used
)

Azure Cognitive Search

from azure.core.credentials import AzureKeyCredential
from llama_index.vector_stores.azureaisearch import AzureAISearchVectorStore

search_service_api_key = "YOUR-AZURE-SEARCH-SERVICE-ADMIN-KEY"
search_service_endpoint = "YOUR-AZURE-SEARCH-SERVICE-ENDPOINT"
search_service_api_version = "2023-11-01"
credential = AzureKeyCredential(search_service_api_key)

# Index name to use
index_name = "llamaindex-vector-demo"

client = SearchIndexClient(
    endpoint=search_service_endpoint,
    credential=credential,
)

vector_store = AzureAISearchVectorStore(
    search_or_index_client=client,
    index_name=index_name,
    embedding_dimensionality=1536,
)

Azure CosmosDB Mongo vCore

import pymongo
import os
from llama_index.vector_stores.azurecosmosmongo import (
    AzureCosmosDBMongoDBVectorSearch,
)

# Set up the connection string with your Azure CosmosDB MongoDB URI
connection_string = os.getenv("YOUR_AZURE_COSMOSDB_MONGODB_URI")
mongodb_client = pymongo.MongoClient(connection_string)

# Create an instance of AzureCosmosDBMongoDBVectorSearch
vector_store = AzureCosmosDBMongoDBVectorSearch(
    mongodb_client=mongodb_client,
    db_name="demo_vectordb",
    collection_name="paul_graham_essay",
)

Azure CosmosDB NoSql

from azure.cosmos import CosmosClient, PartitionKey
import os
from llama_index.vector_stores.azurecosmosnosql import (
    AzureCosmosDBNoSqlVectorSearch,
)

URL = os.getenv("AZURE_COSMOSDB_URI")
KEY = os.getenv("AZURE_COSMOSDB_KEY")
database_name = "test_database"
container_name = "test_container"
test_client = CosmosClient(URL, credential=KEY)

indexing_policy = {
    "indexingMode": "consistent",
    "includedPaths": [{"path": "/*"}],
    "excludedPaths": [{"path": '/"_etag"/?'}],
    "vectorIndexes": [{"path": "/embedding", "type": "quantizedFlat"}],
}

vector_embedding_policy = {
    "vectorEmbeddings": [
        {
            "path": "/embedding",
            "dataType": "float32",
            "distanceFunction": "cosine",
            "dimensions": 1536,
        }
    ]
}

partition_key = PartitionKey(path="/id")
cosmos_container_properties_test = {"partition_key": partition_key}
cosmos_database_properties_test = {}

vector_store = AzureCosmosDBNoSqlVectorSearch(
    cosmos_client=test_client,
    vector_embedding_policy=vector_embedding_policy,
    indexing_policy=indexing_policy,
    database_name=database_name,
    container_name=container_name,
    cosmos_database_properties=cosmos_database_properties_test,
    cosmos_container_properties=cosmos_container_properties_test,
)

Chroma

import chromadb
from llama_index.vector_stores.chroma import ChromaVectorStore

# Creating a Chroma client
# EphemeralClient operates purely in-memory, PersistentClient will also save to disk
chroma_client = chromadb.EphemeralClient()
chroma_collection = chroma_client.create_collection("quickstart")

# construct vector store
vector_store = ChromaVectorStore(
    chroma_collection=chroma_collection,
)

ClickHouse

import clickhouse_connect
from llama_index.vector_stores import ClickHouseVectorStore

# Creating a ClickHouse client
client = clickhouse_connect.get_client(
    host="YOUR_CLUSTER_HOST",
    port=8123,
    username="YOUR_USERNAME",
    password="YOUR_CLUSTER_PASSWORD",
)

# construct vector store
vector_store = ClickHouseVectorStore(clickhouse_client=client)

Couchbase

from datetime import timedelta

from couchbase.auth import PasswordAuthenticator
from couchbase.cluster import Cluster
from couchbase.options import ClusterOptions

# Create a Couchbase Cluster object
auth = PasswordAuthenticator("DATABASE_USERNAME", "DATABASE_PASSWORD")
options = ClusterOptions(auth)
cluster = Cluster("CLUSTER_CONNECTION_STRING", options)

# Wait until the cluster is ready for use.
cluster.wait_until_ready(timedelta(seconds=5))

# Create the Vector Store
vector_store = CouchbaseSearchVectorStore(
    cluster=cluster,
    bucket_name="BUCKET_NAME",
    scope_name="SCOPE_NAME",
    collection_name="COLLECTION_NAME",
    index_name="SEARCH_INDEX_NAME",
)

DashVector

import dashvector
from llama_index.vector_stores.dashvector import DashVectorStore

# init dashvector client
client = dashvector.Client(
    api_key="your-dashvector-api-key",
    endpoint="your-dashvector-cluster-endpoint",
)

# creating a DashVector collection
client.create("quickstart", dimension=1536)
collection = client.get("quickstart")

# construct vector store
vector_store = DashVectorStore(collection)

DeepLake

import os
import getpath
from llama_index.vector_stores.deeplake import DeepLakeVectorStore

os.environ["OPENAI_API_KEY"] = getpath.getpath("OPENAI_API_KEY: ")
os.environ["ACTIVELOOP_TOKEN"] = getpath.getpath("ACTIVELOOP_TOKEN: ")
dataset_path = "hub://adilkhan/paul_graham_essay"

# construct vector store
vector_store = DeepLakeVectorStore(dataset_path=dataset_path, overwrite=True)

DocArray

from llama_index.vector_stores.docarray import (
    DocArrayHnswVectorStore,
    DocArrayInMemoryVectorStore,
)

# construct vector store
vector_store = DocArrayHnswVectorStore(work_dir="hnsw_index")

# alternatively, construct the in-memory vector store
vector_store = DocArrayInMemoryVectorStore()

Elasticsearch

首先，你可以在本地或 Elastic cloud 上启动 Elasticsearch。

要在本地用 docker 启动 Elasticsearch，运行以下命令：

终端窗口

docker run -p 9200:9200 \
  -e "discovery.type=single-node" \
  -e "xpack.security.enabled=false" \
  -e "xpack.security.http.ssl.enabled=false" \
  -e "xpack.license.self_generated.type=trial" \
  docker.elastic.co/elasticsearch/elasticsearch:8.9.0

然后就可以把 Elasticsearch 作为向量数据库与 LlamaIndex 一起连接使用

from llama_index.vector_stores.elasticsearch import ElasticsearchStore

vector_store = ElasticsearchStore(
    index_name="llm-project",
    es_url="http://localhost:9200",
    # Cloud connection options:
    # es_cloud_id="<cloud_id>",
    # es_user="elastic",
    # es_password="<password>",
)

它可以与 VectorStoreIndex 搭配，提供检索、查询、删除、持久化索引等能力的查询接口。

Epsilla

from pyepsilla import vectordb
from llama_index.vector_stores.epsilla import EpsillaVectorStore

# Creating an Epsilla client
epsilla_client = vectordb.Client()

# Construct vector store
vector_store = EpsillaVectorStore(client=epsilla_client)

注：EpsillaVectorStore 依赖 pyepsilla 库以及一个运行中的 Epsilla 向量数据库。若尚未安装，请用 pip/pip3 install pyepsilla。运行中的 Epsilla 向量数据库可通过 docker 镜像获得。完整说明见以下文档：https://epsilla-inc.gitbook.io/epsilladb/quick-start

Faiss

import faiss
from llama_index.vector_stores.faiss import FaissVectorStore

# create faiss index
d = 1536
faiss_index = faiss.IndexFlatL2(d)

# construct vector store
vector_store = FaissVectorStore(faiss_index)

# if update/delete functionality is needed you can leverage the FaissMapVectorStore

d = 1536
faiss_index = faiss.IndexFlatL2(d)
id_map_index = faiss.IndexIDMap2(faiss_index)
vector_store = FaissMapVectorStore(id_map_index)

...

# NOTE: since faiss index is in-memory, we need to explicitly call
#       vector_store.persist() or storage_context.persist() to save it to disk.
#       persist() takes in optional arg persist_path. If none give, will use default paths.
storage_context.persist()

Google Cloud SQL for PostgreSQL

终端窗口

pip install llama-index
pip install llama-index-cloud-sql-pg
pip install llama-index-llms-vertex
gcloud services enable aiplatform.googleapis.com

from llama_index_cloud_sql_pg import PostgresEngine, PostgresVectorStore
from llama_index.core import Settings
from llama_index.embeddings.vertex import VertexTextEmbedding
from llama_index.llms.vertex import Vertex
import google.auth

# Replace with your own Cloud SQL info
engine = PostgresEngine.from_instance(
    project_id=PROJECT_ID,
    region=REGION,
    instance=INSTANCE,
    database=DATABASE,
    user=USER,
    password=PASSWORD,
)

engine.init_vector_store_table(
    table_name=TABLE_NAME,
    vector_size=768,  # Vector size for VertexAI model(textembedding-gecko@latest)
)

vector_store = PostgresVectorStore.create_sync(
    engine=engine,
    table_name=TABLE_NAME,
)

txtai

import txtai
from llama_index.vector_stores.txtai import TxtaiVectorStore

# create txtai index
txtai_index = txtai.ann.ANNFactory.create(
    {"backend": "numpy", "dimension": 512}
)

# construct vector store
vector_store = TxtaiVectorStore(txtai_index)

Jaguar

from llama_index.core.schema import TextNode
from llama_index.core.vector_stores import VectorStoreQuery
from jaguardb_http_client.JaguarHttpClient import JaguarHttpClient
from llama_index.vector_stores.jaguar import JaguarVectorStore

# construct vector store client
url = "http://127.0.0.1:8080/fwww/"
pod = "vdb"
store = "llamaindex_rag_store"
vector_index = "v"
vector_type = "cosine_fraction_float"
vector_dimension = 3

# require JAGUAR_API_KEY environment variable or file $HOME/.jagrc to hold the
# jaguar API key to connect to jaguar store server
vector_store = JaguarVectorStore(
    pod, store, vector_index, vector_type, vector_dimension, url
)

# login to jaguar server for security authentication
vector_store.login()

# create a vector store on the back-end server
metadata_fields = "author char(32), category char(16)"
text_size = 1024
vector_store.create(metadata_fields, text_size)

# store some text
node = TextNode(
    text="Return of King Lear",
    metadata={"author": "William", "category": "Tragedy"},
    embedding=[0.9, 0.1, 0.4],
)
vector_store.add(nodes=[node], use_node_metadata=True)

# make a query
qembedding = [0.4, 0.2, 0.8]
vsquery = VectorStoreQuery(query_embedding=qembedding, similarity_top_k=1)
query_result = vector_store.query(vsquery)

# make a query with metadata filter (where condition)
qembedding = [0.6, 0.1, 0.4]
vsquery = VectorStoreQuery(query_embedding=qembedding, similarity_top_k=3)
where = "author='Eve' or (author='Adam' and category='History')"
query_result = vector_store.query(vsquery, where=where)

# make a query ignoring old data (with time cutoff)
qembedding = [0.3, 0.3, 0.8]
vsquery = VectorStoreQuery(query_embedding=qembedding, similarity_top_k=3)
args = "day_cutoff=180"  # only search recent 180 days data
query_result = vector_store.query(vsquery, args=args)

# check if a vector is anomalous
text = ("Gone With The Wind",)
embed_of_text = [0.7, 0.1, 0.2]
node = TextNode(text=text, embedding=embed_of_text)
true_or_false = vector_store.is_anomalous(node)

# llama_index RAG application
from llama_index.embeddings.openai import OpenAIEmbedding
from llama_index.core import StorageContext
from llama_index.core import VectorStoreIndex

question = "What did the author do growing up?"

storage_context = StorageContext.from_defaults(vector_store=vector_store)
embed_model = OpenAIEmbedding()
embed_of_question = [0.7, 0.1, 0.2]

db_documents = vector_store.load_documents(embed_of_question, 10)
index = VectorStoreIndex.from_documents(
    db_documents,
    embed_model=embed_model,
    storage_context=storage_context,
)

query_engine = index.as_query_engine()
print(f"Question: {question}")
response = query_engine.query(question)
print(f"Answer: {str(response)}")

# logout to clean up resources
vector_store.logout()

注：Client（需要 jaguardb-http-client）<—> Http Gateway <—> JaguarDB Server。客户端一侧需要运行：“pip install -U jaguardb-http-client”

MariaDB

from llama_index.vector_stores.mariadb import MariaDBVectorStore

vector_store = MariaDBVectorStore.from_params(
    host="localhost",
    port=3306,
    user="llamaindex",
    password="password",
    database="vectordb",
    table_name="llama_index_vectorstore",
    embed_dim=1536,  # OpenAI embedding dimension
)

Milvus

• Milvus 索引可以同时存放 Document 及其嵌入。

import pymilvus
from llama_index.vector_stores.milvus import MilvusVectorStore

# construct vector store
vector_store = MilvusVectorStore(
    uri="https://localhost:19530", overwrite="True"
)

注：MilvusVectorStore 依赖 pymilvus 库。若尚未安装，请用 pip install pymilvus。如果卡在为 grpcio 构建 wheel，请检查你是否在用 python 3.11（这是一个已知问题：https://github.com/milvus-io/pymilvus/issues/1308），尝试降级后再试。

MongoDBAtlas

# Provide URI to constructor, or use environment variable
import pymongo
from llama_index.vector_stores.mongodb import MongoDBAtlasVectorSearch
from llama_index.core import VectorStoreIndex
from llama_index.core import StorageContext
from llama_index.core import SimpleDirectoryReader

# mongo_uri = os.environ["MONGO_URI"]
mongo_uri = (
    "mongodb+srv://<username>:<password>@<host>?retryWrites=true&w=majority"
)
mongodb_client = pymongo.MongoClient(mongo_uri)
async_mongodb_client = pymongo.AsyncMongoClient(mongo_uri)

# construct store
store = MongoDBAtlasVectorSearch(
    mongodb_client=mongodb_client, async_mongodb_client=async_mongodb_client
)
storage_context = StorageContext.from_defaults(vector_store=store)
uber_docs = SimpleDirectoryReader(
    input_files=["../data/10k/uber_2021.pdf"]
).load_data()

# construct index
index = VectorStoreIndex.from_documents(
    uber_docs, storage_context=storage_context
)

MyScale

import clickhouse_connect
from llama_index.vector_stores.myscale import MyScaleVectorStore

# Creating a MyScale client
client = clickhouse_connect.get_client(
    host="YOUR_CLUSTER_HOST",
    port=8443,
    username="YOUR_USERNAME",
    password="YOUR_CLUSTER_PASSWORD",
)

# construct vector store
vector_store = MyScaleVectorStore(myscale_client=client)

Neo4j

• Neo4j 存放文本、元数据与嵌入；还可以定制为把图数据以元数据的形式返回。

from llama_index.vector_stores.neo4jvector import Neo4jVectorStore

# construct vector store
neo4j_vector = Neo4jVectorStore(
    username="neo4j",
    password="pleaseletmein",
    url="bolt://localhost:7687",
    embed_dim=1536,
)

Pinecone

import pinecone
from llama_index.vector_stores.pinecone import PineconeVectorStore

# Creating a Pinecone index
api_key = "api_key"
pinecone.init(api_key=api_key, environment="us-west1-gcp")
pinecone.create_index(
    "quickstart", dimension=1536, metric="euclidean", pod_type="p1"
)
index = pinecone.Index("quickstart")

# construct vector store
vector_store = PineconeVectorStore(pinecone_index=index)

Qdrant

import qdrant_client
from llama_index.vector_stores.qdrant import QdrantVectorStore

# Creating a Qdrant vector store
client = qdrant_client.QdrantClient(
    host="<qdrant-host>", api_key="<qdrant-api-key>", https=True
)
collection_name = "paul_graham"

# construct vector store
vector_store = QdrantVectorStore(
    client=client,
    collection_name=collection_name,
)

Redis

首先，启动 Redis-Stack（或从 Redis 服务商处取得 url）

终端窗口

docker run --name redis-vecdb -d -p 6379:6379 -p 8001:8001 redis/redis-stack:latest

然后就可以把 Redis 作为向量数据库与 LlamaIndex 一起连接使用

from llama_index.vector_stores.redis import RedisVectorStore

vector_store = RedisVectorStore(
    index_name="llm-project",
    redis_url="redis://localhost:6379",
    overwrite=True,
)

它可以与 VectorStoreIndex 搭配，提供检索、查询、删除、持久化索引等能力的查询接口。

SingleStore

from llama_index.vector_stores.singlestoredb import SingleStoreVectorStore
import os

# can set the singlestore db url in env
# or pass it in as an argument to the SingleStoreVectorStore constructor
os.environ["SINGLESTOREDB_URL"] = "PLACEHOLDER URL"
vector_store = SingleStoreVectorStore(
    table_name="embeddings",
    content_field="content",
    metadata_field="metadata",
    vector_field="vector",
    timeout=30,
)

Tablestore

import tablestore
from llama_index.vector_stores.tablestore import TablestoreVectorStore

# create a vector store that does not support filtering non-vector fields
simple_vector_store = TablestoreVectorStore(
    endpoint="<end_point>",
    instance_name="<instance_name>",
    access_key_id="<access_key_id>",
    access_key_secret="<access_key_secret>",
    vector_dimension=512,
)

# create a vector store that support filtering non-vector fields
vector_store_with_meta_data = TablestoreVectorStore(
    endpoint="<end_point>",
    instance_name="<instance_name>",
    access_key_id="<access_key_id>",
    access_key_secret="<access_key_secret>",
    vector_dimension=512,
    # optional: custom metadata mapping is used to filter non-vector fields.
    metadata_mappings=[
        tablestore.FieldSchema(
            "type",  # non-vector fields
            tablestore.FieldType.KEYWORD,
            index=True,
            enable_sort_and_agg=True,
        ),
        tablestore.FieldSchema(
            "time",  # non-vector fields
            tablestore.FieldType.LONG,
            index=True,
            enable_sort_and_agg=True,
        ),
    ],
)

TiDB

from llama_index.vector_stores.tidbvector import TiDBVectorStore

tidbvec = TiDBVectorStore(
    # connection url format
    # - mysql+pymysql://root@34.212.137.91:4000/test
    connection_string="PLACEHOLDER URL",
    table_name="llama_index_vectorstore",
    distance_strategy="cosine",
    vector_dimension=1536,
)

Timescale

from llama_index.vector_stores.timescalevector import TimescaleVectorStore

vector_store = TimescaleVectorStore.from_params(
    service_url="YOUR TIMESCALE SERVICE URL",
    table_name="paul_graham_essay",
)

Upstash

from llama_index.vector_stores.upstash import UpstashVectorStore

vector_store = UpstashVectorStore(url="YOUR_URL", token="YOUR_TOKEN")

VectorX DB

from vecx_llamaindex import VectorXVectorStore
from llama_index.core import StorageContext
import time

# Create a unique index name with timestamp to avoid conflicts
timestamp = int(time.time())
index_name = f"llamaindex_demo_{timestamp}"

# Set up the embedding model
embed_model = OpenAIEmbedding()

# Get the embedding dimension
dimension = 1536  # OpenAI's default embedding dimension

# Initialize the VectorX vector store
vector_store = VectorXVectorStore.from_params(
    api_token=vecx_api_token,
    encryption_key=encryption_key,
    index_name=index_name,
    dimension=dimension,
    space_type="cosine",  # Can be "cosine", "l2", or "ip"
)

storage_context = StorageContext.from_defaults(vector_store=vector_store)

index = VectorStoreIndex.from_documents(
    documents, storage_context=storage_context, embed_model=embed_model
)

query_engine = index.as_query_engine()

# Ask a question
response = query_engine.query("What is Python?")

# Create a filtered retriever to only search within AI-related documents
ai_filter = MetadataFilter(
    key="category", value="ai", operator=FilterOperator.EQ
)
ai_filters = MetadataFilters(filters=[ai_filter])

# Create a filtered query engine
filtered_query_engine = index.as_query_engine(filters=ai_filters)

# Ask a general question but only using AI documents
response = filtered_query_engine.query("What is learning from data?")

Vertex AI Vector Search

from llama_index.vector_stores.vertexaivectorsearch import VertexAIVectorStore

vector_store = VertexAIVectorStore(
    project_id="[your-google-cloud-project-id]",
    region="[your-google-cloud-region]",
    index_id="[your-index-resource-name]",
    endpoint_id="[your-index-endpoint-name]",
)

Weaviate

import weaviate
from llama_index.vector_stores.weaviate import WeaviateVectorStore

# creating a Weaviate client
resource_owner_config = weaviate.AuthClientPassword(
    username="<username>",
    password="<password>",
)
client = weaviate.Client(
    "https://<cluster-id>.semi.network/",
    auth_client_secret=resource_owner_config,
)

# construct vector store
vector_store = WeaviateVectorStore(weaviate_client=client)

Zep

Zep 存放文本、元数据与嵌入。检索结果中会把它们全部返回。

from llama_index.vector_stores.zep import ZepVectorStore

vector_store = ZepVectorStore(
    api_url="<api_url>",
    api_key="<api_key>",
    collection_name="<unique_collection_name>",  # Can either be an existing collection or a new one
    embedding_dimensions=1536,  # Optional, required if creating a new collection
)

storage_context = StorageContext.from_defaults(vector_store=vector_store)

index = VectorStoreIndex.from_documents(
    documents, storage_context=storage_context
)

# Query index using both a text query and metadata filters
filters = MetadataFilters(
    filters=[ExactMatchFilter(key="theme", value="Mafia")]
)
retriever = index.as_retriever(filters=filters)
result = retriever.retrieve("What is inception about?")

Zilliz

• Zilliz Cloud（Milvus 的托管版本）使用 Milvus 索引，并附带一些额外参数。

import pymilvus
from llama_index.vector_stores.milvus import MilvusVectorStore

# construct vector store
vector_store = MilvusVectorStore(
    uri="foo.vectordb.zillizcloud.com",
    token="your_token_here",
    overwrite="True",
)

示例 notebook 见这里。

通过数据连接器从向量库加载数据

LlamaIndex 支持从大量来源加载数据。更多细节与 API 文档见数据连接器。

AlloyDB 同时存放文档与向量。本教程演示同步接口；所有同步方法都有对应的异步方法。下面是使用 AlloyDB 的示例：

终端窗口

pip install llama-index
pip install llama-index-alloydb-pg

from llama_index.core import SummaryIndex
from llama_index_alloydb_pg import AlloyDBEngine, AlloyDBReader

engine = AlloyDBEngine.from_instance(
    project_id=PROJECT_ID,
    region=REGION,
    cluster=CLUSTER,
    instance=INSTANCE,
    database=DATABASE,
    user=USER,
    password=PASSWORD,
)
reader = AlloyDBReader.create_sync(
    engine,
    table_name=TABLE_NAME,
)
documents = reader.load_data()

index = SummaryIndex.from_documents(documents)

query_engine = index.as_query_engine()
response = query_engine.query("<query_text>")
display(Markdown(f"<b>{response}</b>"))

Google Cloud SQL for PostgreSQL 同时存放文档与向量。本教程演示同步接口；所有同步方法都有对应的异步方法。下面是使用 Cloud SQL for PostgreSQL 的示例：

终端窗口

pip install llama-index
pip install llama-index-cloud-sql-pg

from llama_index.core import SummaryIndex
from llama_index_cloud_sql_pg import PostgresEngine, PostgresReader

engine = PostgresEngine.from_instance(
    project_id=PROJECT_ID,
    region=REGION,
    instance=INSTANCE,
    database=DATABASE,
    user=USER,
    password=PASSWORD,
)
reader = PostgresReader.create_sync(
    engine,
    table_name=TABLE_NAME,
)
documents = reader.load_data()

index = SummaryIndex.from_documents(documents)

query_engine = index.as_query_engine()
response = query_engine.query("<query_text>")
display(Markdown(f"<b>{response}</b>"))

Chroma 同时存放文档与向量。这是使用 Chroma 的示例：

from llama_index.readers.chroma import ChromaReader
from llama_index.core import SummaryIndex

# The chroma reader loads data from a persisted Chroma collection.
# This requires a collection name and a persist directory.
reader = ChromaReader(
    collection_name="chroma_collection",
    persist_directory="examples/data_connectors/chroma_collection",
)

query_vector = [n1, n2, n3, ...]

documents = reader.load_data(
    collection_name="demo", query_vector=query_vector, limit=5
)
index = SummaryIndex.from_documents(documents)

query_engine = index.as_query_engine()
response = query_engine.query("<query_text>")
display(Markdown(f"<b>{response}</b>"))

Qdrant 同样同时存放文档与向量。这是使用 Qdrant 的示例：

from llama_index.readers.qdrant import QdrantReader

reader = QdrantReader(host="localhost")

# the query_vector is an embedding representation of your query_vector
# Example query_vector
# query_vector = [0.3, 0.3, 0.3, 0.3, ...]

query_vector = [n1, n2, n3, ...]

# NOTE: Required args are collection_name, query_vector.
# See the Python client: https;//github.com/qdrant/qdrant_client
# for more details

documents = reader.load_data(
    collection_name="demo", query_vector=query_vector, limit=5
)

注：由于 Weaviate 可以混合存放文档对象与向量对象，用户既可以显式指定 class_name 与 properties 来查询文档，也可以直接给出原始的 GraphQL 查询。用法见下文。

# option 1: specify class_name and properties

# 1) load data using class_name and properties
documents = reader.load_data(
    class_name="<class_name>",
    properties=["property1", "property2", "..."],
    separate_documents=True,
)

# 2) example GraphQL query
query = """
{
    Get {
        <class_name> {
            <property1>
            <property2>
        }
    }
}
"""

documents = reader.load_data(graphql_query=query, separate_documents=True)

注：Pinecone 与 Faiss 的数据加载器都假定其数据源只存放向量，文本内容存放在别处。因此这两个加载器都要求用户在 load_data 调用中提供 id_to_text_map。

例如，下面是 Pinecone 数据加载器 PineconeReader 的一个用法：

from llama_index.readers.pinecone import PineconeReader

reader = PineconeReader(api_key=api_key, environment="us-west1-gcp")

id_to_text_map = {
    "id1": "text blob 1",
    "id2": "text blob 2",
}

query_vector = [n1, n2, n3, ...]

documents = reader.load_data(
    index_name="quickstart",
    id_to_text_map=id_to_text_map,
    top_k=3,
    vector=query_vector,
    separate_documents=True,
)

示例 notebook 见这里。

向量库示例

• Alibaba Cloud OpenSearch
• Amazon Neptune - Neptune Analytics
• Astra DB
• Async Index Creation
• Azure AI Search
• Azure Cosmos DB
• Caasandra
• Chromadb
• Couchbase
• Dash
• Deeplake
• DocArray HNSW
• DocArray in-Memory
• Espilla
• Google AlloyDB for PostgreSQL
• Google Cloud SQL for PostgreSQL
• LanceDB
• Lantern
• Milvus
• Milvus Async API
• Milvus Full-Text Search
• Milvus Hybrid Search
• MyScale
• ElsaticSearch
• FAISS
• MongoDB Atlas
• Neo4j
• OpenSearch
• Pinecone
• Pinecone Hybrid Search
• PGvectoRS
• Postgres
• Redis
• Qdrant
• Qdrant Hybrid Search
• Rockset
• Simple
• Supabase
• Tablestore
• Tair
• Tencent
• Timesacle
• Upstash
• VectorX DB
• Weaviate
• Weaviate Hybrid Search
• WordLift
• Zep