Diese Seite wurde von der Cloud Translation API übersetzt.

Daten aus einer Vektordatenbank zu AlloyDB migrieren

In dieser Anleitung wird beschrieben, wie Sie Daten aus einer Vektordatenbank eines Drittanbieters mit einem LangChain-VectorStore zu AlloyDB for PostgreSQL migrieren. In dieser Anleitung wird davon ausgegangen, dass die Daten in Vektordatenbanken von Drittanbietern mit einer LangChain VectorStore-Integration erstellt wurden. Wenn Sie Informationen in eine der folgenden Datenbanken einfügen, ohne LangChain zu verwenden, müssen Sie die unten angegebenen Skripts möglicherweise an das Schema Ihrer Daten anpassen. Die folgenden Vektordatenbanken werden unterstützt:

In dieser Anleitung wird davon ausgegangen, dass Sie mit Google Cloud, AlloyDB und der asynchronen Python-Programmierung vertraut sind.

Lernziele

In dieser Anleitung wird Folgendes beschrieben:

Daten aus einer vorhandenen Vektordatenbank extrahieren
Verbindung zu AlloyDB herstellen
Initialisieren Sie die AlloyDB-Tabelle.
Initialisieren Sie ein Vektorspeicherobjekt.
Führen Sie das Migrationsskript aus, um die Daten einzufügen.

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

AlloyDB for PostgreSQL

You might be eligible for a free trial cluster. For more information, see AlloyDB free trial clusters overview.

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen.

Neuen Google Cloud Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweise

Sie benötigen einen der folgenden LangChain-Vektorspeicher von Drittanbietern:

Abrechnung und erforderliche APIs aktivieren

Wählen Sie in der Google Cloud -Console auf der Seite für die Projektauswahl einGoogle Cloud -Projekt aus oder erstellen Sie eines.

Hinweis: Wenn Sie die Ressourcen, die Sie in dieser Anleitung erstellen, nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes Projekt auszuwählen. Wenn Sie fertig sind, können Sie das Projekt löschen und dadurch alle mit ihm verknüpften Ressourcen entfernen.

Zur Projektauswahl
Die Abrechnung für Ihr Google Cloud -Projekt muss aktiviert sein.
Aktivieren Sie die Cloud APIs, die zum Erstellen einer Verbindung zu AlloyDB for PostgreSQL erforderlich sind.

APIs aktivieren
1. Klicken Sie im Schritt Projekt bestätigen auf Weiter, um den Namen des Projekts zu bestätigen, an dem Sie Änderungen vornehmen möchten.
2. Klicken Sie im Schritt APIs aktivieren auf Aktivieren, um Folgendes zu aktivieren:
  - AlloyDB API
  - Compute Engine API
  - Service Networking API

Erforderliche Rollen

Um die Aufgaben in dieser Anleitung ausführen zu können, benötigen Sie die folgenden IAM-Rollen (Identity and Access Management), mit denen Sie Tabellen erstellen und Daten einfügen können:

Inhaber (roles/owner) oder Bearbeiter (roles/editor)
Wenn der Nutzer kein Inhaber oder Bearbeiter ist, sind die folgenden IAM-Rollen und PostgreSQL-Berechtigungen erforderlich:
- AlloyDB-Instanzclient (roles/alloydb.client)
- Cloud AlloyDB-Administrator (roles/alloydb.admin)
- Compute-Netzwerknutzer (roles/compute.networkUser)

Wenn Sie sich mit der IAM-Authentifizierung anstelle der in dieser Anleitung beschriebenen integrierten Authentifizierung bei Ihrer Datenbank authentifizieren möchten, verwenden Sie das Notebook, in dem beschrieben wird, wie Sie AlloyDB for PostgreSQL zum Speichern von Vektoreinbettungen mit der Klasse AlloyDBVectorStore verwenden.

AlloyDB-Cluster und -Nutzer erstellen

