Nach Datenobjekten suchen

Mit der Search API sollen Datenobjekte gefunden werden, die einer bestimmten Anfrage ähneln, und eine Liste mit nach Ähnlichkeit sortierten Ergebnissen zurückgegeben werden. Die Search API unterstützt auch das Filtern.

Die Search API bietet verschiedene Möglichkeiten, nach Datenobjekten zu suchen: Vektorsuche, Volltextsuche und semantische Suche. Außerdem können mehrere Suchvorgänge beliebigen Typs kombiniert werden, um eine Hybridsuche zu ermöglichen.

Bei der Vektorsuche können Sie Ihren eigenen Anfragevektor angeben. Dies ist die erforderliche Methode zum Suchen in Einbettungsfeldern ohne embedding-config. Wenn mehrere vector_search-Felder angegeben werden, werden die Ergebnisse mit gleichen Gewichten kombiniert.

Im folgenden Beispiel wird gezeigt, wie eine Vektorsuche für eine Sammlung mit der ID COLLECTION_ID durchgeführt wird.

REST

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • COLLECTION_ID: Die ID der Sammlung.
  • LOCATION: Die Region, in der Sie die Agent Platform verwenden.
  • PROJECT_ID: Ihre Cloud de Confiance by S3NS Projekt-ID.

HTTP-Methode und URL: 

POST https://vectorsearch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/collections/COLLECTION_ID/dataObjects:search

JSON-Text anfordern:

{
  "vector_search": {
    "search_field": "plot_embedding",
    "vector": {
      "values": [
        0.42426406871192845,
        0.565685424949238,
        0.7071067811865475
      ]
    },
    "filter": {
      "genre": {
        "$eq": "Thriller"
      }
    },
    "top_k": 5,
    "output_fields": {
      "data_fields": "*",
      "vector_fields": "*",
      "metadata_fields": "*"
    }
  }
}

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

{
  "results": [
    {
      "dataObject": {
        "name": "projects/PROJECT_ID/locations/LOCATION/collections/COLLECTION_ID/dataObjects/1",
        "createTime": "2026-01-31T20:05:06Z",
        "updateTime": "2026-02-02T13:59:24Z",
        "data": {
          "year": 1991,
          "title": "The Silence of the Lambs",
          "director": "Jonathan Demme",
          "genre": "Thriller"
        },
        "vectors": {
          "plot_embedding": {
            "dense": {
              "values": [
                1,
                1,
                1
              ]
            }
          },
          "sparse_embedding": {
            "sparse": {
              "values": [
                1,
                6,
                3,
                2,
                8,
                5,
                2
              ],
              "indices": [
                4065,
                13326,
                17377,
                25918,
                28105,
                32683,
                42998
              ]
            }
          },
          "genre_embedding": {
            "dense": {
              "values": [
                0.3863801,
                0.73934346,
                0.16189057,
                0.5271367
              ]
            }
          },
          "soundtrack_embedding": {
            "dense": {
              "values": [
                0.5920452,
                0.08301644,
                0.12647335,
                0.619643,
                0.49258286
              ]
            }
          }
        }
      },
      "distance": 1.697
    },
    {
      "dataObject": {
        "name": "projects/PROJECT_ID/locations/LOCATION/collections/COLLECTION_ID/dataObjects/2",
        "createTime": "2026-02-04T14:35:29Z",
        "updateTime": "2026-02-04T14:37:29Z",
        "data": {
          "year": 1995,
          "title": "Se7en",
          "director": "David Fincher",
          "genre": "Thriller"
        },
        "vectors": {
          "genre_embedding": {
            "dense": {
              "values": [
                0.3863801,
                0.73934346,
                0.16189057,
                0.5271367
              ]
            }
          },
          "plot_embedding": {
            "dense": {
              "values": [
                1,
                1,
                1
              ]
            }
          },
          "sparse_embedding": {
            "sparse": {
              "values": [
                1,
                6,
                3,
                2,
                8,
                5,
                2
              ],
              "indices": [
                4065,
                13326,
                17377,
                25918,
                28105,
                32683,
                42998
              ]
            }
          },
          "soundtrack_embedding": {
            "dense": {
              "values": [
                0.5920452,
                0.08301644,
                0.12647335,
                0.619643,
                0.49258286
              ]
            }
          }
        }
      },
      "distance": 1.75
    }
  ]
}

