Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Dokumente in einem Datenspeicher suchen

Die verwaltete Aufnahmepipeline importiert Dokumente aus Datenspeichern in den Agentenabruf in Datenobjekte und Sammlungen, die Sie mit Textabfragen durchsuchen können. Das Parsen, Segmentieren, Einbetten und Indexieren wird automatisch für Sie übernommen.

Unterstützte Dokumentformate

In der folgenden Tabelle sind die unterstützten Dokumentdateiformate und Dateiendungen aufgeführt.

Dokumenttyp	Dateiendung
PDF	`.pdf`
Nur-Text	`.txt`
Microsoft Word	`.docx`
Microsoft Excel	`.xlsx`
Microsoft Excel-Datei mit aktivierten Makros	`.xlsm` (Skripts und Makros werden ignoriert)
Microsoft PowerPoint	`.pptx`

Vorbereitung

Voraussetzungen:

Ein Projekt in Google Cloud . Informationen zum Erstellen eines Google Cloud -Projekts finden Sie unter Projekt und Entwicklungsumgebung einrichten.
Einen Cloud Storage-Bucket mit den Dateien, die Sie durchsuchen möchten.
Die Berechtigung roles/vectorsearch.serviceAgent, die dem Dienst-Agenten service-PROJECT_NUMBER@gcp-sa-vectorsearch.iam.gserviceaccount.com für das Projekt des Buckets gewährt wurde.

Beispiele

Die Beispiele auf dieser Seite basieren auf den folgenden Beispieldateien.

curl

PROJECT=acme-prod
LOCATION=us-east4
BASE=https://vectorsearch.googleapis.com/v1alpha
INGEST=${BASE}/projects/${PROJECT}/locations/${LOCATION}
AUTH="Authorization: Bearer $(gcloud auth print-access-token)"

Python

import time
import google.auth
from google.auth.transport.requests import AuthorizedSession

PROJECT = "acme-prod"          # Replace with your project ID
LOCATION = "us-east4"          # Replace with your region

credentials, _ = google.auth.default(
    scopes=["https://www.googleapis.com/auth/cloud-platform"]
)
session = AuthorizedSession(credentials)

BASE = "https://vectorsearch.googleapis.com/v1alpha"
INGEST = BASE + "/projects/" + PROJECT + "/locations/" + LOCATION

def wait(operation, poll_seconds=10):
    """Poll a long-running operation until it finishes, then return it."""
    name = operation["name"]
    while True:
        op = session.get(BASE + "/" + name).json()
        if op.get("done"):
            if "error" in op:
                raise RuntimeError(op["error"])
            return op
        meta = op.get("metadata", {})
        print("in progress:", meta)
        time.sleep(poll_seconds)

Die verwaltete Aufnahmepipeline

Die verwaltete Aufnahmepipeline importiert Dokumente aus Ihrem Datenspeicher in Agent Retrieval und übernimmt den Großteil der Arbeit beim Einrichten von Datenobjekten und Sammlungen für Sie.

Dafür musst du einfach nur:

Dateien bereitstellen
Erstellen Sie einen Datenspeicher.
Importieren Sie Ihre Dateien.
Suchen Sie mit Textabfragen nach Ihren Dateien.

1. Dateien bereitstellen

Erstellen Sie einen Bucket und fügen Sie die Dateien hinzu, die Sie durchsuchen möchten. Sie müssen kein Manifest erstellen.

Verwaltete Aufnahme von Dokumenten:

Dokumente, die größer als 200 MB sind, werden übersprungen.
Ignoriert Makros und Skripts in Microsoft Excel-Dokumenten mit aktivierten Makros (.xlsm).
Es werden jeweils nur 100.000 Dokumente importiert.

Sie können auch JSONL-Dateien bereitstellen, die Metadaten für Ihre Dateien definieren. Weitere Informationen finden Sie unter Metadaten für Dateien hinzufügen.

2. Datenspeicher erstellen

Nachdem Sie die Dateien, die Sie durchsuchen möchten, bereitgestellt haben, müssen Sie einen Datenspeicher erstellen. Der Datenspeicher ist die Quelle für die verwaltete Aufnahmepipeline und die Konfiguration, die angibt, wie Ihre Dateien aufgenommen werden.