AlloyDB-Cluster und ‑Instanz erstellen
- Aktivieren Sie die öffentliche IP-Adresse, damit Sie dieses Tutorial von überall aus durchführen können. Wenn Sie private IP-Adressen verwenden, müssen Sie diese Anleitung in Ihrer VPC ausführen.
AlloyDB-Datenbanknutzer erstellen oder auswählen
- Wenn Sie die Instanz erstellen, wird ein postgres-Nutzer mit einem Passwort erstellt. Dieser Nutzer hat Superuser-Berechtigungen.
- In dieser Anleitung wird die integrierte Authentifizierung verwendet, um den Authentifizierungsaufwand zu reduzieren. Die IAM-Authentifizierung ist mit der AlloyDBEngine möglich.

Codebeispiel abrufen

Kopieren Sie das Codebeispiel aus GitHub, indem Sie das Repository klonen:

git clone https://github.com/googleapis/langchain-google-alloydb-pg-python.git

Rufen Sie das Verzeichnis migrations auf:

cd langchain-google-alloydb-pg-python/samples/migrations

Daten aus einer vorhandenen Vektordatenbank extrahieren

Client erstellen.

Pinecone

from pinecone import Pinecone  # type: ignore

pinecone_client = Pinecone(api_key=pinecone_api_key)
pinecone_index = pinecone_client.Index(pinecone_index_name)

Weaviate

import weaviate

# For a locally running weaviate instance, use `weaviate.connect_to_local()`
weaviate_client = weaviate.connect_to_weaviate_cloud(
    cluster_url=weaviate_cluster_url,
    auth_credentials=weaviate.auth.AuthApiKey(weaviate_api_key),
)

Chroma

from langchain_chroma import Chroma

chromadb_client = Chroma(
    collection_name=chromadb_collection_name,
    embedding_function=embeddings_service,
    persist_directory=chromadb_path,
)

Qdrant

from qdrant_client import QdrantClient

qdrant_client = QdrantClient(path=qdrant_path)

Milvus

milvus_client = MilvusClient(uri=milvus_uri)

Alle Daten aus der Datenbank abrufen.

Pinecone

Vektor-IDs aus dem Pinecone-Index abrufen:

results = pinecone_index.list_paginated(
    prefix="", namespace=pinecone_namespace, limit=pinecone_batch_size
)
ids = [v.id for v in results.vectors]
if ids:  # Prevents yielding an empty list.
    yield ids

# Check BOTH pagination and pagination.next
while results.pagination is not None and results.pagination.get("next") is not None:
    pagination_token = results.pagination.get("next")
    results = pinecone_index.list_paginated(
        prefix="",
        pagination_token=pagination_token,
        namespace=pinecone_namespace,
        limit=pinecone_batch_size,
    )

    # Extract and yield the next batch of IDs
    ids = [v.id for v in results.vectors]
    if ids:  # Prevents yielding an empty list.
        yield ids

Rufen Sie dann Datensätze anhand der ID aus dem Pinecone-Index ab:

import uuid

# Iterate through the IDs and download their contents
for ids in id_iterator:
    all_data = pinecone_index.fetch(ids=ids, namespace=pinecone_namespace)
    ids = []
    embeddings = []
    contents = []
    metadatas = []

    # Process each vector in the current batch
    for doc in all_data["vectors"].values():
        # You might need to update this data translation logic according to one or more of your field names
        if pinecone_id_column_name in doc:
            # pinecone_id_column_name stores the unqiue identifier for the content
            ids.append(doc[pinecone_id_column_name])
        else:
            # Generate a uuid if pinecone_id_column_name is missing in source
            ids.append(str(uuid.uuid4()))
        # values is the vector embedding of the content
        embeddings.append(doc["values"])
        # Check if pinecone_content_column_name exists in metadata before accessing
        if pinecone_content_column_name in doc.metadata:
            # pinecone_content_column_name stores the content which was encoded
            contents.append(str(doc.metadata[pinecone_content_column_name]))
            # Remove pinecone_content_column_name after processing
            del doc.metadata[pinecone_content_column_name]
        else:
            # Handle the missing pinecone_content_column_name field appropriately
            contents.append("")
        # metadata is the additional context
        metadatas.append(doc["metadata"])

    # Yield the current batch of results
    yield ids, contents, embeddings, metadatas