gcloud

Ersetzen Sie folgende Werte, bevor sie einen der Befehlsdaten verwenden:

  • SEARCH_VECTOR_FILE: Der lokale Pfad zu einer JSON-Datei, die den dichten oder spärlichen Vektor für die Suche enthält.

    Beispiel für den Inhalt einer Datei für einen dichten Vektor:

    {
  "dense": {
    "values": [
      0.42426406871192845,
      0.565685424949238,
      0.7071067811865475
    ]
  }
}

    Beispiel für den Inhalt einer Datei für einen Sparse-Vektor:

    {
  "sparse": {
    "indices": [1, 5, 10],
    "values": [0.1, 0.5, 0.21]
  }
}
  • COLLECTION_ID: Die ID der Sammlung.
  • LOCATION: Die Region, in der Sie die Agent Platform verwenden.
  • PROJECT_ID: Ihre Cloud de Confiance by S3NS Projekt-ID.

Führen Sie folgenden Befehl aus:

Linux, macOS oder Cloud Shell

gcloud vector-search collections data-objects search \
  --vector-search-field="plot_embedding" \
  --vector-from-file=SEARCH_VECTOR_FILE \
  --json-filter='{"genre": {"$eq": "Thriller"}}' \
  --top-k=5 \
  --output-data-fields='*' \
  --output-vector-fields='*' \
  --output-metadata-fields='*' \
  --collection=COLLECTION_ID \
  --location=LOCATION \
  --project=PROJECT_ID

Windows (PowerShell)

gcloud vector-search collections data-objects search `
  --vector-search-field="plot_embedding" `
  --vector-from-file=SEARCH_VECTOR_FILE `
  --json-filter='{"genre": {"$eq": "Thriller"}}' `
  --top-k=5 `
  --output-data-fields='*' `
  --output-vector-fields='*' `
  --output-metadata-fields='*' `
  --collection=COLLECTION_ID `
  --location=LOCATION `
  --project=PROJECT_ID

Windows (cmd.exe)

gcloud vector-search collections data-objects search ^
  --vector-search-field="plot_embedding" ^
  --vector-from-file=SEARCH_VECTOR_FILE ^
  --json-filter='{"genre": {"$eq": "Thriller"}}' ^
  --top-k=5 ^
  --output-data-fields='*' ^
  --output-vector-fields='*' ^
  --output-metadata-fields='*' ^
  --collection=COLLECTION_ID ^
  --location=LOCATION ^
  --project=PROJECT_ID

Sie sollten eine Antwort ähnlich der folgenden erhalten:

---
dataObject:
  createTime: '2026-01-31T20:05:06Z'
  data:
    director: Jonathan Demme
    genre: Thriller
    title: The Silence of the Lambs
    year: 1991
  name: projects/PROJECT_ID/locations/LOCATION/collections/COLLECTION_ID/dataObjects/1
  updateTime: '2026-02-02T13:59:24Z'
  vectors:
    genre_embedding:
      dense:
        values:
        - 0.38638
        - 0.739343
        - 0.161891
        - 0.527137
    plot_embedding:
      dense:
        values:
        - 1.0
        - 1.0
        - 1.0
    soundtrack_embedding:
      dense:
        values:
        - 0.592045
        - 0.0830164
        - 0.126473
        - 0.619643
        - 0.492583
    sparse_embedding:
      sparse:
        indices:
        - 4065
        - 13326
        - 17377
        - 25918
        - 28105
        - 32683
        - 42998
        values:
        - 1.0
        - 6.0
        - 3.0
        - 2.0
        - 8.0
        - 5.0
        - 2.0