Die verwaltete Aufnahme ist nur für Datenspeicher in der Region us-east4 oder europe-west4 verfügbar.

Wenn Sie einen Datenspeicher erstellen möchten, senden Sie eine POST-Anfrage an die dataStores API und geben Sie den folgenden Parameter an:

data_store_id: Die ID für den zu erstellenden Datenspeicher. Er muss mit einem Kleinbuchstaben beginnen, mit einem Kleinbuchstaben oder einer Ziffer enden, darf nur Kleinbuchstaben, Ziffern und Bindestriche enthalten und muss zwischen 1 und 63 Zeichen lang sein.

Die JSON-Nutzlast enthält die JSON-Konfigurationseinstellungen, die von der verwalteten Aufnahme verwendet werden, um den Datenspeicher zu erstellen und die von Ihnen bereitgestellten Dokumente zu verarbeiten.

Die JSON-Nutzlast muss das Attribut document_type auf oberster Ebene enthalten. Damit werden die Dateitypen angegeben, die aus dem Datenspeicher importiert werden sollen. Gültige Werte sind:

UNSTRUCTURED: Der Datenspeicher enthält Dokumente. Eine Liste der unterstützten Formate finden Sie unter Unterstützte Dokumentformate.
VIDEO: Der Datenspeicher enthält Videos.

Die folgenden Attribute sind optional:

display_name: (STRING) Der Anzeigename des Datenspeichers. Die maximale Größe beträgt 1.024 Byte. Der Standardwert ist ein leerer String.
description: (STRING) Die Beschreibung des Datenspeichers. Die maximale Größe beträgt 1.024 Byte. Der Standardwert ist ein leerer String.
labels: (STRING-Array) Ein Array von Schlüssel/Wert-Paaren. Weitere Informationen finden Sie unter Ressourcen mithilfe von Labels organisieren. Der Standardwert ist ein leeres Array.
processing_config: (OBJECT): Die Konfiguration für die Verarbeitung der Daten im Datenspeicher durch die verwaltete Aufnahme. Dies kann mit einer PATCH-Anfrage aktualisiert werden. Informationen zu den Standardeinstellungen, wenn sie weggelassen werden, finden Sie unter Optionale Einstellungen für Dokumentdatenspeicher.
document_metadata_schema: (OBJECT): Das Metadatenschema für Metadaten, die mit den Dokumenten im Datenspeicher verknüpft sind. Weitere Informationen finden Sie unter Metadatenschema hinzufügen. Der Standardwert ist ein leeres Objekt (kein Metadatenschema).

Optionale Einstellungen für Dokumentdateien

Für Dokumentdatenspeicher sind die folgenden optionalen Einstellungen verfügbar:

processing_config.unstructured_processing_config.segmentation_config: (OBJECT) Die Aufnahmekonfiguration für die Segmentierung des Dokuments (Suchanfragen erfolgen pro Segment, nicht pro Dokument). Weitere Informationen finden Sie unter Dokumentsegmentierung. Ein leeres Objekt führt dazu, dass die Anfrage mit dem Status INVALID_ARGUMENT abgelehnt wird. Falls angegeben, muss er eines der folgenden Elemente enthalten:
- page_segmentation_config: (OBJECT) Dieses Objekt hat keine Properties.
- chunk_segmentation_config: (OBJECT) Hat die folgenden Eigenschaften:
- chunk_size: (INTEGER) Die maximale Anzahl von Tokens in einem Segment. Der Wert muss zwischen 300 und dem maximalen Wert 500 liegen. Der Standardwert ist 500.
- include_ancestor_headings: (BOOL) Stellt jedem Block eine Kette von Abschnittsüberschriften voran, um Kontext zu bieten. Der Standardwert ist false.
processing_config.unstructured_processing_config.parsing_config: (OBJECT) Die Aufnahme-Konfiguration für das Parsen des Dokuments. Weitere Informationen finden Sie unter Dokumente parsen. Ein leeres Objekt führt dazu, dass die Anfrage mit dem Status INVALID_ARGUMENT abgelehnt wird. Falls angegeben, muss er einen der folgenden Werte enthalten:
- layout_parsing_config: (OBJECT) Es wird das Layoutparsing verwendet. Dieses Objekt hat keine Attribute.
- digital_parsing_config: (OBJECT) Es wird digitales Parsing verwendet. Dieses Objekt hat keine Attribute.
processing_config.unstructured_processing_config.embedding_config.mode: (STRING) Der zu verwendende Einbettungsmodus. Folgende sind möglich:
- TEXT: Nur extrahierter Text wird eingebettet. Bilder werden ignoriert. Der Standardwert ist TEXT.