Weaviate

# Iterate through the IDs and download their contents
weaviate_collection = weaviate_client.collections.get(weaviate_collection_name)
ids: list[str] = []
content: list[Any] = []
embeddings: list[list[float]] = []
metadatas: list[Any] = []

for item in weaviate_collection.iterator(include_vector=True):
    # You might need to update this data translation logic according to one or more of your field names
    # uuid is the unqiue identifier for the content
    ids.append(str(item.uuid))
    # weaviate_text_key is the content which was encoded
    content.append(item.properties[weaviate_text_key])
    # vector is the vector embedding of the content
    embeddings.append(item.vector["default"])  # type: ignore
    del item.properties[weaviate_text_key]  # type: ignore
    # properties is the additional context
    metadatas.append(item.properties)

    if len(ids) >= weaviate_batch_size:
        # Yield the current batch of results
        yield ids, content, embeddings, metadatas
        # Reset lists to start a new batch
        ids = []
        content = []
        embeddings = []
        metadatas = []

Chroma

# Iterate through the IDs and download their contents
offset = 0
while True:
    # You might need to update this data translation logic according to one or more of your field names
    # documents is the content which was encoded
    # embeddings is the vector embedding of the content
    # metadatas is the additional context
    docs = chromadb_client.get(
        include=["metadatas", "documents", "embeddings"],
        limit=chromadb_batch_size,
        offset=offset,
    )

    if len(docs["documents"]) == 0:
        break

    # ids is the unqiue identifier for the content
    yield docs["ids"], docs["documents"], docs["embeddings"].tolist(), docs[
        "metadatas"
    ]

    offset += chromadb_batch_size

Qdrant

# Iterate through the IDs and download their contents
offset = None
while True:
    docs, offset = qdrant_client.scroll(
        collection_name=qdrant_collection_name,
        with_vectors=True,
        limit=qdrant_batch_size,
        offset=offset,
        with_payload=True,
    )

    ids: List[str] = []
    contents: List[Any] = []
    embeddings: List[List[float]] = []
    metadatas: List[Any] = []

    for doc in docs:
        if doc.payload and doc.vector:
            # You might need to update this data translation logic according to one or more of your field names
            # id is the unqiue identifier for the content
            ids.append(str(doc.id))
            # page_content is the content which was encoded
            contents.append(doc.payload["page_content"])
            # vector is the vector embedding of the content
            embeddings.append(doc.vector)  # type: ignore
            # metatdata is the additional context
            metadatas.append(doc.payload["metadata"])

    yield ids, contents, embeddings, metadatas

    if not offset:
        break

Milvus

# Iterate through the IDs and download their contents
iterator = milvus_client.query_iterator(
    collection_name=milvus_collection_name,
    filter='pk >= "0"',
    output_fields=["pk", "text", "vector", "idv"],
    batch_size=milvus_batch_size,
)

while True:
    ids = []
    content = []
    embeddings = []
    metadatas = []
    page = iterator.next()
    if len(page) == 0:
        iterator.close()
        break
    for i in range(len(page)):
        # You might need to update this data translation logic according to one or more of your field names
        doc = page[i]
        # pk is the unqiue identifier for the content
        ids.append(doc["pk"])
        # text is the content which was encoded
        content.append(doc["text"])
        # vector is the vector embedding of the content
        embeddings.append(doc["vector"])
        del doc["pk"]
        del doc["text"]
        del doc["vector"]
        # doc is the additional context
        metadatas.append(doc)
    yield ids, content, embeddings, metadatas

AlloyDB-Tabelle initialisieren