distance: 1.697
---
dataObject:
  createTime: '2026-02-04T14:35:29Z'
  data:
    director: David Fincher
    genre: Thriller
    title: Se7en
    year: 1995
  name: projects/PROJECT_ID/locations/LOCATION/collections/COLLECTION_ID/dataObjects/2
  updateTime: '2026-02-04T14:37:29Z'
  vectors:
    genre_embedding:
      dense:
        values:
        - 0.38638
        - 0.739343
        - 0.161891
        - 0.527137
    plot_embedding:
      dense:
        values:
        - 1.0
        - 1.0
        - 1.0
    soundtrack_embedding:
      dense:
        values:
        - 0.592045
        - 0.0830164
        - 0.126473
        - 0.619643
        - 0.492583
    sparse_embedding:
      sparse:
        indices:
        - 4065
        - 13326
        - 17377
        - 25918
        - 28105
        - 32683
        - 42998
        values:
        - 1.0
        - 6.0
        - 3.0
        - 2.0
        - 8.0
        - 5.0
        - 2.0
distance: 1.75

Python

from google.cloud import vectorsearch_v1

# Create the client
data_object_search_service_client = vectorsearch_v1.DataObjectSearchServiceClient()

# Initialize request
vector_search = vectorsearch_v1.VectorSearch(
    search_field="plot_embedding",
    vector={"values": [0.1, 0.2, 0.3]},
    filter={"genre": {"$eq": "Thriller"}},
    top_k=5,
)
request = vectorsearch_v1.SearchDataObjectsRequest(
    parent="projects/PROJECT_ID/locations/LOCATION/collections/COLLECTION_ID",
    vector_search=vector_search,
)

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

# Handle the response
print(response)

Suchgenauigkeit und ‑leistung optimieren

Bei Vektorsuchen in dichten ANN-Indizes mit mehr als 100.000 Einbettungen wird standardmäßig versucht, mit Agent Retrieval ein optimales Gleichgewicht zwischen Recall und Latenz zu erzielen. Sie können dieses Gleichgewicht für Ihren Anwendungsfall anpassen, indem Sie eine Zielrate für den Recall angeben.

Die Werte müssen größer oder gleich 0.00 und kleiner oder gleich 1.00 sein.

Informationen zum Erstellen eines ANN-Index finden Sie unter ANN-Index erstellen.

Im folgenden Beispiel wird gezeigt, wie Sie eine Vektorsuche in einem dichten ANN-Index mit einer Ziel-Recallrate von 0.95 durchführen.

REST

HTTP-Methode und URL:

POST https://vectorsearch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/collections/COLLECTION_ID/dataObjects:search

JSON-Text der Anfrage:

{
  "vectorSearch": {
    "searchField": "plot_embedding",
    "vector": {
      "values": [0.42426406871192845, 0.565685424949238, 0.7071067811865475]
    },
    "topK": 10,
    "searchHint": {
      "indexHint": {
        "name": "projects/PROJECT_ID/locations/LOCATION/collections/COLLECTION_ID/indexes/INDEX_ID",
        "denseScannParams": {
          "targetRecall": 0.95
        }
      }
    },
    "outputFields": {
      "dataFields": "*",
      "vectorFields": "*",
      "metadataFields": "*"
    }
  }
}

gcloud

Speichern Sie den Abfragevektor in einer JSON-Datei, z. B. vector.json:

{
  "dense": {
    "values": [0.42426406871192845, 0.565685424949238, 0.7071067811865475]
  }
}

Führen Sie dann den Befehl gcloud vector-search collections data-objects searchaus:

gcloud vector-search collections data-objects search \
    --project=PROJECT_ID \
    --location=LOCATION \
    --collection=COLLECTION_ID \
    --vector-search-field=plot_embedding \
    --vector-from-file=vector.json \
    --use-index=INDEX_ID \
    --dense-scann-target-recall=0.95 \
    --top-k=10

Python

from google.cloud import vectorsearch_v1

# Create the client
data_object_search_service_client = vectorsearch_v1.DataObjectSearchServiceClient()

collection = "projects/PROJECT_ID/locations/LOCATION/collections/COLLECTION_ID"

# Set the target recall rate on the index hint
search_hint = vectorsearch_v1.SearchHint(
    index_hint=vectorsearch_v1.SearchHint.IndexHint(
        name=f"{collection}/indexes/INDEX_ID",
        dense_scann_params=vectorsearch_v1.SearchHint.IndexHint.DenseScannParams(
            target_recall=0.95,
        ),
    ),
)

