搜索数据对象

Search API 的用途是查找与给定查询类似的数据对象，并返回按相似度排序的结果列表。Search API 还支持过滤。

Search API 提供多种搜索数据对象的方式：向量搜索、全文搜索和语义搜索。此外，您还可以将任意类型的多次搜索组合在一起，以实现混合搜索。

借助向量搜索，您可以提供自己的查询向量。这是搜索没有 embedding-config 的嵌入字段的必需方法。如果提供了多个 vector_search 字段，系统会使用相同的权重来合并结果。

以下示例演示了如何对 ID 为 COLLECTION_ID 的集合执行向量搜索。

REST

在使用任何请求数据之前，请先进行以下替换：

  • COLLECTION_ID：集合的 ID。
  • LOCATION：您使用 Agent Platform 的区域。
  • PROJECT_ID：您的 Cloud de Confiance by S3NS 项目 ID。

HTTP 方法和网址：

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

请求 JSON 正文：

{
  "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": "*"
    }
  }
}

如需发送您的请求，请展开以下选项之一：

您应该收到类似以下内容的 JSON 响应：

{
  "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

在使用下面的命令数据之前，请先进行以下替换：

  • SEARCH_VECTOR_FILE：本地路径，指向包含要搜索的密集或稀疏向量的 JSON 文件。

    密集向量的文件内容示例：

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

    稀疏向量的示例文件内容：

    {
  "sparse": {
    "indices": [1, 5, 10],
    "values": [0.1, 0.5, 0.21]
  }
}
  • COLLECTION_ID：集合的 ID。
  • LOCATION：您使用 Agent Platform 的区域。
  • PROJECT_ID：您的 Cloud de Confiance by S3NS 项目 ID。

执行以下命令：

Linux、macOS 或 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

您应该会收到类似如下所示的响应：

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

调整搜索准确性和性能

对于包含超过 10 万个嵌入内容的密集 ANN 索引上的向量搜索，Agent Retrieval 默认会尝试在召回率和延迟时间之间实现最佳平衡。您可以通过指定目标召回率来根据自己的使用情形调整这种平衡。

值必须大于或等于 0.00 且小于或等于 1.00。

如需了解如何创建 ANN 索引，请参阅创建 ANN 索引。

以下示例演示了如何对目标召回率为 0.95 的密集 ANN 索引执行向量搜索。

REST

HTTP 方法和网址：

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

请求 JSON 正文：

{
  "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

将查询向量保存到 JSON 文件（例如 vector.json）：

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

然后，运行 gcloud vector-search collections data-objects search 命令：

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)

文字搜索

此函数可执行不含稀疏向量的全文搜索。默认的“字词”查询方言会将整个输入视为具有隐式 AND 运算符的各个搜索字词。您可以将 enhanced_query 设置为 true，以扩展搜索字词、处理词干提取、移除停用词，并允许使用其他搜索运算符：

  • OR：一种区分大小写的析取运算符，用于匹配包含至少一个指定字词的文档。它仅适用于两个相邻的字词。

  • "：（双引号）用于搜索词组。

  • -：否定运算符。它会排除包含其前面任何字词的文档。

高级文本搜索

借助 Agent Retrieval 文本搜索 API，您可以通过包含一个或多个子查询的结构化查询来表达文本搜索，从而实现以下操作：

  • 根据特定数据对象字段进行匹配。

  • 指定要执行的匹配类型：

    • 每个字词，不区分大小写

    • 完全区分大小写

  • 包含每种语言的增强功能，可匹配词干、同义词、拼写错误和停用字词（例如“a”“an”和“the”）。

  • 使用 AND、OR 和 NOT 布尔运算符来组合子查询。

  • 通过将子查询分组在一起来控制评估顺序。

  • 提升得分贡献以影响排名。

子查询有三种类型：

  • 文本：提供搜索文本以及要匹配的一个或多个字段。

  • 一元：对单个子查询应用 NOT 操作。

  • 组合：应用 AND 或 OR 运算符来组合子查询，并可用于分组其他组合子查询以控制评估顺序。

本页面的示例使用下表中所示的 Collection。它包含六个数据对象，并在其数据架构中定义了以下字段：字符串 ID、Title、Description 和字符串数组 Keywords。

ID 标题 说明 关键字
1 The Quick Brown Fox 敏捷的棕色狐狸轻松跳过懒狗。 野生, 森林, 哺乳动物, 橙色, 敏捷, 捕食者
2 Lazy Dog Days 棕色狗在睡觉。 家养、宠物、房屋、犬类、平静、懒惰、顺从
3 狐狸与狗 敏捷的狐狸智胜了狗。 野生、家养、冲突、犬形亚目、哺乳动物、互动
4 棕熊 在森林中快速移动。 野生的、森林、熊科、顶级掠食者、冬眠、巨型
5 一个狡猾的故事 The dog jumps high. 狡猾，跳跃
6 我的夏日慵懒时光 一篇关于在暑假期间放松身心的短篇故事。 夏天、放松、度假、阳光

文本子查询

文本查询会与数据对象中的一个或多个字段进行匹配。所有结构化查询都必须包含至少一个文本查询。

以下示例定义了一个基本文本查询：

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

默认情况下，文本会拆分为单个字词，然后在指定的字段中搜索每个字词。在上述示例中，系统会在 Title 字段中搜索“fox”“vs”和“dog”这三个字词。

文本查询具有以下可选参数：

  • fields：要匹配的字段数组。如果未指定，则默认针对所有字段进行匹配。系统会使用隐式 OR 运算符匹配字段。

  • match_type：要执行的匹配类型。匹配类型可以是 EXACT，表示字段必须与搜索文本完全匹配。如果该字段是字符串数组，则会针对数组中的任何元素执行匹配。

  • enhancement：指定 enabled 和 languageCode，从而可以针对 languageCode 指定的语言（例如 en-US）中的同义词、词干、拼写错误和停用词执行匹配。默认情况下不进行增强。

  • boost：可选。要应用于查询得分的系数。 默认值为 1.0。

匹配类型

match_type 参数用于指定搜索文本与字段值的匹配方式。

参数值可以是：

  • EXACT：相应字段必须与搜索查询字词完全匹配。如果该字段是字符串数组，则会针对数组中的任何元素执行匹配。

以下示例指定了 EXACT 匹配类型：

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

字符串数组的匹配类型

查询结果如下表所示：

得分 ID 标题 说明 关键字
1.0000 3 狐狸与狗 敏捷的狐狸智胜了狗。 野生、家养、冲突、犬形亚目、哺乳动物、互动

如果该字段是字符串数组，则搜索文本会与任何数组元素进行匹配。

以下示例展示了如何在 Keywords 字符串数组中搜索确切的文本 wild：

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

查询结果如下表所示：

得分 ID 标题 说明 关键字
1.0000 3 狐狸与狗 敏捷的狐狸智胜了狗。 野生、家养、冲突、犬形亚目、哺乳动物、互动
1.0000 4 棕熊 在森林中快速移动。 野生的、森林、熊科、顶级掠食者、冬眠、巨型
1.0000 1 The Quick Brown Fox 敏捷的棕色狐狸轻松跳过懒狗。 野生, 森林, 哺乳动物, 橙色, 敏捷, 捕食者

查询增强功能

搜索查询可以包含一个可选的 queryEnhancement 参数，用于指定特定于语言的增强功能。这包括匹配同义词、词干（例如，“jump”词干“jumping”）、拼写错误和停用字（例如“a”“an”和“the”）。

该参数是一个具有以下属性的对象：

  • enabled：一个布尔值，用于指定是否启用增强功能。

  • languageCode：一个字符串，用于指定增强功能的语言（例如 en-US）。

以下示例针对 en-US 语言启用了增强功能：

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

查询结果如下表所示：

得分 ID 标题 说明 关键字
0.3419 1 The Quick Brown Fox 敏捷的棕色狐狸轻松跳过懒狗。 野生, 森林, 哺乳动物, 橙色, 敏捷, 捕食者
0.3419 5 一个狡猾的故事 The dog jumps high. 狡猾，跳跃

如果未指定 queryEnhancement 或 enabled 为 false，则不会进行匹配。

组合子查询

组合查询会对两个或更多个子查询应用布尔运算。支持的操作为 AND 和 OR。

组合查询具有以下属性：

  • op：要应用于子查询的布尔值运算符。值可以是 AND 或 OR。

  • subQueries：要合并的子查询数组。这些子查询可以是任何受支持的子查询类型，包括其他组合查询。嵌套深度上限为 2。

    • boost：可选。要应用于查询得分的系数。 默认值为 1.0。

合取 (AND)

AND 运算符用于匹配包含所有子查询的字词的数据对象。

以下示例演示了如何使用 AND 运算符组合三个文本查询：

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

在此示例中，只有当所有三个子查询都匹配时，才会进行匹配。

查询结果如下表所示：

得分 ID 标题 说明 关键字
5.0587 4 棕熊 在森林中快速移动。 野生的、森林、熊科、顶级掠食者、冬眠、巨型
5.0587 1 The Quick Brown Fox 敏捷的棕色狐狸轻松跳过懒狗。 野生, 森林, 哺乳动物, 橙色, 敏捷, 捕食者

如果文本子查询有多个要匹配的字段，系统会应用隐式 OR，如以下示例所示：

"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" ]
          }
        }
      ]
    }
  }
}