Einen Einbettungsdienst definieren

Für die VectorStore-Schnittstelle ist ein Einbettungsdienst erforderlich. In diesem Workflow werden keine neuen Einbettungen generiert. Daher wird die Klasse FakeEmbeddings verwendet, um Kosten zu vermeiden.

Pinecone

# The VectorStore interface requires an embedding service. This workflow does not
# generate new embeddings, therefore FakeEmbeddings class is used to avoid any costs.
from langchain_core.embeddings import FakeEmbeddings

embeddings_service = FakeEmbeddings(size=vector_size)

Weaviate

# The VectorStore interface requires an embedding service. This workflow does not
# generate new embeddings, therefore FakeEmbeddings class is used to avoid any costs.
from langchain_core.embeddings import FakeEmbeddings

embeddings_service = FakeEmbeddings(size=vector_size)

Chroma

# The VectorStore interface requires an embedding service. This workflow does not
# generate new embeddings, therefore FakeEmbeddings class is used to avoid any costs.
from langchain_core.embeddings import FakeEmbeddings

embeddings_service = FakeEmbeddings(size=vector_size)

Qdrant

# The VectorStore interface requires an embedding service. This workflow does not
# generate new embeddings, therefore FakeEmbeddings class is used to avoid any costs.
from langchain_core.embeddings import FakeEmbeddings

embeddings_service = FakeEmbeddings(size=vector_size)

Milvus

# The VectorStore interface requires an embedding service. This workflow does not
# generate new embeddings, therefore FakeEmbeddings class is used to avoid any costs.
from langchain_core.embeddings import FakeEmbeddings

embeddings_service = FakeEmbeddings(size=vector_size)

AlloyDB-Tabelle vorbereiten

Verbindung zu AlloyDB über eine öffentliche IP-Adresse herstellen Weitere Informationen finden Sie unter IP-Adresstyp angeben.

Pinecone

from langchain_google_alloydb_pg import AlloyDBEngine

alloydb_engine = await AlloyDBEngine.afrom_instance(
    project_id=project_id,
    region=region,
    cluster=cluster,
    instance=instance,
    database=db_name,
    user=db_user,
    password=db_pwd,
    ip_type=IPTypes.PUBLIC,  # Optionally use IPTypes.PRIVATE
)

Weaviate

from langchain_google_alloydb_pg import AlloyDBEngine

alloydb_engine = await AlloyDBEngine.afrom_instance(
    project_id=project_id,
    region=region,
    cluster=cluster,
    instance=instance,
    database=db_name,
    user=db_user,
    password=db_pwd,
    ip_type=IPTypes.PUBLIC,
)

Chroma

from langchain_google_alloydb_pg import AlloyDBEngine

alloydb_engine = await AlloyDBEngine.afrom_instance(
    project_id=project_id,
    region=region,
    cluster=cluster,
    instance=instance,
    database=db_name,
    user=db_user,
    password=db_pwd,
    ip_type=IPTypes.PUBLIC,
)

Qdrant

from langchain_google_alloydb_pg import AlloyDBEngine

alloydb_engine = await AlloyDBEngine.afrom_instance(
    project_id=project_id,
    region=region,
    cluster=cluster,
    instance=instance,
    database=db_name,
    user=db_user,
    password=db_pwd,
    ip_type=IPTypes.PUBLIC,
)

Milvus

from langchain_google_alloydb_pg import AlloyDBEngine

alloydb_engine = await AlloyDBEngine.afrom_instance(
    project_id=project_id,
    region=region,
    cluster=cluster,
    instance=instance,
    database=db_name,
    user=db_user,
    password=db_pwd,
    ip_type=IPTypes.PUBLIC,
)

Erstellen Sie eine Tabelle, in die die Daten kopiert werden sollen, falls sie noch nicht vorhanden ist.

Pinecone

from langchain_google_alloydb_pg import Column