# Initialize request
vector_search = vectorsearch_v1.VectorSearch(
    search_field="plot_embedding",
    vector={"values": [0.42426406871192845, 0.565685424949238, 0.7071067811865475]},
    top_k=10,
    search_hint=search_hint,
    output_fields=vectorsearch_v1.OutputFields(
        data_fields=["*"],
        vector_fields=["*"],
        metadata_fields=["*"],
    ),
)
request = vectorsearch_v1.SearchDataObjectsRequest(
    parent=collection,
    vector_search=vector_search,
)

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

# Handle the response
print(response)

Textsuche

Dadurch wird eine Volltextsuche ohne spärliche Vektoren durchgeführt. Im Standarddialekt für „word“-Abfragen wird die gesamte Eingabe als einzelne Suchbegriffe mit einem impliziten AND-Operator behandelt. Sie können enhanced_query auf true setzen, um Suchbegriffe zu erweitern, Stemming und das Entfernen von Stoppwörtern zu verarbeiten und zusätzliche Suchoperatoren zuzulassen:

  • OR: Ein Operator für die disjunktive Suche, bei dem die Groß-/Kleinschreibung berücksichtigt wird und der Dokumente abgleicht, die mindestens einen der angegebenen Begriffe enthalten. Sie gilt nur für die beiden angrenzenden Begriffe.

  • ": (doppelte Anführungszeichen) für die Suche nach Wortgruppen.

  • -: Der Negationsoperator. Dokumente, die Begriffe enthalten, vor denen der Operator steht, werden ausgeschlossen.

Erweiterte Textsuche

Mit der Agent Retrieval Text Search API können Sie Textsuchanfragen über strukturierte Anfragen mit einer oder mehreren Unteranfragen ausdrücken. So haben Sie folgende Möglichkeiten:

  • Abgleich mit bestimmten Feldern von Datenobjekten

  • Geben Sie den Typ der abzugleichenden Daten an:

    • Pro Begriff, Groß-/Kleinschreibung nicht berücksichtigend

    • Genau, Groß-/Kleinschreibung beachten

  • Fügen Sie sprachspezifische Optimierungen hinzu, um nach Wortstämmen, Synonymen, Falschschreibungen und Stoppwörtern (z. B. „ein“, „eine“ und „der“) zu suchen.

  • Verwenden Sie die booleschen Operatoren AND, OR und NOT, um Unterabfragen zu kombinieren.

  • Die Reihenfolge der Auswertung lässt sich durch Gruppieren von Unterabfragen steuern.

  • Boost-Beiträge, um das Ranking zu beeinflussen.

Es gibt drei Arten von Unterabfragen:

  • Text: Enthält den Suchtext und ein oder mehrere Felder, mit denen abgeglichen werden soll.

  • Unär: Wendet einen NOT-Vorgang auf eine einzelne Unterabfrage an.

  • Kombiniert: Wendet den Operator AND oder OR an, um Unterabfragen zu kombinieren. Kann verwendet werden, um andere kombinierte Unterabfragen zu gruppieren und so die Auswertungsreihenfolge zu steuern.

In den Beispielen auf dieser Seite wird die Sammlung aus der folgenden Tabelle verwendet. Es enthält sechs Datenobjekte und definiert die folgenden Felder im Datenschema: die Strings ID, Title, Description und das String-Array Keywords.

ID Titel Beschreibung Keywords
1 The Quick Brown Fox Ein schneller brauner Fuchs springt mühelos über den faulen Hund. wild, Wald, Säugetier, orange, Agilität, Raubtier
2 Lazy Dog Days Der braune Hund schläft. Haustier, Hund, Haus, ruhig, faul, gehorsam
3 Fuchs gegen Hund Der schnelle Fuchs überlistet den Hund. wild, domestic, conflict, caniformia, mammals, interaction
4 Braunbären Schnelle Bewegungen im Wald. wild, Wald, bärenartig, Spitzenprädator, Ruhezustand, riesig
5 Eine raffinierte Geschichte Der Hund springt hoch. listig, springt
6 My Lazy Days of Summer Eine Kurzgeschichte über das Entspannen in den Sommerferien. Sommer, Entspannung, Urlaub, Sonne

Text-Unterabfragen

Textanfragen werden mit einem oder mehreren Feldern in einem DataObject abgeglichen. Alle strukturierten Anfragen müssen mindestens eine Textanfrage enthalten.

Im folgenden Beispiel wird eine einfache Textanfrage definiert:

"text_search": {
  "structured_query": {
    "text": {
      "text": "fox vs dog"
    }
  }
}

Standardmäßig wird der Text in einzelne Begriffe unterteilt und jeder Begriff wird in den angegebenen Feldern gesucht. Im vorherigen Beispiel wird im Feld Title nach den Begriffen „fox“, „vs“ und „dog“ gesucht.

Für Textanfragen sind die folgenden optionalen Parameter verfügbar:

  • fields: Ein Array von Feldern, die abgeglichen werden sollen. Wenn nicht angegeben, wird standardmäßig mit allen Feldern abgeglichen. Felder werden mit einem impliziten OR-Operator abgeglichen.

  • match_type: Der Typ des abzugleichenden Elements. Die Keyword-Option kann EXACT sein. In diesem Fall muss das Feld genau mit dem Suchtext übereinstimmen. Wenn das Feld ein String-Array ist, wird ein Abgleich mit jedem Element im Array durchgeführt.

  • enhancement: Gibt enabled und ein languageCode an, sodass Abgleiche mit Synonymen, Wortstämmen, Falschschreibweisen und Stoppwörtern in der für languageCode angegebenen Sprache (z. B. en-US) durchgeführt werden können. Die Standardeinstellung ist „Keine Optimierung“.

  • boost: Optional. Ein Multiplikator, der auf die Punktzahl der Anfrage angewendet wird. Der Standardwert ist 1.0.

Übereinstimmungstyp

Mit dem Parameter match_type wird angegeben, wie der Suchtext mit dem Wert eines Felds übereinstimmt.

Der Wert des Parameters kann Folgendes sein:

  • EXACT: Das Feld muss genau mit dem Suchbegriff übereinstimmen. Wenn das Feld ein String-Array ist, wird ein Abgleich mit jedem Element im Array durchgeführt.

Im folgenden Beispiel wird die Keyword-Option EXACT angegeben:

"text_search": {
  "structured_query": {
    "text": {
      "text": "Fox vs Dog",
      "fields": [ "Title" ],
      "match_type": "EXACT"
    }
  }
}

Übereinstimmungstyp für String-Arrays

Die Ergebnisse der Abfrage sind in der folgenden Tabelle aufgeführt:

Punktzahl ID Titel Beschreibung Keywords
1,0000 3 Fuchs gegen Hund Der schnelle Fuchs überlistet den Hund. wild, domestic, conflict, caniformia, mammals, interaction

Wenn das Feld ein String-Array ist, wird der Suchtext mit jedem Array-Element abgeglichen.

Das folgende Beispiel zeigt, wie Sie im String-Array Keywords nach dem genauen Text wild suchen:

"text_search": {
  "structured_query": {
    "text": {
      "text": "wild",
      "fields": [ "Keywords" ],
      "match_type": "EXACT"
    }
  }
}

Die Ergebnisse der Abfrage sind in der folgenden Tabelle aufgeführt:

Punktzahl ID Titel Beschreibung Keywords
1,0000 3 Fuchs gegen Hund Der schnelle Fuchs überlistet den Hund. wild, domestic, conflict, caniformia, mammals, interaction
1,0000 4 Braunbären Schnelle Bewegungen im Wald. wild, Wald, bärenartig, Spitzenprädator, Ruhezustand, riesig
1,0000 1 The Quick Brown Fox Ein schneller brauner Fuchs springt mühelos über den faulen Hund. wild, Wald, Säugetier, orange, Agilität, Raubtier

Erweiterungen für Suchanfragen

Suchanfragen können einen optionalen queryEnhancement-Parameter enthalten, um sprachspezifische Verbesserungen anzugeben. Dazu gehören auch Synonyme, Wortstämme (z. B. der Wortstamm „jump“ für „jumping“), Falschschreibungen und Stoppwörter (z. B. „ein“, „eine“ und „der“).

Der Parameter ist ein Objekt mit den folgenden Eigenschaften:

  • enabled: Ein boolescher Wert, der angibt, ob Verbesserungen aktiviert werden sollen.

  • languageCode: Ein String, der die Sprache für die Verbesserungen angibt (z. B. en-US).

Im folgenden Beispiel werden Verbesserungen für die Sprache en-US aktiviert:

"text_search": {
  "structured_query": {
    "text": {
      "text": {
        "text": "jump",
        "fields": [ "Description" ],
        "queryEnhancement": {
          "enabled": true,
          "languageCode": "en-US"
        }
      }
    }
  }
}

Die Ergebnisse der Abfrage sind in der folgenden Tabelle aufgeführt:

Punktzahl ID Titel Beschreibung Keywords
0,3419 1 The Quick Brown Fox Ein schneller brauner Fuchs springt mühelos über den faulen Hund. wild, Wald, Säugetier, orange, Agilität, Raubtier
0,3419 5 Eine raffinierte Geschichte Der Hund springt hoch. listig, springt

Wenn queryEnhancement nicht angegeben wurde oder enabled gleich false war, würde keine Übereinstimmung gefunden.

Kombinierte Unterabfragen

Bei kombinierten Abfragen wird eine boolesche Operation auf zwei oder mehr Unterabfragen angewendet. Die unterstützten Vorgänge sind AND und OR.

Kombinierte Abfragen haben die folgenden Eigenschaften:

  • op: Der boolesche Operator, der auf die Unterabfragen angewendet werden soll. Der Wert kann AND oder OR sein.

  • subQueries: Ein Array von zu kombinierenden Unterabfragen. Das können beliebige unterstützte Unterabfragetypen sein, einschließlich anderer kombinierter Abfragen. Die maximale Verschachtelungstiefe beträgt 2.

    • boost: Optional. Ein Multiplikator, der auf die Punktzahl der Anfrage angewendet wird. Der Standardwert ist 1.0.

Konjunktion (AND)

Der Operator AND entspricht Datenobjekten, die die Begriffe aller Unterabfragen enthalten.

Im folgenden Beispiel wird gezeigt, wie Sie drei Textanfragen mit dem Operator AND kombinieren:

"text_search": {
  "structured_query": {
    "combine": {
      "op": "AND",
      "subQueries": [
        {
          "text": {
            "text": "Brown",
            "fields": [ "Title" ]
          }
        },
        {
          "text": {
            "text": "quick",
            "fields": [ "Description" ]
          }
        },
        {
          "text": {
            "text": "forest predator",
            "fields": [ "Keywords" ]
          }
        }
      ]
    }
  }
}

Im Beispiel werden nur Übereinstimmungen gefunden, wenn alle drei Unterabfragen übereinstimmen.

Die Ergebnisse der Abfrage sind in der folgenden Tabelle aufgeführt:

Punktzahl ID Titel Beschreibung Keywords
5,0587 4 Braunbären Schnelle Bewegungen im Wald. wild, Wald, bärenartig, Spitzenprädator, Ruhezustand, riesig
5,0587 1 The Quick Brown Fox Ein schneller brauner Fuchs springt mühelos über den faulen Hund. wild, Wald, Säugetier, orange, Agilität, Raubtier

Wenn eine Textunterabfrage mehrere Felder für den Abgleich enthält, wird ein implizites OR angewendet, wie im folgenden Beispiel gezeigt:

"text_search": {
  "structured_query": {
    "combine": {
      "op": "AND",
      "subQueries": [
        {
          "text": {
            "text": "Brown",
            "fields": [ "Title", "Description" ]
          }
        },
        {
          "text": {
            "text": "quick",
            "fields": [ "Description" ]
          }
        },
        {
          "text": {
            "text": "forest predator",
            "fields": [ "Keywords" ]
          }
        }
      ]
    }
  }
}

Im obigen Beispiel gilt Folgendes:

  • Die erste Unterabfrage sucht nach dem Begriff Brown (ohne Berücksichtigung der Groß-/Kleinschreibung) im Feld Title oder Description.

  • In der zweiten Unterabfrage wird nach dem Begriff quick im Feld Description gesucht, wobei die Groß-/Kleinschreibung nicht berücksichtigt wird.

  • Die dritte Unterabfrage entspricht den Begriffen forest und predator (Groß-/Kleinschreibung wird nicht berücksichtigt) in einem der Werte im String-Array-Feld Keywords.

  • Wenn alle drei untergeordneten Anfragen übereinstimmen, wird eine Übereinstimmung für die kombinierte Anfrage erzielt.

