文档存储

文档存储包含已摄入的文档片段，我们称之为Node对象。

更多细节请参阅API参考。

简单文档存储

默认情况下，SimpleDocumentStore将Node对象存储在内存中。通过调用docstore.persist()（以及对应的SimpleDocumentStore.from_persist_path(...)）可以将它们持久化到磁盘（或从磁盘加载）。

完整示例可查看此处

MongoDB文档存储

我们支持将MongoDB作为替代文档存储后端，在摄入数据时持久化Node对象。

from llama_index.storage.docstore.mongodb import MongoDocumentStore
from llama_index.core.node_parser import SentenceSplitter

# create parser and parse document into nodes
parser = SentenceSplitter()
nodes = parser.get_nodes_from_documents(documents)

# create (or load) docstore and add nodes
docstore = MongoDocumentStore.from_uri(uri="<mongodb+srv://...>")
docstore.add_documents(nodes)

# create storage context
storage_context = StorageContext.from_defaults(docstore=docstore)

# build index
index = VectorStoreIndex(nodes, storage_context=storage_context)

底层实现上，MongoDocumentStore会连接到一个固定的MongoDB数据库，并为您的节点初始化新的集合（或加载现有集合）。

注意：在实例化MongoDocumentStore时可以配置db_name和namespace，默认值为db_name="db_docstore"和namespace="docstore"。

注意在使用MongoDocumentStore时不需要调用storage_context.persist()（或docstore.persist()），因为数据默认就会持久化。

您可以通过使用现有的db_name和collection_name重新初始化MongoDocumentStore，轻松地重新连接到MongoDB集合并重新加载索引。

完整示例可查看此处

Redis文档存储

我们支持将Redis作为替代文档存储后端，在摄入数据时持久化Node对象。

from llama_index.storage.docstore.redis import RedisDocumentStore
from llama_index.core.node_parser import SentenceSplitter

# create parser and parse document into nodes
parser = SentenceSplitter()
nodes = parser.get_nodes_from_documents(documents)

# create (or load) docstore and add nodes
docstore = RedisDocumentStore.from_host_and_port(
    host="127.0.0.1", port="6379", namespace="llama_index"
)
docstore.add_documents(nodes)

# create storage context
storage_context = StorageContext.from_defaults(docstore=docstore)

# build index
index = VectorStoreIndex(nodes, storage_context=storage_context)

底层实现上，RedisDocumentStore会连接到Redis数据库，并将您的节点添加到存储在{namespace}/docs下的命名空间中。

注意：在实例化RedisDocumentStore时可以配置namespace，默认值为namespace="docstore"。

您可以通过使用现有的host、port和namespace重新初始化RedisDocumentStore，轻松地重新连接到Redis客户端并重新加载索引。

完整示例可查看此处

Firestore文档存储

我们支持将Firestore作为替代文档存储后端，在摄入数据时持久化Node对象。

from llama_index.storage.docstore.firestore import FirestoreDocumentStore
from llama_index.core.node_parser import SentenceSplitter

# create parser and parse document into nodes
parser = SentenceSplitter()
nodes = parser.get_nodes_from_documents(documents)

# create (or load) docstore and add nodes
docstore = FirestoreDocumentStore.from_database(
    project="project-id",
    database="(default)",
)
docstore.add_documents(nodes)

# create storage context
storage_context = StorageContext.from_defaults(docstore=docstore)

# build index
index = VectorStoreIndex(nodes, storage_context=storage_context)

底层实现上，FirestoreDocumentStore会连接到Google Cloud中的Firestore数据库，并将您的节点添加到存储在{namespace}/docs下的命名空间中。

注意：在实例化FirestoreDocumentStore时可以配置namespace，默认值为namespace="docstore"。

您可以通过使用现有的project、database和namespace重新初始化FirestoreDocumentStore，轻松地重新连接到Firestore数据库并重新加载索引。

完整示例可查看此处

Couchbase文档存储

我们支持将Couchbase作为替代文档存储后端，在摄入数据时持久化Node对象。

from llama_index.storage.docstore.couchbase import CouchbaseDocumentStore
from llama_index.core.node_parser import SentenceSplitter

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

# create couchbase client
auth = PasswordAuthenticator("DB_USERNAME", "DB_PASSWORD")
options = ClusterOptions(authenticator=auth)

cluster = Cluster("couchbase://localhost", options)

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

# create parser and parse document into nodes
parser = SentenceSplitter()
nodes = parser.get_nodes_from_documents(documents)

# create (or load) docstore and add nodes
docstore = CouchbaseDocumentStore.from_couchbase_client(
    client=cluster,
    bucket_name="llama-index",
    scope_name="_default",
    namespace="default",
)
docstore.add_documents(nodes)

# create storage context
storage_context = StorageContext.from_defaults(docstore=docstore)

# build index
index = VectorStoreIndex(nodes, storage_context=storage_context)

底层实现上，CouchbaseDocumentStore会连接到Couchbase操作型数据库，并将您的节点添加到指定{bucket_name}和{scope_name}下名为{namespace}_data的集合中。