await alloydb_engine.ainit_vectorstore_table(
    table_name=alloydb_table,
    vector_size=vector_size,
    # Customize the ID column types if not using the UUID data type
    # id_column=Column("langchain_id", "TEXT"),  # Default is Column("langchain_id", "UUID")
    # overwrite_existing=True,  # Drop the old table and Create a new vector store table
)

Weaviate

await alloydb_engine.ainit_vectorstore_table(
    table_name=alloydb_table,
    vector_size=vector_size,
    # Customize the ID column types with `id_column` if not using the UUID data type
)

Chroma

await alloydb_engine.ainit_vectorstore_table(
    table_name=alloydb_table,
    vector_size=vector_size,
    # Customize the ID column types with `id_column` if not using the UUID data type
)

Qdrant

await alloydb_engine.ainit_vectorstore_table(
    table_name=alloydb_table,
    vector_size=vector_size,
    # Customize the ID column types with `id_column` if not using the UUID data type
)

Milvus

await alloydb_engine.ainit_vectorstore_table(
    table_name=alloydb_table,
    vector_size=vector_size,
    # Customize the ID column types with `id_column` if not using the UUID data type
)

Vektorspeicherobjekt initialisieren

Mit diesem Code werden der Spalte langchain_metadata zusätzliche Metadaten für die Vektoreinbettung im JSON-Format hinzugefügt. Um das Filtern effizienter zu gestalten, sollten Sie diese Metadaten in separaten Spalten organisieren. Weitere Informationen finden Sie unter Benutzerdefinierten Vektorspeicher erstellen.

Führen Sie den folgenden Befehl aus, um ein Vektorspeicherobjekt zu initialisieren:

Pinecone

from langchain_google_alloydb_pg import AlloyDBVectorStore

vs = await AlloyDBVectorStore.create(
    engine=alloydb_engine,
    embedding_service=embeddings_service,
    table_name=alloydb_table,
)

Weaviate

from langchain_google_alloydb_pg import AlloyDBVectorStore

vs = await AlloyDBVectorStore.create(
    engine=alloydb_engine,
    embedding_service=embeddings_service,
    table_name=alloydb_table,
)

Chroma

from langchain_google_alloydb_pg import AlloyDBVectorStore

vs = await AlloyDBVectorStore.create(
    engine=alloydb_engine,
    embedding_service=embeddings_service,
    table_name=alloydb_table,
)

Qdrant

from langchain_google_alloydb_pg import AlloyDBVectorStore

vs = await AlloyDBVectorStore.create(
    engine=alloydb_engine,
    embedding_service=embeddings_service,
    table_name=alloydb_table,
)

Milvus

from langchain_google_alloydb_pg import AlloyDBVectorStore

vs = await AlloyDBVectorStore.create(
    engine=alloydb_engine,
    embedding_service=embeddings_service,
    table_name=alloydb_table,
)

Fügen Sie Daten in die AlloyDB-Tabelle ein:

Pinecone

pending: set[Any] = set()
for ids, contents, embeddings, metadatas in data_iterator:
    pending.add(
        asyncio.ensure_future(
            vs.aadd_embeddings(
                texts=contents,
                embeddings=embeddings,
                metadatas=metadatas,
                ids=ids,
            )
        )
    )
    if len(pending) >= max_concurrency:
        _, pending = await asyncio.wait(
            pending, return_when=asyncio.FIRST_COMPLETED
        )
if pending:
    await asyncio.wait(pending)

Weaviate

pending: set[Any] = set()
for ids, contents, embeddings, metadatas in data_iterator:
    pending.add(
        asyncio.ensure_future(
            vs.aadd_embeddings(
                texts=contents,
                embeddings=embeddings,
                metadatas=metadatas,
                ids=ids,
            )
        )
    )
    if len(pending) >= max_concurrency:
        _, pending = await asyncio.wait(
            pending, return_when=asyncio.FIRST_COMPLETED
        )