Sie können Ihrem Datenspeicher auch Metadaten hinzufügen. Weitere Informationen finden Sie unter Metadaten für Dateien hinzufügen.

Beispiele

In den folgenden Beispielen wird gezeigt, wie Sie einen Dokumentdatenspeicher erstellen.

curl

  curl -X POST -H "${AUTH}" -H "Content-Type: application/json" \
  "${INGEST}/dataStores?data_store_id=acme-financials" \
  -d '{
    "display_name": "Acme financial reports",
    "document_type": "UNSTRUCTURED",
    "processing_config": {
      "unstructured_processing_config": {
        "segmentation_config": {
          "chunk_segmentation_config": {
            "chunk_size": 300,
            "include_ancestor_headings": true
          }
        },
        "parsing_config": {
          "layout_parsing_config": {}
        }
      }
    }
  }'

Python

  op = session.post(
    INGEST + "/dataStores",
    params={"data_store_id": "acme-financials"},
    json={
        "display_name": "Acme financial reports",
        "document_type": "UNSTRUCTURED",
        "processing_config": {
            "unstructured_processing_config": {
                "segmentation_config": {
                    "chunk_segmentation_config": {
                        "chunk_size": 300,
                        "include_ancestor_headings": True,
                    }
                },
                "parsing_config": {"layout_parsing_config": {}},
            }
        },
    },
).json()

wait(op)

Beispielantwort

  "name": "projects/acme-prod/locations/us-east4/dataStores/acme-financials",
  "documentType": "UNSTRUCTURED",
  "state": "ACTIVE",
  "collectionName": "projects/acme-prod/locations/us-east4/collections/google-acme-financials"
}

Metadaten für Ihre Dateien hinzufügen

Sie können Metadatenattribute für die Dateien definieren, die Sie mit der verwalteten Aufnahme importieren möchten. Diese Attribute können aus den entsprechenden Datenobjekten abgerufen werden, die von der Pipeline erstellt wurden, und sind nützlich, um Suchergebnisse zu filtern.

So definieren Sie Metadaten:

Erstellen Sie eine JSONL-Datei. Die Erweiterung sollte json oder jsonl sein.
Fügen Sie für jede Datei, die Sie importieren möchten, ein JSON-Objekt in einer neuen Zeile hinzu und geben Sie die folgenden Attribute an:
- name: Der Name der Datei im Datenspeicher. Das letzte Segment des Namens wird als ID für das Datenobjekt verwendet, das für die Datei erstellt wurde.
- content.gcsUri: Der URI des Dokuments in Cloud Storage.
- metadata.value: Die Metadaten des Dokuments. Die Metadatenattribute werden in einem Schema definiert, das Sie beim Erstellen des Datenspeichers angeben. Weitere Informationen finden Sie unter Metadatenschema hinzufügen.

Das folgende Beispiel zeigt eine JSONL-Metadatendatei mit den Metadatenattributen category, year, tags und issuer.

{"name":"projects/acme-prod/locations/us-east4/dataStores/acme-financials/documents/q3-earnings","content":{"gcsUri":"gs://acme-docs/reports/2025-q3-earnings.pdf"},"metadata":{"value":{"category":"earnings","year":2025,"tags":["revenue"],"issuer":{"country":"US"}}}}
{"name":"projects/acme-prod/locations/us-east4/dataStores/acme-financials/documents/covenants","content":{"gcsUri":"gs://acme-docs/reports/covenant-summary.docx"},"metadata":{"value":{"category":"covenant","year":2024,"tags":["credit","debt"]}}}