在前面的示例中：

  • 第一个子查询匹配 Title 或 Description 字段中不区分大小写的字词 Brown。

  • 第二个子查询匹配 Description 字段中不区分大小写的字词 quick。

  • 第三个子查询匹配 Keywords 字符串数组字段中任何值中的不区分大小写的字词 forest 和 predator。

  • 如果这三个子查询都匹配，则组合查询匹配。

查询结果如下表所示：

得分 ID 标题 说明 关键字
6.3176 1 The Quick Brown Fox 敏捷的棕色狐狸轻松跳过懒狗。 野生, 森林, 哺乳动物, 橙色, 敏捷, 捕食者
5.0587 4 棕熊 在森林中快速移动。 野生的、森林、熊科、顶级掠食者、冬眠、巨型

析取 (OR)

OR 运算符用于匹配包含至少一个子查询的字词的数据对象。

以下示例演示了如何使用 OR 运算符组合三个文本查询：

"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" ]
          }
        }
      ]
    }
  }
}

在此示例中，如果三个子查询中的任何一个匹配，则视为匹配。

查询结果如下表所示：

得分 ID 标题 说明 关键字
6.3176 1 The Quick Brown Fox 敏捷的棕色狐狸轻松跳过懒狗。 野生, 森林, 哺乳动物, 橙色, 敏捷, 捕食者
5.0587 4 棕熊 在森林中快速移动。 野生的、森林、熊科、顶级掠食者、冬眠、巨型