Die Ergebnisse der Abfrage sind in der folgenden Tabelle aufgeführt:

Punktzahl ID Titel Beschreibung Keywords
6,3176 1 The Quick Brown Fox Ein schneller brauner Fuchs springt mühelos über den faulen Hund. wild, Wald, Säugetier, orange, Agilität, Raubtier
5,0587 4 Braunbären Schnelle Bewegungen im Wald. wild, Wald, bärenartig, Spitzenprädator, Ruhezustand, riesig

Disjunktion (OR)

Der Operator OR entspricht Datenobjekten, die die Begriffe aus mindestens einer der Unterabfragen enthalten.

Im folgenden Beispiel wird gezeigt, wie Sie drei Textanfragen mit dem Operator OR kombinieren:

"text_search": {
  "structured_query": {
    "combine": {
      "op": "OR",
      "subQueries": [
        {
          "text": {
            "text": "Brown",
            "fields": [ "Title", "Description" ]
          }
        },
        {
          "text": {
            "text": "quick",
            "fields": [ "Description" ]
          }
        },
        {
          "text": {
            "text": "forest predator",
            "fields": [ "Keywords" ]
          }
        }
      ]
    }
  }
}

Im Beispiel wird eine Übereinstimmung erzielt, wenn eine der drei Unterabfragen übereinstimmt.

Die Ergebnisse der Abfrage sind in der folgenden Tabelle aufgeführt:

Punktzahl ID Titel Beschreibung Keywords
6,3176 1 The Quick Brown Fox Ein schneller brauner Fuchs springt mühelos über den faulen Hund. wild, Wald, Säugetier, orange, Agilität, Raubtier
5,0587 4 Braunbären Schnelle Bewegungen im Wald. wild, Wald, bärenartig, Spitzenprädator, Ruhezustand, riesig

Gruppierung

Kombinierte Unterabfragen können in anderen kombinierten Unterabfragen verschachtelt werden, um die Auswertungsreihenfolge zu steuern.

Im folgenden Beispiel wird gezeigt, wie Unterabfragen gruppiert werden:

"text_search": {
  "structured_query": {
    "combine": {
      "op": "AND",
      "subQueries": [
        {
          "combine": {
            "op": "OR",
            "subQueries": [
              {
                "text": {
                  "text": "Fox",
                  "fields": [ "Title" ]
                }
              },
              {
                "text": {
                  "text": "jumps",
                  "fields": [ "Description" ]
                }
              }
            ]
          }
        },
        {
          "unary": {
            "op": "NOT",
            "subQuery": {
              "text": {
                "text": "domestic",
                "fields": [ "Keywords" ]
              }
            }
          }
        }
      ]
    }
  }
}

Das vorherige Beispiel entspricht dem Folgenden: (Fox ohne Berücksichtigung der Groß-/Kleinschreibung in Title OR jumps ohne Berücksichtigung der Groß-/Kleinschreibung in Description) AND NOT domestic ohne Berücksichtigung der Groß-/Kleinschreibung in einem der Keywords-Elemente.

Die folgende Tabelle zeigt die Ergebnisse der Abfrage:

Punktzahl ID Titel Beschreibung Keywords
3.5178 1 The Quick Brown Fox Ein schneller brauner Fuchs springt mühelos über den faulen Hund. wild, Wald, Säugetier, orange, Agilität, Raubtier
2,2589 5 Eine raffinierte Geschichte Der Hund springt hoch. listig, springt

Unäre Unterabfragen

Bei unären Unterabfragen wird ein boolescher Vorgang auf eine einzelne Unterabfrage in einer strukturierten Abfrage angewendet. Der Operator NOT ist der einzige unterstützte unäre Vorgang.

Unäre Abfragen haben die folgenden Eigenschaften:

  • op: Der boolesche Operator, der auf die Unterabfrage angewendet werden soll. Der Wert kann NOT sein.

  • subQuery: Die Unterabfrage, auf die der unäre Vorgang angewendet werden soll.

    • boost: Optional. Ein Multiplikator, der auf die Punktzahl der Anfrage angewendet wird. Der Standardwert ist 1.0.

Negation (NOT)

Der Operator NOT stimmt mit Data-Objekten überein, die die Begriffe der Unterabfrage nicht enthalten.

