跳到内容

文档存储#

文档存储包含摄入的文档块，我们称之为 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 数据库并重新加载索引。

Tablestore 文档存储#

我们支持 Tablestore 作为替代文档存储后端，它在摄入 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 连接到 Tablestore 数据库，并将您的节点添加到名为 {namespace}_data 的表。

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

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

更完整的示例可以在此处找到

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

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

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

# initialize a new table in cloud sql postgres
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)

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

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

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

在底层，PostgresDocumentStore 连接到 Google Cloud 中的 Cloud SQL for PostgreSQL 数据库，并将您的节点添加到 schema_name 下的表中。

您可以通过使用 PostgresEngine 重新初始化 PostgresDocumentStore 来轻松地重新连接到您的 PostgreSQL 数据库并重新加载索引，而无需初始化新表。

更详细的指南可以在此处找到