Die Attribute müssen mit einem Schema übereinstimmen, das Sie beim Erstellen des Datenspeichers angeben.

Sie verwenden die von Ihnen erstellten JSONL-Dateien als Eingabe-URIs, wenn Sie Ihre Dateien importieren.

Metadatenschema hinzufügen

Sie können ein Metadatenschema im Attribut document_metadata_schema auf oberster Ebene in der JSON-Konfiguration des Datenspeichers angeben. Damit wird ein Vertrag für die Metadaten definiert, die Sie mit Ihren Dokumenten verknüpfen können. Diese Metadaten können pro Dokument abgerufen oder zum Filtern von Suchergebnissen verwendet werden.

Metadatenattribute müssen mit dem Schema übereinstimmen, das Sie beim Erstellen des Datenspeichers angeben. Das Schema folgt eng dem JSON-Schemaentwurf 7. Folgende Datentypen werden unterstützt:

string
number
integer
boolean
object (einschließlich Properties)
array

Attributnamen dürfen nur Buchstaben, Ziffern, Unterstriche (_) und Bindestriche (-) enthalten und dürfen nicht mit google (beliebige Groß-/Kleinschreibung) beginnen. Das Präfix ist für Felder reserviert, die der Dienst schreibt.

Sie können Eigenschaften später mit einer PATCH-Anfrage hinzufügen. Eigenschaften im Schema können nicht entfernt und ihr Datentyp kann nicht geändert werden. Weitere Informationen finden Sie unter Verarbeitungskonfiguration aktualisieren.

Im folgenden Beispiel wird ein Metadatenschema mit den Metadatenattributen category, year, tags und issuer definiert.

"document_metadata_schema": {
  "schema": {
    "type": "object",
    "properties": {
      "category": {"type": "string"},
      "year":     {"type": "integer"},
      "tags":     {"type": "array", "items": {"type": "string"}},
      "issuer":   {"type": "object", "properties": {"country": {"type": "string"}}}
    }
  }
}

Verarbeitungskonfiguration aktualisieren

Nachdem der Datenspeicher erstellt wurde, können Sie die Verarbeitungskonfiguration (processing_config) mit einer PATCH-Anfrage aktualisieren.

Die folgenden Attribute können aktualisiert werden:

display_name
description
labels
document_metadata_schema (nur zusätzliche Properties können hinzugefügt werden)

Attribute, die aktualisiert werden, müssen im Abfrageparameter update_mask enthalten sein.

In den folgenden Beispielen wird gezeigt, wie die Attribute display_name und document_metadata_schema einer Verarbeitungskonfiguration aktualisiert werden.

curl

curl -X PATCH -H "${AUTH}" -H "Content-Type: application/json" \
"${INGEST}/dataStores/acme-financials?update_mask=display_name,document_metadata_schema" \
-d '{"display_name": "Acme reports",
"document_metadata_schema": {"schema": {"type": "object", "properties": {
"category": {"type": "string"}, "year": {"type": "integer"},
"region": {"type": "string"}}}}}'

Dokumentsegmentierung

Beim Erstellen des Datenspeichers können Sie angeben, wie die verwaltete Aufnahmepipeline Ihre Dokumente segmentieren soll:

Seitensegmentierung (processing_config.segmentation_config.page_segmentation_config): Bei der verwalteten Aufnahme wird versucht, Dokumente nach Seiten zu segmentieren.
Segmentierung in Blöcke (processing_config.segmentation_config.chunk_segmentation_config): Bei der verwalteten Aufnahme werden Dokumente in separate Blöcke segmentiert.

Wenn keine Angabe erfolgt, ist die Standardeinstellung die Chunk-Segmentierung. Wenn beide angegeben sind, schlägt die Anfrage fehl.

Seitensegmentierung

Wenn Sie die Seitensegmentierung (processing_config.segmentation_config.page_segmentation_config) angeben, wird die verwaltete Aufnahmepipeline angewiesen, Dokumente nach Seite oder Seitenbereich zu segmentieren. Wenn ein Dokument keine Seiteninformationen enthält, z. B. eine Textdatei, wird es in Seiten mit einer Größe von bis zu 2,5 MB segmentiert.