Das folgende Beispiel zeigt, wie der Operator NOT verwendet wird:

"text_search": {
  "structured_query": {
    "unary": {
      "op": "NOT",
      "subQuery": {
        "text": {
          "text": "dog",
          "fields": [ "Description" ]
        }
      }
    }
  }
}

Die Ergebnisse der Abfrage sind in der folgenden Tabelle aufgeführt:

Punktzahl ID Titel Beschreibung Keywords
1.000 4 Braunbären Schnelle Bewegungen im Wald. wild, Wald, bärenartig, Spitzenprädator, Ruhezustand, riesig
1.000 6 My Lazy Days of Summer Eine Kurzgeschichte über das Entspannen in den Sommerferien. Sommer, Entspannung, Urlaub, Sonne

Bei Anwendung auf ein String-Array stimmt der Operator NOT mit einem Datenobjekt überein, wenn der Begriff in keinem der Elemente des Arrays enthalten ist.

Im Beispiel wird eine Übereinstimmung erzielt, wenn der nicht berücksichtigende Begriff orange in keinem Element des String-Arrays Keywords enthalten ist.

"text_search": {
  "structured_query": {
    "combine": {
      "op": "AND",
      "subQueries": [
        {
          "text": {
            "text": "Brown",
            "fields": [ "Title" ]
          }
        },
        {
          "text": {
            "text": "quick",
            "fields": [ "Description" ]
          }
        },
        {
          "text": {
            "text": "forest predator",
            "fields": [ "Keywords" ]
          }
        },
        {
          "unary": {
            "op": "NOT",
            "subQuery": {
              "text": {
                "text": "orange",
                "fields": [ "Keywords" ]
              }
            }
          }
        }
      ]
    }
  }
}

Die Ergebnisse der Abfrage sind in der folgenden Tabelle aufgeführt:

Punktzahl ID Titel Beschreibung Keywords
6,0587 4 Braunbären Schnelle Bewegungen im Wald. wild, Wald, bärenartig, Spitzenprädator, Ruhezustand, riesig

Boosting

Jede Unterabfrage kann einen boost-Parameter haben, um einen Multiplikator auf die Punktzahl der Unterabfrage anzuwenden. Standardmäßig haben alle Unterabfragen einen boost von 1.0.

Das folgende Beispiel zeigt, wie eine Unterabfrage verstärkt wird:

"text_search": {
  "structured_query": {
    "combine": {
      "op": "OR",
      "subQueries": [
        {
          "text": {
            "text": "fox",
            "fields": [ "Title" ]
          },
          "boost": 1.0
        },
        {
          "text": {
            "text": "jumps",
            "fields": [ "Description" ]
          },
          "boost": 1.0
        },
        {
          "text": {
            "text": "interaction",
            "fields": [ "Keywords" ]
          },
          "boost": 5.0
        }
      ]
    }
  }
}

Die Ergebnisse der Abfrage sind in der folgenden Tabelle aufgeführt:

Punktzahl ID Titel Beschreibung Keywords
7,5534 3 Fuchs gegen Hund Der schnelle Fuchs überlistet den Hund. wild, domestic, conflict, caniformia, mammals, interaction
2,5178 1 The Quick Brown Fox Ein schneller brauner Fuchs springt mühelos über den faulen Hund. wild, Wald, Säugetier, orange, Agilität, Raubtier
1,2589 5 Eine raffinierte Geschichte Der Hund springt hoch. listig, springt

Bei dieser Suche wird Ihre Textanfrage in Einbettungen umgewandelt, um Ergebnisse auf Grundlage der semantischen Bedeutung zu finden. Dabei wird die in Ihrem Schema definierte embedding-config verwendet, um die Abfrageeinbettung zu generieren. Wenn mehrere vector_search-Felder angegeben werden, werden die Ergebnisse mit gleichen Gewichten kombiniert.

Mit batch_search_data_objects können Sie mehrere Suchvorgänge parallel ausführen (Vektorsuche, Textsuche und semantische Suche). Die Ergebnisse können optional mit dem ReciprocalRankFusion-Ranker kombiniert und gerankt werden. Dabei werden Ergebnismengen mit dem RRF-Algorithmus (Reciprocal Rank Fusion) zusammengeführt.