if pending:
    await asyncio.wait(pending)

Chroma

pending: set[Any] = set()
for ids, contents, embeddings, metadatas in data_iterator:
    pending.add(
        asyncio.ensure_future(
            vs.aadd_embeddings(
                texts=contents,
                embeddings=embeddings,
                metadatas=metadatas,
                ids=ids,
            )
        )
    )
    if len(pending) >= max_concurrency:
        _, pending = await asyncio.wait(
            pending, return_when=asyncio.FIRST_COMPLETED
        )
if pending:
    await asyncio.wait(pending)

Qdrant

pending: set[Any] = set()
for ids, contents, embeddings, metadatas in data_iterator:
    pending.add(
        asyncio.ensure_future(
            vs.aadd_embeddings(
                texts=contents,
                embeddings=embeddings,
                metadatas=metadatas,
                ids=ids,
            )
        )
    )
    if len(pending) >= max_concurrency:
        _, pending = await asyncio.wait(
            pending, return_when=asyncio.FIRST_COMPLETED
        )
if pending:
    await asyncio.wait(pending)

Milvus

pending: set[Any] = set()
for ids, contents, embeddings, metadatas in data_iterator:
    pending.add(
        asyncio.ensure_future(
            vs.aadd_embeddings(
                texts=contents,
                embeddings=embeddings,
                metadatas=metadatas,
                ids=ids,
            )
        )
    )
    if len(pending) >= max_concurrency:
        _, pending = await asyncio.wait(
            pending, return_when=asyncio.FIRST_COMPLETED
        )
if pending:
    await asyncio.wait(pending)

Migrationsskript ausführen

Python-Umgebung einrichten
Installieren Sie die Beispielabhängigkeiten:
```
pip install -r requirements.txt
```
Führen Sie die Beispielmigration aus.
Pinecone
```
python migrate_pinecone_vectorstore_to_alloydb.py
```
Nehmen Sie die folgenden Änderungen vor, bevor Sie das Beispiel ausführen:
- PINECONE_API_KEY: Der Pinecone-API-Schlüssel.
- PINECONE_NAMESPACE: der Pinecone-Namespace.
- PINECONE_INDEX_NAME: Der Name des Pinecone-Index.
- PROJECT_ID: Projekt-ID.
- REGION: Die Region, in der der AlloyDB-Cluster bereitgestellt wird.
- CLUSTER ist der Name des Clusters.
- INSTANCE: der Name der Instanz.
- DB_NAME: der Name der Datenbank
- DB_USER: der Name des Datenbanknutzers
- DB_PWD: Das Secret-Passwort für die Datenbank.
Weaviate
```
python migrate_weaviate_vectorstore_to_alloydb.py
```
Nehmen Sie die folgenden Änderungen vor, bevor Sie das Beispiel ausführen:
- WEAVIATE_API_KEY: Der Weaviate-API-Schlüssel.
- WEAVIATE_CLUSTER_URL: die Weaviate-Cluster-URL.
- WEAVIATE_COLLECTION_NAME: der Name der Weaviate-Sammlung.
- PROJECT_ID: Projekt-ID.
- REGION: Die Region, in der der AlloyDB-Cluster bereitgestellt wird.
- CLUSTER ist der Name des Clusters.
- INSTANCE: der Name der Instanz.
- DB_NAME: der Name der Datenbank
- DB_USER: der Name des Datenbanknutzers
- DB_PWD: Das Secret-Passwort für die Datenbank.
Chroma
```
python migrate_chromadb_vectorstore_to_alloydb.py
```
Nehmen Sie die folgenden Änderungen vor, bevor Sie das Beispiel ausführen:
- CHROMADB_PATH: Der Chroma-Datenbankpfad.
- CHROMADB_COLLECTION_NAME: Der Name der Chroma-Datenbanksammlung.
- PROJECT_ID: Projekt-ID.
- REGION: Die Region, in der der AlloyDB-Cluster bereitgestellt wird.
- CLUSTER ist der Name des Clusters.
- INSTANCE: der Name der Instanz.
- DB_NAME: der Name der Datenbank
- DB_USER: der Name des Datenbanknutzers
- DB_PWD: Das Secret-Passwort für die Datenbank.
Qdrant
```
python migrate_qdrant_vectorstore_to_alloydb.py
```
Nehmen Sie die folgenden Änderungen vor, bevor Sie das Beispiel ausführen:
- QDRANT_PATH: Der Qdrant-Datenbankpfad.
- QDRANT_COLLECTION_NAME: Der Name der Qdrant-Sammlung.
- PROJECT_ID: Projekt-ID.
- REGION: Die Region, in der der AlloyDB-Cluster bereitgestellt wird.
- CLUSTER ist der Name des Clusters.
- INSTANCE: der Name der Instanz.
- DB_NAME: der Name der Datenbank
- DB_USER: der Name des Datenbanknutzers
- DB_PWD: Das Secret-Passwort für die Datenbank.
Milvus
```
python migrate_milvus_vectorstore_to_alloydb.py
```
Nehmen Sie die folgenden Änderungen vor, bevor Sie das Beispiel ausführen:
- MILVUS_URI: Der Milvus-URI.
- MILVUS_COLLECTION_NAME: Der Name der Milvus-Sammlung.
- PROJECT_ID: Projekt-ID.
- REGION: Die Region, in der der AlloyDB-Cluster bereitgestellt wird.
- CLUSTER ist der Name des Clusters.
- INSTANCE: der Name der Instanz.
- DB_NAME: der Name der Datenbank
- DB_USER: der Name des Datenbanknutzers
- DB_PWD: Das Secret-Passwort für die Datenbank.
Bei einer erfolgreichen Migration werden Protokolle ähnlich den folgenden ohne Fehler ausgegeben:
Migration completed, inserted all the batches of data to AlloyDB
Öffnen Sie AlloyDB Studio, um Ihre migrierten Daten anzusehen. Weitere Informationen finden Sie unter Daten mit AlloyDB Studio verwalten.

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Rufen Sie in der Google Cloud Console die Seite Cluster auf.