Die Seitensegmentierung ist für die Dokumentabfrage optimiert, z. B. für Anwendungen, die mit jedem Suchergebnis PDFs oder Word-Dokumente zurückgeben. Weitere Informationen finden Sie unter Dokumente für RAG in Blöcke aufteilen.

Segmentierung von Blöcken

Wenn Sie die Segmentierung in Chunks (processing_config.segmentation_config.chunk_segmentation_config) angeben, wird die verwaltete Aufnahmepipeline angewiesen, Dokumente in Chunks von bis zu processing_config.segmentation_config.chunk_segmentation_config.chunk_size Tokens zu segmentieren. Standardmäßig beträgt die Blockgröße 500 Tokens (die maximale Blockgröße). Die Mindestgröße für Chunks beträgt 300.

Große Stücke:

Mehr Kontext berücksichtigen
Weniger Segmente produzieren.
Kann mehrere Themen abdecken, die nicht zu einer Suchanfrage passen, wodurch relevante Informationen möglicherweise untergehen.

Kleine Blöcke:

Schmalere Textblöcke
Sie enthalten mit größerer Wahrscheinlichkeit nur die Informationen, die einer Abfrage entsprechen.
Sie enthalten weniger Kontext und teilen relevante Informationen möglicherweise in mehrere Segmente auf.

Für die meisten langen Inhalte ist eine Blockgröße von 500 Tokens gut geeignet. Kleinere Blockgrößen eignen sich besser für kurze, faktenbasierte Inhalte oder zum Abrufen kompakter, präziser Textpassagen.

Eingabe-URIs

Das JSON-Attribut gcs_source.input_uris ist ein String-Array, das die Eingaben für eine verwaltete Aufnahme-Anfrage angibt, z. B. welche Dateien aus Ihrem Datenspeicher importiert oder was aus dem Agentenabruf gelöscht werden soll.

Wenn gcs_source.source_format nicht angegeben oder auf SOURCE_FORMAT_UNSPECIFIED (Standard) festgelegt ist, können die Eingabe-URIs Folgendes sein:

Einen oder mehrere bestimmte URIs.
Ein oder mehrere Platzhaltermuster.
Eine oder mehrere Textdateien.
- Dokument-IDs werden zeilenweise definiert. Leere Zeilen werden ignoriert und Leerzeichen werden aus jeder Zeile entfernt.

Wenn gcs_source.source_format auf SOURCE_FORMAT_DOCUMENT_JSON gesetzt ist, werden die Eingabe-URIs im JSONL-Format definiert. Weitere Informationen finden Sie unter Metadaten zu Dokumenten hinzufügen.

Platzhalter

Muster	Stimmt überein mit
`gs://acme/files/hello_world.xyz`	Die angegebene Datei.
`gs://acme/files/*`	Jede Datei, die mit dem angegebenen `document_type` direkt in `gs://acme/files/` übereinstimmt.
`gs://acme/files/*.xyz`	Jede Datei mit der Erweiterung `.xyz`.

Platzhalter sind nicht rekursiv. Wenn Sie beispielsweise gs://acme/files/* angeben, werden keine Dateien unter gs://acme/files/2025/ importiert. Der Platzhalter ** wird genauso interpretiert wie *. Sie können entweder die Hierarchie vereinfachen oder ein Muster pro Ebene übergeben, um dieses Problem zu umgehen.

Wenn ein Muster nicht übereinstimmt, schlägt die Anfrage fehl. Wenn Sie beispielsweise vier URIs übergeben und einer einen Tippfehler enthält, wird der Import mit den anderen drei URIs nicht fortgesetzt. Prüfen Sie, ob jeder URI korrekt ist, bevor Sie eine Importanfrage stellen.

3. Dateien importieren

In der nächsten Phase der Pipeline wird importDocuments mit den URIs der Dateien in Ihrem Datenspeicher aufgerufen, die Sie aufnehmen möchten.

Die folgenden Beispiele zeigen, wie Dokumente importiert werden.

curl

