Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Eseguire la migrazione dei dati da un database vettoriale ad AlloyDB

Puoi eseguire la migrazione di vector embedding e metadati da database vettoriali di terze parti ad AlloyDB per PostgreSQL utilizzando un'integrazione VectorStore di LangChain. In questo tutorial, esporterai i dati vettoriali esistenti generati con LangChain e li caricherai in una tabella AlloyDBVectorStore. Se hai importato i dati in uno dei seguenti database senza utilizzare LangChain, modifica gli script di migrazione forniti in modo che corrispondano allo schema dei dati. Sono supportati i seguenti database vettoriali:

Questo tutorial presuppone che tu abbia familiarità con Google Cloud, AlloyDB e la programmazione Python asincrona.

Obiettivi

Questo tutorial mostra gli aspetti seguenti:

Estrarre i dati da un database vettoriale esistente.
Connettiti ad AlloyDB.
Inizializza la tabella AlloyDB.
Inizializza un oggetto datastore vettoriale.
Esegui lo script di migrazione per inserire i dati.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

AlloyDB for PostgreSQL

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

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Al termine delle attività descritte in questo documento, puoi evitare l'addebito di ulteriori costi eliminando le risorse che hai creato. Per saperne di più, consulta Esegui la pulizia.

Prima di iniziare

Assicurati di avere uno dei seguenti archivi vettoriali di database di terze parti LangChain:

Abilita la fatturazione e le API richieste

Nella console Google Cloud , nella pagina di selezione del progetto, seleziona o crea un progettoGoogle Cloud .

Nota: se non prevedi di conservare le risorse che crei in questo tutorial, crea un progetto invece di selezionarne uno già esistente. Una volta completata questa procedura, puoi eliminare il progetto e tutte le relative risorse.

Vai al selettore di progetti
Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud .
Abilita le API Cloud necessarie per creare e connettersi ad AlloyDB per PostgreSQL.

Abilita le API
1. Nel passaggio Conferma progetto, fai clic su Avanti per confermare il nome del progetto a cui apporterai le modifiche.
2. Nel passaggio Abilita API, fai clic su Abilita per abilitare quanto segue:
  - API AlloyDB
  - API Compute Engine
  - API Service Networking

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per completare le attività di questo tutorial, disponi dei seguenti ruoli Identity and Access Management (IAM) che consentono la creazione di tabelle e l'inserimento di dati:

Proprietario (roles/owner) o Editor (roles/editor)
Se l'utente non è un proprietario o un editor, sono richiesti i seguenti ruoli IAM e privilegi PostgreSQL:
- Client istanza AlloyDB (roles/alloydb.client)
- Cloud AlloyDB Admin (roles/alloydb.admin)
- Compute Network User (roles/compute.networkUser)

Se vuoi autenticarti nel tuo database utilizzando l'autenticazione IAM anziché l'autenticazione integrata in questo tutorial, utilizza il notebook che mostra come utilizzare AlloyDB per PostgreSQL per archiviare i vector embedding con la classe AlloyDBVectorStore.

Crea un cluster e un utente AlloyDB

Crea un cluster e un'istanza AlloyDB.
- Abilita l'IP pubblico per eseguire questo tutorial da qualsiasi luogo. Se utilizzi un IP privato, devi eseguire questo tutorial dall'interno del VPC.
Crea o seleziona un utente del database AlloyDB.
- Quando crei l'istanza, viene creato un utente postgres con una password. Questo utente dispone delle autorizzazioni di super utente.
- Questo tutorial utilizza l'autenticazione integrata per ridurre eventuali problemi di autenticazione. L'autenticazione IAM è possibile utilizzando AlloyDBEngine.

Recupera l'esempio di codice

Copia l'esempio di codice da GitHub clonando il repository:

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

Vai alla directory migrations:

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

Estrai dati da un database vettoriale esistente

Crea un cliente.

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)

Recupera tutti i dati dal database.

Pinecone

Recupera gli ID vettoriali dall'indice Pinecone:

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

Quindi, recupera i record per ID dall'indice Pinecone:

import uuid

# Iterate through the IDs and download their contents
for ids_batch in id_iterator:
    all_data = pinecone_index.fetch(ids=ids_batch, 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.metadata:
            # 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

Inizializza la tabella AlloyDB

Definisci il servizio di incorporamento.

L'interfaccia VectorStore richiede un servizio di embedding. Questo flusso di lavoro non genera nuovi incorporamenti, quindi la classe FakeEmbeddings viene utilizzata per evitare costi.

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)

Prepara la tabella AlloyDB.

Connettiti ad AlloyDB utilizzando una connessione IP pubblico. Per saperne di più, consulta Specifica del tipo di indirizzo IP.

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

Crea una tabella in cui copiare i dati, se non esiste già.

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
)

Inizializza un oggetto datastore vettoriale

Questo codice aggiunge metadati di vector embedding aggiuntivi alla colonna langchain_metadata in formato JSON. Per rendere più efficiente l'applicazione dei filtri, organizza questi metadati in colonne separate. Per saperne di più, consulta Creare un archivio vettoriale personalizzato.

Per inizializzare un oggetto vector store, esegui questo comando:

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

Inserisci i dati nella tabella AlloyDB:

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)

Esegui lo script di migrazione