Zu den Clustern
Klicken Sie in der Spalte Ressourcenname auf den Namen des Clusters, den Sie erstellt haben.
Klicken Sie auf Cluster löschen.
Geben Sie unter Cluster löschen den Namen des Clusters ein, um zu bestätigen, dass Sie ihn löschen möchten.
Klicken Sie auf Löschen.

Wenn Sie beim Erstellen eines Clusters eine private Verbindung erstellt haben, löschen Sie sie:
Rufen Sie in der Google Cloud -Console die Seite „Netzwerk“ auf und klicken Sie auf VPC-Netzwerk löschen.

Daten aus einer Vektordatenbank zu AlloyDB migrieren Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Lernziele

Kosten

Hinweise

Abrechnung und erforderliche APIs aktivieren

Erforderliche Rollen

AlloyDB-Cluster und -Nutzer erstellen

Codebeispiel abrufen

Daten aus einer vorhandenen Vektordatenbank extrahieren

Pinecone

Weaviate

Chroma

Qdrant

Milvus

Pinecone

Weaviate

Chroma

Qdrant

Milvus

AlloyDB-Tabelle initialisieren

Pinecone

Weaviate

Chroma

Qdrant

Milvus

Pinecone

Weaviate

Chroma

Qdrant

Milvus

Pinecone

Weaviate

Chroma

Qdrant

Milvus

Vektorspeicherobjekt initialisieren

Pinecone

Weaviate

Chroma

Qdrant

Milvus

Pinecone

Weaviate

Chroma

Qdrant

Milvus

Migrationsskript ausführen

Pinecone

Weaviate

Chroma

Qdrant

Milvus

Bereinigen

Nächste Schritte

Daten aus einer Vektordatenbank zu AlloyDB migrieren