curl -X POST -H "${AUTH}" -H "Content-Type: application/json" \
  "${INGEST}/dataStores/acme-financials:importDocuments" \
  -d '{
    "gcs_source": {
      "input_uris": ["gs://acme-docs/reports/*"]
    },
    "import_output_config": {
      "error_gcs_prefix": "gs://acme-docs/import-errors/"
    }
  }'

Python

op = session.post(
    INGEST + "/dataStores/acme-financials:importDocuments",
    json={
        "gcs_source": {"input_uris": ["gs://acme-docs/reports/*"]},
        "import_output_config": {
            "error_gcs_prefix": "gs://acme-docs/import-errors/"
        },
    },
).json()

result = wait(op)
print(result["metadata"]["successCount"], "imported")
# failureCount is not set on import metadata; check error files instead.

Sie können sie optional mit Metadaten importieren. Weitere Informationen finden Sie unter Metadaten zu Dokumenten hinzufügen.

Die folgenden Beispiele zeigen, wie Sie die JSONL-Metadatendateien importieren.

curl

gcloud storage cp docs.jsonl gs://acme-docs/manifests/docs.jsonl
curl -X POST -H "${AUTH}" -H "Content-Type: application/json" \
  "${INGEST}/dataStores/acme-financials:importDocuments" \
  -d '{
    "gcs_source": {
      "input_uris": ["gs://acme-docs/manifests/docs.jsonl"],
      "source_format": "SOURCE_FORMAT_DOCUMENT_JSON"
    },
    "import_output_config": {
      "error_gcs_prefix": "gs://acme-docs/import-errors-json/"
    }
  }'

Python

op = session.post(
    INGEST + "/dataStores/acme-financials:importDocuments",
    json={
        "gcs_source": {
            "input_uris": ["gs://acme-docs/manifests/docs.jsonl"],
            "source_format": "SOURCE_FORMAT_DOCUMENT_JSON",
        },
        "import_output_config": {
            "error_gcs_prefix": "gs://acme-docs/import-errors-json/"
        },
    },
).json()

result = wait(op)

Die verwaltete Aufnahme für die Sammlung erstellt

Wenn Sie Ihren Datenspeicher erstellen, wird durch die verwaltete Aufnahme eine Sammlung in Agent Retrieval mit öffentlichen Agent Retrieval APIs erstellt, die wie jede andere Agent Retrieval-Sammlung verwendet werden kann. Die Sammlung ist leer, bis der Importvorgang abgeschlossen ist.

Informationen zum Abfragen der Sammlung finden Sie unter In Dokumenten suchen.

Im folgenden Beispiel wird gezeigt, wie Sie den Namen der Sammlung aus dem Datenspeicher abrufen.

curl

curl -H "${AUTH}" "${INGEST}/dataStores/acme-financials"

Python

data_store = session.get(INGEST + "/dataStores/acme-financials").json()
collection_name = data_store["collectionName"]
print(collection_name)

Importfortschritt verfolgen

Wenn Sie den Fortschritt des Importjobs verfolgen möchten, fragen Sie den Vorgang ab, anstatt den Status des Buckets zu prüfen. Das Feld successCount in der Antwort enthält die Anzahl der erfolgreich importierten Dateien.

Sie können die Fehler beheben und eine weitere Importanfrage stellen. Weitere Informationen finden Sie unter Importvorgang noch einmal ausführen.

In den folgenden Beispielen wird gezeigt, wie Sie den Vorgang abfragen.

curl

curl -H "${AUTH}" "${BASE}/{OPERATION_NAME}"

Python

# To check once, without blocking, using the op returned by the import call:
status = session.get(BASE + "/" + op["name"]).json()
print(status.get("done"), status.get("metadata", {}))

Im folgenden Beispiel wird gezeigt, wie Sie eine Liste der importierten Dateien abrufen, nachdem der Importvorgang abgeschlossen ist.

curl

curl -H "${AUTH}" "${INGEST}/dataStores/acme-financials/documents"

Python

docs = session.get(INGEST + "/dataStores/acme-financials/documents").json()
print(len(docs.get("documents", [])))

Importvorgang noch einmal ausführen