Configura l'ambiente Python.
Installa le dipendenze di esempio:
```
pip install -r requirements.txt
```
Esegui la migrazione di esempio.
Pinecone
python migrate_pinecone_vectorstore_to_alloydb.py
Apporta le seguenti sostituzioni prima di eseguire l'esempio:
- PINECONE_API_KEY: la chiave API Pinecone.
- PINECONE_NAMESPACE: lo spazio dei nomi Pinecone.
- PINECONE_INDEX_NAME: il nome dell'indice Pinecone.
- PROJECT_ID: l'ID progetto
- REGION: la regione in cui viene eseguito il deployment del cluster AlloyDB.
- CLUSTER: il nome del cluster.
- INSTANCE: il nome dell'istanza
- DB_NAME: il nome del database.
- DB_USER: il nome dell'utente del database.
- DB_PWD: la password del secret del database.
Weaviate
python migrate_weaviate_vectorstore_to_alloydb.py
Apporta le seguenti sostituzioni prima di eseguire l'esempio:
- WEAVIATE_API_KEY: la chiave API di Weaviate.
- WEAVIATE_CLUSTER_URL: l'URL del cluster Weaviate.
- WEAVIATE_COLLECTION_NAME: il nome della raccolta Weaviate.
- PROJECT_ID: l'ID progetto
- REGION: la regione in cui viene eseguito il deployment del cluster AlloyDB.
- CLUSTER: il nome del cluster.
- INSTANCE: il nome dell'istanza
- DB_NAME: il nome del database.
- DB_USER: il nome dell'utente del database.
- DB_PWD: la password del secret del database.
Chroma
python migrate_chromadb_vectorstore_to_alloydb.py
Apporta le seguenti sostituzioni prima di eseguire l'esempio:
- CHROMADB_PATH: il percorso del database Chroma.
- CHROMADB_COLLECTION_NAME: il nome della raccolta del database Chroma.
- PROJECT_ID: l'ID progetto
- REGION: la regione in cui viene eseguito il deployment del cluster AlloyDB.
- CLUSTER: il nome del cluster.
- INSTANCE: il nome dell'istanza
- DB_NAME: il nome del database.
- DB_USER: il nome dell'utente del database.
- DB_PWD: la password del secret del database.
Qdrant
python migrate_qdrant_vectorstore_to_alloydb.py
Apporta le seguenti sostituzioni prima di eseguire l'esempio:
- QDRANT_PATH: il percorso del database Qdrant.
- QDRANT_COLLECTION_NAME: il nome della raccolta Qdrant.
- PROJECT_ID: l'ID progetto
- REGION: la regione in cui viene eseguito il deployment del cluster AlloyDB.
- CLUSTER: il nome del cluster.
- INSTANCE: il nome dell'istanza
- DB_NAME: il nome del database.
- DB_USER: il nome dell'utente del database.
- DB_PWD: la password del secret del database.
Milvus
python migrate_milvus_vectorstore_to_alloydb.py
Apporta le seguenti sostituzioni prima di eseguire l'esempio:
- MILVUS_URI: l'URI di Milvus.
- MILVUS_COLLECTION_NAME: il nome della raccolta Milvus.
- PROJECT_ID: l'ID progetto
- REGION: la regione in cui viene eseguito il deployment del cluster AlloyDB.
- CLUSTER: il nome del cluster.
- INSTANCE: il nome dell'istanza
- DB_NAME: il nome del database.
- DB_USER: il nome dell'utente del database.
- DB_PWD: la password del secret del database.
Una migrazione riuscita stampa log simili ai seguenti senza errori:
Migration completed, inserted all the batches of data to AlloyDB
Apri AlloyDB Studio per visualizzare i dati di cui è stata eseguita la migrazione. Per saperne di più, vedi Gestisci i tuoi dati utilizzando AlloyDB Studio.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Nella console Google Cloud , vai alla pagina Cluster.

Vai a Cluster
Nella colonna Nome risorsa, fai clic sul nome del cluster che hai creato.
Fai clic su Elimina cluster.
In Elimina cluster, inserisci il nome del cluster per confermare che vuoi eliminarlo.
Fai clic su Elimina.

Se hai creato una connessione privata quando hai creato un cluster, elimina la connessione privata:
Vai alla pagina Rete della console Google Cloud e fai clic su Elimina rete VPC.

Eseguire la migrazione dei dati da un database vettoriale ad AlloyDB Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Obiettivi

Costi

Prima di iniziare

Abilita la fatturazione e le API richieste

Ruoli obbligatori

Crea un cluster e un utente AlloyDB

Recupera l'esempio di codice

Estrai dati da un database vettoriale esistente

Pinecone

Weaviate

Chroma

Qdrant

Milvus

Pinecone

Weaviate

Chroma

Qdrant

Milvus

Inizializza la tabella AlloyDB

Pinecone

Weaviate

Chroma

Qdrant

Milvus

Pinecone

Weaviate

Chroma

Qdrant

Milvus

Pinecone

Weaviate

Chroma

Qdrant

Milvus

Inizializza un oggetto datastore vettoriale

Pinecone

Weaviate

Chroma

Qdrant

Milvus

Pinecone

Weaviate

Chroma

Qdrant

Milvus

Esegui lo script di migrazione

Pinecone

Weaviate

Chroma

Qdrant

Milvus

Esegui la pulizia

Passaggi successivi

Eseguire la migrazione dei dati da un database vettoriale ad AlloyDB