注意：在实例化CouchbaseIndexStore时可以配置namespace、bucket和scope。默认使用的集合是docstore_data。除了字母数字字符外，集合名称中只允许使用-、_和%。存储会自动将其他特殊字符转换为_。

您可以通过使用现有的client、bucket_name、scope_name和namespace重新初始化CouchbaseDocumentStore，轻松地重新连接到Couchbase数据库并重新加载索引。

表格存储文档存储

我们支持将表格存储作为替代文档存储后端，在摄入数据时持久化Node对象。

from llama_index.core import Document
from llama_index.core import StorageContext, VectorStoreIndex
from llama_index.core.node_parser import SentenceSplitter

from llama_index.storage.docstore.tablestore import TablestoreDocumentStore

# create parser and parse document into nodes
parser = SentenceSplitter()
documents = [
    Document(text="I like cat.", id_="1", metadata={"key1": "value1"}),
    Document(text="Mike likes dog.", id_="2", metadata={"key2": "value2"}),
]
nodes = parser.get_nodes_from_documents(documents)

# create (or load) doc_store and add nodes
docs_tore = TablestoreDocumentStore.from_config(
    endpoint="<tablestore_end_point>",
    instance_name="<tablestore_instance_name>",
    access_key_id="<tablestore_access_key_id>",
    access_key_secret="<tablestore_access_key_secret>",
)
docs_tore.add_documents(nodes)

# create storage context
storage_context = StorageContext.from_defaults(docstore=docs_tore)

# build index
index = VectorStoreIndex(nodes, storage_context=storage_context)

底层实现上，TablestoreDocumentStore会连接到表格存储数据库，并将您的节点添加到名为{namespace}_data的表下。

注意：在实例化TablestoreDocumentStore时可以配置namespace。

您可以通过使用现有的endpoint、instance_name、access_key_id和access_key_secret重新初始化TablestoreDocumentStore，轻松地重新连接到表格存储数据库并重新加载索引。

完整示例可查看此处

Google AlloyDB文档存储

我们支持AlloyDB作为替代文档存储后端，在摄入数据时持久化Node对象。

本教程演示同步接口。所有同步方法都有对应的异步方法。

pip install llama-index
pip install llama-index-alloydb-pg
pip install llama-index-llms-vertex

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

# create parser and parse document into nodes
parser = SentenceSplitter()
nodes = parser.get_nodes_from_documents(documents)

# create an AlloyDB Engine for connection pool
engine = AlloyDBEngine.from_instance(
    project_id=PROJECT_ID,
    region=REGION,
    cluster=CLUSTER,
    instance=INSTANCE,
    database=DATABASE,
    user=USER,
    password=PASSWORD,
)

# initialize a new table in AlloyDB
engine.init_doc_store_table(
    table_name=TABLE_NAME,
)

doc_store = AlloyDBDocumentStore.create_sync(
    engine=engine,
    table_name=TABLE_NAME,
)

doc_store.add_documents(nodes)

# create storage context
storage_context = StorageContext.from_defaults(docstore=doc_store)

# build index
index = VectorStoreIndex(nodes, storage_context=storage_context)

注意：在初始化新表和实例化AlloyDBDocumentStore时，可以配置schema_name和table_name。默认schema_name为public。

底层实现上，AlloyDBDocumentStore会连接到Google Cloud中的AlloyDB数据库，并将您的节点添加到schema_name下的表中。

您可以通过使用AlloyDBEngine重新初始化AlloyDBDocumentStore（无需初始化新表），轻松地重新连接到AlloyDB数据库并重新加载索引。

更详细的指南可查看此处

Google Cloud SQL for PostgreSQL 文档存储

我们支持将 Cloud SQL for PostgreSQL 作为替代的文档存储后端，可在数据被摄取为 Node 对象时进行持久化存储。

本教程演示同步接口的使用。所有同步方法均有对应的异步方法实现。

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, PostgresDocumentStore

# 创建解析器并将文档解析为节点
parser = SentenceSplitter()
nodes = parser.get_nodes_from_documents(documents)

# 创建Postgres连接池引擎
engine = PostgresEngine.from_instance(
    project_id=PROJECT_ID,
    region=REGION,
    instance=INSTANCE,
    database=DATABASE,
    user=USER,
    password=PASSWORD,
)

# 在Cloud SQL PostgreSQL中初始化新表
engine.init_doc_store_table(
    table_name=TABLE_NAME,
)

doc_store = PostgresDocumentStore.create_sync(
    engine=engine,
    table_name=TABLE_NAME,
)

doc_store.add_documents(nodes)

# 创建存储上下文
storage_context = StorageContext.from_defaults(docstore=doc_store)

# 构建索引
index = VectorStoreIndex(nodes, storage_context=storage_context)

注意：初始化新表和实例化 PostgresDocumentStore 时，可同时配置 schema_name 和 table_name。默认 schema_name 为 public。

底层实现中，PostgresDocumentStore 会连接 Google Cloud 的 PostgreSQL 数据库，并将您的节点数据添加到指定 schema_name 下的表中。

您可以通过重新初始化带有 PostgresEngine 的 PostgresDocumentStore（无需新建表）来快速重连 PostgreSQL 数据库并重新加载索引。

更详细的操作指南请参阅此处