Wenn Sie zusätzliche Importvorgänge für denselben Bucket ausführen, werden nur Dateien verarbeitet, die geändert oder hinzugefügt wurden. Eine Datei, die bereits importiert wurde und unverändert ist, wird übersprungen.

In Dokumenten suchen

Die verwaltete Aufnahme, die die Sammlung für Sie erstellt, ist wie eine reguläre Abrufsammlung für KI-Agenten. Sie können Abfragen ausführen und die Ergebnisse filtern, neu sortieren, indexieren und mehr.

Beispiele

Im folgenden Beispiel wird gezeigt, wie Sie den Inhalt der Dateien durchsuchen, die aus einem Datenspeicher importiert wurden.

curl

COLLECTION=projects/${PROJECT}/locations/${LOCATION}/collections/google-acme-financials

curl -X POST -H "${AUTH}" -H "Content-Type: application/json" \
  "https://vectorsearch.googleapis.com/v1/${COLLECTION}/dataObjects:search" \
  -d '{
    "semantic_search": {
      "search_text": "what is the total revenue?",
      "search_field": "multimodal_embedding",
      "task_type": "RETRIEVAL_QUERY",
      "top_k": 10,
      "output_fields": {
        "data_fields": ["google_document_id", "google_customer_uri", "google_unstructured_details.content_snippet"]
      }
    }
  }'

Python

from google.cloud import vectorsearch_v1

# Create the client
search_client = vectorsearch_v1.DataObjectSearchServiceClient()

# Initialize request argument(s)
semantic_search = vectorsearch_v1.SemanticSearch(
    search_text="what is the total revenue?",
    search_field="multimodal_embedding",
    task_type=vectorsearch_v1.EmbeddingTaskType.RETRIEVAL_QUERY,
    top_k=10,
    output_fields=vectorsearch_v1.OutputFields(
        data_fields=["google_document_id", "google_customer_uri", "google_unstructured_details.content_snippet"],
    ),
)
request = vectorsearch_v1.SearchDataObjectsRequest(
    parent="projects/PROJECT_ID/locations/LOCATION/collections/COLLECTION_ID",
    semantic_search=semantic_search,
)

# Make the request
response = search_client.search_data_objects(request=request)

# Handle the response
for hit in response.results:
    data = dict(hit.data_object.data)
    print(hit.distance, data["google_customer_uri"][0])
    print(data["google_unstructured_details"]["content_snippet"][:200])

Suchergebnisse

Jedes Suchergebnis enthält die folgenden Attribute:

Attribut	Typ	Beschreibung
`google_document_id`	String	Das Dokument, aus dem das Segment stammt.
`google_customer_uri`	String	Der ursprüngliche `gs://`-URI für die Zitation.
`google_modality`	String	`UNSTRUCTURED` oder `VIDEO`.
`google_unstructured_details.content_snippet`	String	Der Segmenttext.
`google_unstructured_details.start_page`/`end_page`	integer	Seitenbereich des Chunks. Wird nur bei der Seitensegmentierung ausgefüllt, die digitales Parsen erfordert. Bei der Chunk-Segmentierung bleibt das Feld leer.
`google_video_details.start_offset_nanos`/`end_offset_nanos`	integer	Zeitspanne eines Videosegments.
`multimodal_embedding`	Vektor, dicht, 768 Dimensionen	Die Chunk-Einbettung aus `gemini-embedding-2`.
`metadata`	Objekt	Aus dem Dokument in jedes seiner Segmente kopiert, ohne Präfix und wie deklariert verschachtelt (z. B. `category` oder `issuer.country`).

Die Attribute start_page, end_page, start_offset_nanos und end_offset_nanos werden immer zurückgegeben, unabhängig vom angegebenen Dokumenttyp.

Bei Textdokumenten werden start_page und end_page nur dann ausgefüllt, wenn beim Erstellen des Datenspeichers die Seitenaufteilung angegeben wurde.

Die Attribute in metadata entsprechen dem JSON-Schema, das beim Import angegeben wurde.

Dateien endgültig löschen

Wenn Sie eine Datei aus einem Datenspeicher dauerhaft löschen möchten, laden Sie eine oder mehrere Textdateien in Cloud Storage hoch. Jede Zeile muss die ID einer Datei enthalten, die Sie dauerhaft löschen möchten. Übergeben Sie die URIs der Textdateien an einen purgeDocuments.