分组

为了控制评估顺序，组合子查询可以嵌套在其他组合子查询中。

以下示例演示了如何对子查询进行分组：

"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" ]
              }
            }
          }
        }
      ]
    }
  }
}

上述示例等效于以下内容：（Title 中不区分大小写的 Fox OR Description 中不区分大小写的 jumps）AND NOT 任何 Keywords 元素中不区分大小写的 domestic。

下表显示了查询结果：

得分 ID 标题 说明 关键字
3.5178 1 The Quick Brown Fox 敏捷的棕色狐狸轻松跳过懒狗。 野生, 森林, 哺乳动物, 橙色, 敏捷, 捕食者
2.2589 5 一个狡猾的故事 The dog jumps high. 狡猾，跳跃

一元子查询

一元子查询将布尔运算应用于结构化查询中的单个子查询。NOT 运算符是唯一受支持的一元运算。

一元查询具有以下属性：

  • op：要应用于子查询的布尔值运算符。值可以是 NOT。

  • subQuery：要对其应用一元运算的子查询。

    • boost：可选。要应用于查询得分的系数。 默认值为 1.0。

取反 (NOT)

NOT 运算符用于匹配不包含子查询中的字词的数据对象。

以下示例演示了如何使用 NOT 运算符：

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

查询结果如下表所示：

得分 ID 标题 说明 关键字
1.000 4 棕熊 在森林中快速移动。 野生的、森林、熊科、顶级掠食者、冬眠、巨型
1.000 6 我的夏日慵懒时光 一篇关于在暑假期间放松身心的短篇故事。 夏天、放松、度假、阳光

当应用于字符串数组时，如果字词未包含在数组的任何元素中，NOT 运算符会匹配数据对象。

在此示例中，如果 orange（不区分大小写的字词）未包含在 Keywords 字符串数组的任何元素中，则会发生匹配。

"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" ]
              }
            }
          }
        }
      ]
    }
  }
}

查询结果如下表所示：

得分 ID 标题 说明 关键字
6.0587 4 棕熊 在森林中快速移动。 野生的、森林、熊科、顶级掠食者、冬眠、巨型

提高

任何子查询都可以包含 boost 参数，以便将乘数应用于子查询的得分。默认情况下，所有子查询的 boost 均为 1.0。

以下示例演示了如何提高子查询的权重：

"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
        }
      ]
    }
  }
}

查询结果如下表所示：

得分 ID 标题 说明 关键字
7.5534 3 狐狸与狗 敏捷的狐狸智胜了狗。 野生、家养、冲突、犬形亚目、哺乳动物、互动
2.5178 1 The Quick Brown Fox 敏捷的棕色狐狸轻松跳过懒狗。 野生, 森林, 哺乳动物, 橙色, 敏捷, 捕食者
1.2589 5 一个狡猾的故事 The dog jumps high. 狡猾，跳跃

此搜索功能会将您的文本查询转换为嵌入，以便根据语义含义查找结果。它使用架构中定义的 embedding-config 生成查询嵌入。如果提供了多个 vector_search 字段，系统会使用相同的权重来合并结果。

使用 batch_search_data_objects 并行执行多项搜索（向量搜索、文本搜索和语义搜索）。您可以选择使用 ReciprocalRankFusion Ranker 合并结果并对其进行排名，该 Ranker 使用倒数排序融合 (RFF) 算法合并结果集。