In der Antwort wird nicht angegeben, welche Dateien dauerhaft gelöscht werden. Rufen Sie GetDocument auf, um zu prüfen, ob eine Datei endgültig gelöscht wurde. Die Antwort gibt 404 zurück.

Setzen Sie force auf false, um den Löschvorgang zuerst zu testen. Dadurch werden die zu löschenden Dateien in der von Ihnen angegebenen error_gcs_prefix protokolliert.

Nachdem die Dateien endgültig gelöscht wurden, können Sie den Datenspeicher löschen, der die endgültig gelöschten Dateien enthält.

In den folgenden Beispielen wird gezeigt, wie Dateien dauerhaft gelöscht werden.

curl

curl -X POST -H "${AUTH}" -H "Content-Type: application/json" \
"${INGEST}/dataStores/acme:purgeDocuments" \
-d '{
  "gcs_source": {
    "input_uris": ["gs://acme/purge/purge-ids.txt"]
  },
  "purge_output_config": {
    "error_gcs_prefix": "gs://acme/purge-force-errors/"
  },
  "force": true
}'

Python

op = session.post(
  INGEST + "/dataStores/acme:purgeDocuments",
  json={
      "gcs_source": {
            "input_uris": ["gs://acme/purge/purge-ids.txt"],
        },
        "purge_output_config": {
            "error_gcs_prefix": "gs://acme/purge-force-errors/",
        },
        "force": True,
    },
).json()

result = wait(op)

Datenspeicher löschen

Senden Sie eine DELETE-Anfrage mit dem URI des Datenspeichers, um den Datenspeicher zu löschen. Wenn force auf true gesetzt ist und der Datenspeicher noch Dateien enthält, schlägt die Anfrage mit dem Status FAILED_PRECONDITION und der Nachricht DataStore deletion is not allowed because it still contains documents. Set force=true to delete the DataStore and all its Documents. fehl.

Setzen Sie backing_collection_deleted auf true, um die Sammlung und die Datenobjekte zu löschen, die nach dem Import des Datenspeichers erstellt wurden. Andernfalls bleiben die Sammlung und die Datenobjekte erhalten und verbrauchen weiterhin Kontingent. Jede Anfrage zum Erstellen eines neuen Datenspeichers mit derselben ID schlägt mit der Meldung FAILED_PRECONDITION (BACKING_COLLECTION_ALREADY_EXISTS) fehl.

Während die Löschanfrage ausgeführt wird, gibt eine get-Anfrage den Status DELETING und nach Abschluss einen 404-Fehler zurück.

Im folgenden Beispiel wird gezeigt, wie ein Datenspeicher gelöscht wird.

curl

curl -X DELETE -H "${AUTH}" \
  "${INGEST}/dataStores/acme-financials?force=true&backing_collection_deleted=true"

Python

op = session.delete(
  INGEST + "/dataStores/acme-financials",
  params={"force": "true", "backing_collection_deleted": "true"},
).json()

result = wait(op)

Dokumente in einem Datenspeicher suchen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Unterstützte Dokumentformate

Vorbereitung

Beispiele

curl

Python

Die verwaltete Aufnahmepipeline

1. Dateien bereitstellen

2. Datenspeicher erstellen

Optionale Einstellungen für Dokumentdateien

Beispiele

curl

Python

Metadaten für Ihre Dateien hinzufügen

Metadatenschema hinzufügen

Verarbeitungskonfiguration aktualisieren

curl

Dokumentsegmentierung

Seitensegmentierung

Segmentierung von Blöcken

Eingabe-URIs

Platzhalter

3. Dateien importieren

curl

Python

curl

Python

Die verwaltete Aufnahme für die Sammlung erstellt

curl

Python

Importfortschritt verfolgen

curl

Python

curl

Python

Importvorgang noch einmal ausführen

In Dokumenten suchen

Beispiele

curl

Python

Suchergebnisse

Dateien endgültig löschen

curl

Python

Datenspeicher löschen

curl

Python

Dokumente in einem Datenspeicher suchen