本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 搜索索引
**注意**
功能支持因所用索引类型和搜索 API 而异。要查看您使用的索引类型和搜索 API 是否支持此功能，请参阅[索引类型](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html)。
要搜索 Amazon Kendra 索引，您可以使用[查询](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) API。`Query` API 会返回有关您在应用程序中使用的已编入索引的文档的信息。本节介绍如何进行查询、执行筛选以及如何解释从 `Query` API 获得的响应。
要搜索已编入索引的 Amazon Kendra 文档 Amazon Lex，请使用[亚马逊。 KendraSearchIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_KendraConfiguration.html)。有关使用进行配置的示例 Amazon Kendra Amazon Lex，请参阅[为 Amazon Kendra 索引创建常见问题解答机器人](https://docs.aws.amazon.com/lexv2/latest/dg/faq-bot-kendra-search.html)。
**Topics**
+ [查询索引](searching-example.md)
+ [检索段落](searching-retrieve.md)
+ [浏览索引](browsing.md)
+ [精选搜索结果](featured-results.md)
+ [HTML 表格搜索](searching-tables.md)
+ [查询建议](query-suggestions.md)
+ [查询拼写检查程序](query-spell-check.md)
+ [筛选和分面搜索](filtering.md)
+ [根据用户上下文进行筛选](user-context-filter.md)
+ [查询响应和响应类型](query-responses-types.md)
+ [调整和排序响应](tuning-sorting-responses.md)
+ [折叠/展开查询结果](expand-collapse-query-results.md)
# 查询索引
**注意**
功能支持因所用索引类型和搜索 API 而异。要查看您使用的索引类型和搜索 API 是否支持此功能，请参阅[索引类型](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html)。
搜索索引时， Amazon Kendra 使用您提供的有关文档的所有信息来确定与输入的搜索词最相关的文档。需要 Amazon Kendra 考虑的一些项目是：
+ 文档的文本或正文。
+ 文档标题。
+ 您已标记为可搜索的自定义文本字段。
+ 应使用您指定的日期字段来确定文档的“新鲜度”。
+ 可以提供相关信息的任何其他字段。
Amazon Kendra 还可以根据您可能为搜索设置的任何 field/attribute 过滤器来筛选响应。例如，如果您有一个名为“部门”的自定义字段，则可以筛选响应以仅返回名为“法律”的部门的文档。有关更多信息，请参阅[自定义字段和属性](https://docs.aws.amazon.com/kendra/latest/dg/custom-attributes.html)。
返回的搜索结果按每个文档所确 Amazon Kendra 定的相关性进行排序。结果是分页的，这样您就可以一次向用户显示一个页面。
要搜索已编入索引的 Amazon Kendra 文档 Amazon Lex，请使用[亚马逊。 KendraSearchIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_KendraConfiguration.html)。有关使用进行配置的示例 Amazon Kendra Amazon Lex，请参阅[为 Amazon Kendra 索引创建常见问题解答机器人](https://docs.aws.amazon.com/lexv2/latest/dg/faq-bot-kendra-search.html)。
以下示例说明如何搜索索引。 Amazon Kendra 确定最适合查询的搜索结果类型（答案、文档、问题答案）。您无法配置 Amazon Kendra 为向查询返回特定类型的搜索响应（答案、文档、问题答案）。
有关查询响应的信息，请参阅[查询响应和响应类型](query-responses-types.md)。
**Topics**
+ [先决条件](#searching-prerequisites)
+ [搜索索引（控制台）](#searching-index-console)
+ [搜索索引（SDK）](#searching-index-sdk)
+ [搜索索引（Postman）](#searching-index-postman)
+ [使用高级查询语法进行搜索](#searching-index-query-syntax)
+ [搜索语言](#searching-index-languages)
## 先决条件
在使用[查询](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) API 查询索引之前：
+ 为索引设置所需的权限并连接到您的数据来源或批量上传文档。有关更多信息，请参阅 [IAM 角色](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html)。在调用 API 创建索引和数据来源连接器或批量上传文档时，您可以使用角色的 Amazon 资源名称。
+ 设置 AWS Command Line Interface、SDK 或转到 Amazon Kendra 控制台。有关更多信息，请参阅[设置 Amazon Kendra](https://docs.aws.amazon.com/kendra/latest/dg/setup.html)。
+ 创建索引并连接到文档的数据来源或批量上传文档。有关更多信息，请参阅[创建索引](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html)和[创建数据来源连接器](https://docs.aws.amazon.com/kendra/latest/dg/data-source.html)。
## 搜索索引（控制台）
您可以使用 Amazon Kendra 控制台搜索和测试您的索引。您可以进行查询并查看结果。
**使用控制台搜索索引**
1. 登录 AWS 管理控制台 并打开 Amazon Kendra 控制台，[网址为 http://console.aws.amazon.com/kendra/](https://console.aws.amazon.com/kendra)。
1. 在导航窗格上，选择**索引**。
1. 选择您的索引。
1. 在导航菜单中，选择搜索索引的选项。
1. 在文本框中输入查询，然后按 Enter。
1. Amazon Kendra 返回搜索结果。
您还可以通过选择侧面板中的灯泡图标来获取搜索的查询 ID。
## 搜索索引（SDK）
**使用 Python 或 Java 搜索索引**
+ 以下示例搜索索引。将 `query` 的值更改为搜索查询，将 `index_id` 或 `indexId` 值更改为要搜索的索引的索引标识符。
您还可以在调用 [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) API 时获取作为响应元素一部分的搜索查询 ID。
------
#### [ Python ]
```
import boto3
import pprint
kendra = boto3.client("kendra")
# Provide the index ID
index_id = "index-id"
# Provide the query text
query = "query text"
response = kendra.query(
QueryText = query,
IndexId = index_id)
print("\nSearch results for query: " + query + "\n")
for query_result in response["ResultItems"]:
print("-------------------")
print("Type: " + str(query_result["Type"]))
if query_result["Type"]=="ANSWER" or query_result["Type"]=="QUESTION_ANSWER":
answer_text = query_result["DocumentExcerpt"]["Text"]
print(answer_text)
if query_result["Type"]=="DOCUMENT":
if "DocumentTitle" in query_result:
document_title = query_result["DocumentTitle"]["Text"]
print("Title: " + document_title)
document_text = query_result["DocumentExcerpt"]["Text"]
print(document_text)
print("------------------\n\n")
```
------
#### [ Java ]
```
package com.amazonaws.kendra;
import software.amazon.awssdk.services.kendra.KendraClient;
import software.amazon.awssdk.services.kendra.model.QueryRequest;
import software.amazon.awssdk.services.kendra.model.QueryResponse;
import software.amazon.awssdk.services.kendra.model.QueryResultItem;
public class SearchIndexExample {
public static void main(String[] args) {
KendraClient kendra = KendraClient.builder().build();
String query = "query text";
String indexId = "index-id";
QueryRequest queryRequest = QueryRequest
.builder()
.queryText(query)
.indexId(indexId)
.build();
QueryResponse queryResponse = kendra.query(queryRequest);
System.out.println(String.format("\nSearch results for query: %s", query));
for(QueryResultItem item: queryResponse.resultItems()) {
System.out.println("----------------------");
System.out.println(String.format("Type: %s", item.type()));
switch(item.type()) {
case QUESTION_ANSWER:
case ANSWER:
String answerText = item.documentExcerpt().text();
System.out.println(answerText);
break;
case DOCUMENT:
String documentTitle = item.documentTitle().text();
System.out.println(String.format("Title: %s", documentTitle));
String documentExcerpt = item.documentExcerpt().text();
System.out.println(String.format("Excerpt: %s", documentExcerpt));
break;
default:
System.out.println(String.format("Unknown query result type: %s", item.type()));
}
System.out.println("-----------------------\n");
}
}
}
```
------
## 搜索索引（Postman）
你可以使用 [Postman](https://www.postman.com/) 来查询和测试你的 Amazon Kendra 索引。
**使用 Postman 搜索索引**
1. 在 Postman 中创建一个新集合，并将请求类型设置为 **POST**。
1. 输入端点 URL。例如，*https://kendra..amazonaws.com*。
1. 选择**身份验证**选项卡并输入以下信息。
+ **类型** - 选择 **AWS 签名**。
+ **AccessKey**— 输入创建 IAM 用户时生成的访问密钥。
+ **SecretKey**— 输入创建 IAM 用户时生成的密钥。
+ **AWS 区域**-输入索引区域。例如，*us-west-2*。
+ **服务名称** - 输入 *kendra*。这区分大小写，因此必须是小写字母。
**警告**
如果您输入的服务名称不正确或未使用小写字母，则在选择**发送**请求后会引发错误：“凭证的范围应限定为正确的服务‘kendra’。”
您还必须检查您输入的访问密钥和密钥钥是否正确。
1. 选择**标头**选项卡，然后输入以下键和值信息。
+ 键：*X-Amz-Target*
价值：*com.amazonaws.kendra。 AWSKendraFrontendService.Query*
+ 键：*Content-Encoding*
值：*amz-1.0*
1. 选择**正文**选项卡并执行以下操作。
+ 为请求正文选择**原始** JSON 类型。
+ 输入包含您的索引 ID 和查询文本的 JSON。
```
{
"IndexId": "index-id",
"QueryText": "enter a query here"
}
```
**警告**
如果你的 JSON 没有使用正确的缩进，则会抛出一个错误：“” SerializationException。检查您的 JSON 中的缩进。
1. 选择**发送**（靠近右上角）。
## 使用高级查询语法进行搜索
您可以使用高级查询语法或运算符创建比简单的关键字或自然语言查询更具体的查询。这包括范围、布尔值、通配符等。通过使用运算符，您可以为查询提供更多背景信息，并进一步优化搜索结果。
Amazon Kendra 支持以下运算符。
+ 布尔值：限制或扩大搜索范围的逻辑。例如，将搜索 `amazon AND sports` 限制为仅搜索包含两个术语的文档。
+ 圆括号：按优先顺序读取嵌套的查询词。例如，`(amazon AND sports) NOT rainforest`读取 `NOT rainforest` 之前的 `(amazon AND sports)`。
+ 范围：日期或数字范围值。范围可以是包容性的、排他的，也可以是无界的。例如，您可以搜索上次更新于 2020 年 1 月 1 日至 2020 年 12 月 31 日之间的文档，包括这些日期。
+ 字段：使用特定字段限制搜索范围。例如，您可以搜索在“位置”字段中带有“美国”字样的文档。
+ 通配符：部分匹配一串文本。例如，`Cloud*`可以匹配 CloudFormation。 Amazon Kendra 目前仅支持尾随通配符。
+ 精确引号：精确匹配一串文本。例如，包含 `"Amazon Kendra" "pricing"` 的文档。
您可以使用上述任何运算符的组合。
请注意，过度使用运算符或查询高度复杂可能会影响查询延迟。就延迟而言，通配符是最昂贵的运算符之一。一般规则是，使用的术语和运算符越多，对延迟的潜在影响就越大。影响延迟的其他因素包括已编入索引的文档的平均大小、索引的大小、对搜索结果的任何筛选以及 Amazon Kendra 索引的总体负载。
### 布尔值
您可以使用布尔运算符 `AND`、`OR`、`NOT` 来组合或排除单词。
以下是使用布尔运算符的示例。
**`amazon AND sports`**
返回文本中同时包含术语“amazon”和“sports”的搜索结果，例如 Amazon Prime 视频体育或其他类似内容。
**`sports OR recreation`**
返回文本中包含“sports”或“recreation”或两者兼而有之的搜索结果。
**`amazon NOT rainforest`**
返回文本中包含“amazon”一词但不包含“rainforest”一词的搜索结果。这是为了搜索有关 Amazon 公司的文档，而不是 Amazon 雨林的文档。
### 圆括号
您可以使用圆括号按优先顺序查询嵌套单词。圆括号表示应 Amazon Kendra 如何读取查询。
以下是使用圆括号运算符的示例。
**`(amazon AND sports) NOT rainforest`**
返回文本中同时包含“amazon”和“sports”，但不包含“rainforest”一词的文档。这是为了搜索 Amazon Prime 视频体育或其他类似内容，而不是 Amazon 雨林中的冒险运动。括号有助于表明 `amazon AND sports` 应该在 `NOT rainforest` 之前读取。不应将该查询理解为 `amazon AND (sports NOT rainforest)`。
**`(amazon AND (sports OR recreation)) NOT rainforest`**
返回包含“sports”或“recreation”（或两者兼而有之）以及“amazon”一词的文档。但它不包括“rainforest”一词。这是为了搜索 Amazon Prime 视频体育或娱乐，而不是 Amazon 雨林中的冒险运动。括号有助于指明 `sports OR recreation` 应在与“amazon”合并之前阅读，即在 `NOT rainforest` 之前阅读。不应将该查询理解为 `amazon AND (sports OR (recreation NOT rainforest))`。
### 范围
您可以使用一系列值来筛选搜索结果。您必须为指定属性和范围值。这可以是日期或数字类型。
日期范围必须为以下格式：
+ Epoch
+ YYYY
+ YYYY-mm
+ YYYY-mm-dd
+ YYYY-mm-dd'T'HH
您还可以指定是包括还是排除范围的较低值和较高值。
以下是使用范围运算符的示例。
**`_processed_date:>2019-12-31 AND _processed_date:<2021-01-01`**
退回在 2020 年处理的文件，大于 2019 年 12 月 31 日且少于 2021 年 1 月 1 日。
**`_processed_date:>=2020-01-01 AND _processed_date:<=2020-12-31`**
退回在 2020 年处理的文件，大于或等于 2020 年 1 月 1 日且小于或等于 2020 年 12 月 31 日。
**`_document_likes:<1`**
返回点赞次数为零或没有用户反馈的文档，点赞次数少于 1。
您可以指定应将范围视为包含给定范围值还是不包含给定范围值。
**包含**
**`_last_updated_at:[2020-01-01 TO 2020-12-31]`**
返回文档最后更新时间为 2020 年，包括 2020 年 12 月 1 日和 2020 年 12 月 31 日。
**排除**
**`_last_updated_at:{2019-12-31 TO 2021-01-01}`**
返回文档最后更新时间为 2020 年，不包括 2019 年 12 月 31 日和 2021 年 1 月 1 日。
对于既不包含也不排除的无界定范围，只需使用 < and > 运算符即可。例如，`_last_updated_at:>2019-12-31 AND _last_updated_at:<2021-01-01`
#### 字段
您可以将搜索限制为仅返回符合特定字段值的文档。该字段可以是任意类型。
以下是使用字段级上下文运算符的示例。
**`status:"Incomplete" AND financial_year:2021`**
返回状态为“未完成”的 2021 财务年度文件。
**`(sports OR recreation) AND country:"United States" AND level:"professional"`**
返回讨论美国职业体育或娱乐活动的文档。
#### 通配符
您可以使用通配符运算符扩大搜索范围，以考虑单词和短语的变体。这在搜索名称变体时很有用。 Amazon Kendra 目前仅支持尾随通配符。尾随通配符的前缀字符数必须大于二。
以下是使用通配符运算符的示例。
**`Cloud*`**
返回包含 CloudFormation 和等变体的文档 CloudWatch。
**`kendra*aws`**
返回包含 kendra.amazonaws 等变体的文档。
**`kendra*aws*`**
返回包含 kendra.amazonaws.com 等变体的文档
#### 确切限额
您可以使用引号来搜索一段文本的精确匹配项。
以下是使用引号的示例。
**`"Amazon Kendra" "pricing"`**
返回同时包含短语“Amazon Kendra”和“定价”一词的文档。文档必须同时包含“Amazon Kendra”和“定价”才能返回结果。
**`"Amazon Kendra" "pricing" cost`**
返回同时包含短语“Amazon Kendra”和“定价”一词以及可选的“成本”一词的文档。文档必须同时包含“Amazon Kendra”和“定价”才能返回结果，但不一定包含“成本”。
#### 查询语法无效
Amazon Kendra 如果您的查询语法存在问题或当前不支持您的查询，则会发出警告 Amazon Kendra。有关更多信息，请参阅[有关查询警告的 API 文档](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Warning.html)。
以下查询是无效查询语法的示例。
**`_last_updated_at:<2021-12-32`**
日期无效。公历没有 32 日，只有 Amazon Kendra才会使用 32 日。
**`_view_count:ten`**
数值无效。必须使用数字来表示数值。
**`nonExistentField:123`**
字段搜索无效。该字段必须存在才能使用字段搜索。
**`Product:[A TO D]`**
范围无效。范围必须使用数值或日期。
**`OR Hello`**
布尔值无效。运算符必须与术语一起使用并置于术语之间。
## 搜索语言
您可以使用支持的语言搜索文档。您可以在中传递语言代码，[AttributeFilter](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeFilter.html)返回所选语言的已筛选文档。您可以使用支持的语言输入查询。
如果未指定语言，则默认 Amazon Kendra 查询英文文档。有关支持的语言（包括其代码）的更多信息，请参阅[添加非英语语言文档](https://docs.aws.amazon.com/kendra/latest/dg/in-adding-languages.html)。
要在控制台中以支持的语言搜索文档，请选择您的索引，然后从导航菜单中选择搜索索引的选项。选择搜索设置，然后从**语言**下拉列表中选择一种语言，即可选择要返回文档的语言。
以下示例显示了如何搜索西班牙语文档。
**在控制台中用西班牙语搜索索引**
1. 登录 AWS 管理控制台 并打开 Amazon Kendra 控制台，[网址为 http://console.aws.amazon.com/kendra/](https://console.aws.amazon.com/kendra)。
1. 在导航菜单中选择**索引**，然后选择索引。
1. 在导航菜单中，选择搜索索引的选项。
1. 在搜索设置中选择**语言**下拉列表并选择西班牙语。
1. 在文本框中输入查询，然后按 Enter。
1. Amazon Kendra 以西班牙语返回搜索结果。
**使用 CLI、Python 或 Java 搜索西班牙语索引**
+ 以下示例使用西班牙语搜索索引。将值 `searchString` 更改为搜索查询，并将值 `indexID` 更改为要搜索的索引的标识符。西班牙语的语言代码是 `es`。您可以将其替换为自己的语言代码。
------
#### [ CLI ]
```
{
"EqualsTo":{
"Key": "_language_code",
"Value": {
"StringValue": "es"
}
}
}
```
------
#### [ Python ]
```
import boto3
import pprint
kendra = boto3.client("kendra")
# Provide the index ID
index_id = "index-id"
# Provide the query text
query = "search-string"
# Includes the index ID, query text, and language attribute filter
response = kendra.query(
QueryText = query,
IndexId = index_id,
AttributeFilter = {
"EqualsTo": {
"Key": "_language_code",
"Value": {
"StringValue": "es"
}
}
})
print ("\nSearch results|Resultados de la búsqueda: " + query + "\n")
for query_result in response["ResultItems"]:
print("-------------------")
print("Type: " + str(query_result["Type"]))
if query_result["Type"]=="ANSWER" or query_result["Type"]=="QUESTION_ANSWER":
answer_text = query_result["DocumentExcerpt"]["Text"]
print(answer_text)
if query_result["Type"]=="DOCUMENT":
if "DocumentTitle" in query_result:
document_title = query_result["DocumentTitle"]["Text"]
print("Title: " + document_title)
document_text = query_result["DocumentExcerpt"]["Text"]
print(document_text)
print("------------------\n\n")
```
------
#### [ Java ]
```
package com.amazonaws.kendra;
import software.amazon.awssdk.services.kendra.KendraClient;
import software.amazon.awssdk.services.kendra.model.QueryRequest;
import software.amazon.awssdk.services.kendra.model.QueryResponse;
import software.amazon.awssdk.services.kendra.model.QueryResultItem;
public class SearchIndexExample {
public static void main(String[] args) {
KendraClient kendra = KendraClient.builder().build();
String query = "searchString";
String indexId = "indexID";
QueryRequest queryRequest = QueryRequest.builder()
.queryText(query)
.indexId(indexId)
.attributeFilter(
AttributeFilter.builder()
.withEqualsTo(
DocumentAttribute.builder()
.withKey("_language_code")
.withValue("es")
.build())
.build())
.build();
QueryResponse queryResponse = kendra.query(queryRequest);
System.out.println(String.format("\nSearch results|
Resultados de la búsqueda: %s", query));
for(QueryResultItem item: queryResponse.resultItems()) {
System.out.println("----------------------");
System.out.println(String.format("Type: %s", item.type()));
switch(item.type()) {
case QUESTION_ANSWER:
case ANSWER:
String answerText = item.documentExcerpt().text();
System.out.println(answerText);
break;
case DOCUMENT:
String documentTitle = item.documentTitle().text();
System.out.println(String.format("Title: %s", documentTitle));
String documentExcerpt = item.documentExcerpt().text();
System.out.println(String.format("Excerpt: %s", documentExcerpt));
break;
default:
System.out.println(String.format("Unknown query result type: %s", item.type()));
}
System.out.println("-----------------------\n");
}
}
}
```
------
# 检索段落
您可以将 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_Retrieve.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Retrieve.html) API 用作检索增强生成（RAG）系统的检索器。
RAG 系统使用生成式人工智能来构建问答应用程序。RAG 系统由检索器和大型语言模型（LLM）组成。给定一个查询，检索器会从文档语料库中识别出最相关的文本块，并将其提供给 LLM 以提供最有用的答案。然后，LLM 会分析相关的文本块或段落，并为查询生成全面的响应。
`Retrieve` API 会查看被称为*段落*的文本块或摘录，并返回与查询最相关的前述段落。
与 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) API 一样，`Retrieve` API 也搜索相关信息。Retrieve API 的信息检索会考虑查询的上下文以及已编制索引的文档中的所有可用信息。但是，默认情况下，`Query` API 仅返回最多 100 个标记词的摘录段落。使用 `Retrieve` API，您可以检索最多 200 个标记词和多达 100 个语义相关段落的较长段落。这不包括索引中的问题答案或常见问题解答类型的回复。这些段落（也称为文本块）是可以从多个文档或同一文档的不同部分中通过语义分析提取的文本摘录。Kendra 的 GenAI 企业版索引通过对向量与关键词索引使用混合搜索，结合深度学习模型排序，提供高精度的检索结果。
您还可以使用 `Retrieve` API 执行以下操作：
+ 覆盖指数级别的提升
+ 根据文档字段或属性进行筛选
+ 根据用户或其群组对文档的访问权限进行筛选
+ 查看置信度分数区以获取检索到的通过结果。 Amazon Kendra 的置信度分区提供相对排名，表示响应与查询相关的信心程度。
**注意**
置信度分数桶目前仅适用于英语。
您还可以在响应中加入某些字段，这些字段可能会提供有用的其他信息。
`Retrieve` API 当前不支持以下功能：使用[高级查询语法](https://docs.aws.amazon.com/kendra/latest/dg/searching-example.html#searching-index-query-syntax)进行查询、对查询使用[建议的拼写更正](https://docs.aws.amazon.com/kendra/latest/dg/query-spell-check.html)、[分面](https://docs.aws.amazon.com/kendra/latest/dg/filtering.html#search-facets)，自动完成搜索查询的[查询建议](https://docs.aws.amazon.com/kendra/latest/dg/query-suggestions.html)以及[增量学习](https://docs.aws.amazon.com/kendra/latest/dg/submitting-feedback.html)。任何检索 API 查询都不会出现在分析控制面板中。
`Retrieve` API 共享您为索引设置的[查询容量单位](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CapacityUnitsConfiguration.html)数。有关单个容量单位中包含的内容以及索引的默认基本容量的更多信息，请参阅[调整容量](https://docs.aws.amazon.com/kendra/latest/dg/adjusting-capacity.html)。
**注意**
如果您使用的是 Amazon Kendra 开发者版，则无法添加容量；只能在使用 Amazon Kendra 企业版时添加容量。有关开发人员版和企业版中包含的内容的更多信息，请参阅 [Amazon Kendra 版本](https://docs.aws.amazon.com/kendra/latest/dg/what-is-kendra.html#kendra-editions)。
以下是使用 `Retrieve` API 从 "how does amazon kendra work?" 查询索引中的文档中检索前 100 条最相关的段落的示例
------
#### [ Python ]
```
import boto3
import pprint
kendra = boto3.client("kendra")
# Provide the index ID
index_id = "index-id"
# Provide the query text
query = "how does amazon kendra work?"
# You can retrieve up to 100 relevant passages
# You can paginate 100 passages across 10 pages, for example
page_size = 10
page_number = 10
result = kendra.retrieve(
IndexId = index_id,
QueryText = query,
PageSize = page_size,
PageNumber = page_number)
print("\nRetrieved passage results for query: " + query + "\n")
for retrieve_result in result["ResultItems"]:
print("-------------------")
print("Title: " + str(retrieve_result["DocumentTitle"]))
print("URI: " + str(retrieve_result["DocumentURI"]))
print("Passage content: " + str(retrieve_result["Content"]))
print("------------------\n\n")
```
------
#### [ Java ]
```
package com.amazonaws.kendra;
import software.amazon.awssdk.services.kendra.KendraClient;
import software.amazon.awssdk.services.kendra.model.RetrieveRequest;
import software.amazon.awssdk.services.kendra.model.RetrieveResult;
import software.amazon.awssdk.services.kendra.model.RetrieveResultItem;
public class RetrievePassageExample {
public static void main(String[] args) {
KendraClient kendra = KendraClient.builder().build();
String indxId = "index-id";
String query = "how does amazon kendra work?";
Integer pgSize = 10;
Integer pgNumber = 10;
RetrieveRequest retrieveRequest = retrieveRequest
.builder()
.indexId(indxId)
.queryText(query)
.pageSize(pgSize)
.pageNumber(pgNumber)
.build();
RetrieveResult retrieveResult = kendra.retrieve(retrieveRequest);
System.out.println(String.format("\nRetrieved passage results for query: %s", query));
for(RetrieveResultItem item: retrieveResult.resultItems()) {
System.out.println("----------------------");
System.out.println(String.format("Title: %s", documentTitle));
System.out.println(String.format("URI: %s", documentURI));
System.out.println(String.format("Passage content: %s", content));
System.out.println("-----------------------\n");
}
}
}
```
------
# 浏览索引
**注意**
功能支持因所用索引类型和搜索 API 而异。要查看您使用的索引类型和搜索 API 是否支持此功能，请参阅[索引类型](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html)。
您无需键入搜索查询即可按其属性或分面浏览文档。 Amazon Kendra *浏览索引*可以帮助您的用户通过自由浏览索引来发现文档，而无需考虑特定的查询。这还可以帮助您的用户广泛浏览索引，将其作为搜索的起点。
浏览索引只能用于按文档属性或具有排序类型的分面进行搜索。不能使用“浏览索引”搜索整个索引。如果缺少查询文本，则 Amazon Kendra 要求提供文档属性筛选器或分面以及排序类型。
要允许使用[查询](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) API 浏览索引，必须包含[AttributeFilter](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeFilter.html)或 [Facet](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Facet.html) 和。[SortingConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_SortingConfiguration.html)要允许在控制台中浏览索引，请在导航菜单的**索引**下选择您的索引，然后选择搜索索引的选项。在搜索框中，按两次 *Enter* 键。选择下拉列表**筛选搜索结果**以选择筛选条件，然后选择下拉列表**排序**以选择排序类型。
以下是按文档创建日期降序浏览西班牙语文档索引的示例。
------
#### [ CLI ]
```
aws kendra query \
--index-id "index-id" \
--attribute-filter '{
"EqualsTo":{
"Key": "_language_code",
"Value": {
"StringValue": "es"
}
}
}' \
--sorting-configuration '{
"DocumentAttributeKey": "_created_at",
"SortOrder": "DESC"
}'
```
------
#### [ Python ]
```
import boto3
kendra = boto3.client("kendra")
# Must include the index ID, the attribute filter, and sorting configuration
response = kendra.query(
IndexId = "index-id",
AttributeFilter = {
"EqualsTo": {
"Key": "_language_code",
"Value": {
"StringValue": "es"
}
}
},
SortingConfiguration = {
"DocumentAttributeKey": "_created_at",
"SortOrder": "DESC"})
print("\nSearch results|Resultados de la búsqueda: \n")
for query_result in response["ResultItems"]:
print("-------------------")
print("Type: " + str(query_result["Type"]))
if query_result["Type"]=="ANSWER" or query_result["Type"]=="QUESTION_ANSWER":
answer_text = query_result["DocumentExcerpt"]["Text"]
print(answer_text)
if query_result["Type"]=="DOCUMENT":
if "DocumentTitle" in query_result:
document_title = query_result["DocumentTitle"]["Text"]
print("Title: " + document_title)
document_text = query_result["DocumentExcerpt"]["Text"]
print(document_text)
print("------------------\n\n")
```
------
#### [ Java ]
```
package com.amazonaws.kendra;
import software.amazon.awssdk.services.kendra.KendraClient;
import software.amazon.awssdk.services.kendra.model.QueryRequest;
import software.amazon.awssdk.services.kendra.model.QueryResult;
import software.amazon.awssdk.services.kendra.model.QueryResultItem;
public class SearchIndexExample {
public static void main(String[] args) {
KendraClient kendra = KendraClient.builder().build();
QueryRequest queryRequest = QueryRequest.builder()
.withIndexId("index-id")
.withAttributeFilter(AttributeFilter.builder()
.withEqualsTo(DocumentAttribute.builder()
.withKey("_language_code")
.withValue(DocumentAttributeValue.builder()
.withStringValue("es")
.build())
.build())
.build())
.withSortingConfiguration(SortingConfiguration.builder()
.withDocumentAttributeKey("_created_at")
.withSortOrder("DESC")
.build())
.build());
QueryResult queryResult = kendra.query(queryRequest);
for (QueryResultItem item : queryResult.getResultItems()) {
System.out.println("----------------------");
System.out.println(String.format("Type: %s", item.getType()));
switch (item.getType()) {
case QueryResultType.QUESTION_ANSWER:
case QueryResultType.ANSWER:
String answerText = item.getDocumentExcerpt().getText();
System.out.println(answerText);
break;
case QueryResultType.DOCUMENT:
String documentTitle = item.getDocumentTitle().getText();
System.out.println(String.format("Title: %s", documentTitle));
String documentExcerpt = item.getDocumentExcerpt().getText();
System.out.println(String.format("Excerpt: %s", documentExcerpt));
break;
default:
System.out.println(String.format("Unknown query result type: %s", item.getType()));
}
System.out.println("-----------------------\n");
}
}
}
```
------
# 精选搜索结果
**注意**
功能支持因所用索引类型和搜索 API 而异。要查看您使用的索引类型和搜索 API 是否支持此功能，请参阅[索引类型](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html)。
当您的用户发出某些查询时，您可以在搜索结果中突出显示特定文档。这有助于让用户更清楚地看到和突出显示结果。精选结果与通常的结果列表分开，并显示在搜索页面的顶部。您可以尝试为不同的查询提供不同的文档，或者确保某些文档获得应有的知名度。
您可以将特定查询映射到特定的文档，以便出现在结果中。如果查询包含完全匹配项，则搜索结果中会显示一个或多个特定文档。
例如，您可以指定，如果您的用户发布查询“2023 年新产品”，则选择标题为“最新动态”和“即将推出”的文档以显示在搜索结果页面的顶部。这有助于确保这些关于新产品的文档获得应有的知名度。
Amazon Kendra 如果搜索结果已被选中显示在搜索结果页面的顶部，则不会重复搜索结果。如果精选结果已经高于所有其他结果，则该结果不会再次被列为第一个结果。
为了显示某些结果，您必须使用查询中包含的关键字或短语来指定全文查询的精确匹配，而不是指定查询的部分匹配。例如，如果您仅在精选结果集中指定查询“Kendra”，则诸如“Kendra 在语义上如何对结果进行排名？”之类的查询 不会呈现精选结果。精选结果专为特定的查询而设计，而不是范围过于宽泛的查询。 Amazon Kendra 自然会处理关键字类型查询，以在搜索结果中对最有用的文档进行排名，从而避免根据简单关键字对结果进行过度精选。
如果您的用户经常使用某些查询，则可以为精选结果指定这些查询。例如，如果您使用 [Amazon Kendra Analytics](https://docs.aws.amazon.com/kendra/latest/dg/search-analytics.html) 查看热门查询，然后发现特定的查询，例如“kendra 在语义上如何对结果进行排名？” 和 “kendra 语义搜索” 经常被使用，那么这些查询对于指定标题为 “search 101” 的文档可能很有用。Amazon Kendra
Amazon Kendra 将对精选结果的查询视为不区分大小写。 Amazon Kendra 将查询转换为小写，并将尾随的空格字符替换为单个空格。 Amazon Kendra 匹配所有其他字符，就像您为精选结果指定查询时一样。
您可以使用 [CreateFeaturedResultsSet](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateFeaturedResultsSet.html)API 创建一组精选结果，将其映射到某些查询。如果您使用控制台，则可以选择您的索引，然后在导航菜单中选择**精选结果**来创建精选结果集。每个索引最多可以创建 50 组精选结果，每组最多可以创建 4 个精选文档，每个精选结果集最多可以创建 49 个查询文本。您可以联系 AWS [支持部门](https://aws.amazon.com/contact-us/)以提高这些限制。
您可以在多组精选结果中选择同一个文档。但是，不得在多个集合中使用相同的完全匹配查询文本。对于每个索引的每个精选结果集，您为精选结果指定的查询必须是唯一的。
在最多选择四个精选文档时，您可以排列文档的顺序。如果您使用 API，则列出精选文档的顺序与精选结果中显示的顺序相同。如果您使用控制台，则在选择要在结果中显示的文档时，只需拖放文档顺序即可。
配置精选结果时，仍然可以进行访问控制，即某些用户和群组可以访问某些文档，而其他用户和群组则不能。对于用户上下文筛选也是如此。例如，用户 A 属于“实习生”公司群组，该群组不应访问有关公司机密的文档。如果用户 A 输入包含公司机密文档的查询，则用户 A 不会在搜索结果中看到该文档。搜索结果页面上的任何其他结果也是如此。您还可以使用标签来控制对精选结果集的访问权限，该结果集是您可以控制访问权限的 Amazon Kendra 资源。
以下是创建一组精选结果的示例，其中查询“2023 年新产品”、“新产品上市”映射到标题为“最新动态”（doc-id-1）和“即将推出”（doc-id-2）的文档。
------
#### [ CLI ]
```
aws kendra create-featured-results-set \
--featured-results-set-name 'New product docs to feature' \
--description "Featuring What's new and Coming soon docs" \
--index-id index-id \
--query-texts 'new products 2023' 'new products available' \
--featured-documents '{"Id":"doc-id-1", "Id":"doc-id-2"}'
```
------
#### [ Python ]
```
import boto3
from botocore.exceptions import ClientError
import pprint
import time
kendra = boto3.client("kendra")
print("Create a featured results set.")
# Provide a name for the featured results set
featured_results_name = "New product docs to feature"
# Provide an optional decription for the featured results set
description = "Featuring What's new and Coming soon docs"
# Provide the index ID for the featured results set
index = "index-id"
# Provide a list of query texts for the featured results set
queries = ['new products 2023', 'new products available']
# Provide a list of document IDs for the featured results set
featured_doc_ids = [{"Id":"doc-id-1"}, {"Id":"doc-id-2"}]
try:
featured_results_set_response = kendra.create_featured_results_set(
FeaturedResultsSetName = featured_results_name,
Decription = description,
Index = index,
QueryTexts = queries,
FeaturedDocuments = featured_doc_ids
)
pprint.pprint(featured_results_set_response)
featured_results_set_id = featured_results_set_response["FeaturedResultsSetId"]
while True:
# Get the details of the featured results set, such as the status
featured_results_set_description = kendra.describe_featured_results_set(
Id = featured_results_set_id
)
status = featured_results_set_description["Status"]
print(" Featured results set status: "+status)
except ClientError as e:
print("%s" % e)
print("Program ends.")
```
------
# HTML 表格搜索
**注意**
功能支持因所用索引类型和搜索 API 而异。要查看您使用的索引类型和搜索 API 是否支持此功能，请参阅[索引类型](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html)。
Amazon Kendra的表格搜索功能可以从 HTML 文档中嵌入的表格中搜索和提取答案。搜索索引时，如果表中的摘录与查询相关，则 Amazon Kendra 包括该摘录并提供有用的信息。
Amazon Kendra 查看文档正文中的所有信息，包括表格中的有用信息。例如，索引包含业务报告，其中包含运营成本、收入和其他财务信息的表格。对于查询，“从2020-2022年起，每年的运营成本是多少？” ， Amazon Kendra 可以返回表格的摘录，该表包含相关的表格列 “运营（百万美元）” 和 “财政年度”，以及包含 2020 年、2021 年和 2022 年收入值的表格行。结果中包含表格摘录、文档标题、指向完整文档的链接以及您选择包含的任何其他文档字段。
无论信息是在表格的一个单元格中还是在多个单元格中找到，都可以在搜索结果中显示表格摘录。例如， Amazon Kendra 可以显示针对以下每种查询量身定制的表格摘录：
+ “2020 年利率最高的信用卡”
+ “2020-2022 年以来利率最高的信用卡”
+ “2020-2022 年利率排名前三的信用卡”
+ “利率低于 10% 的信用卡”
+ “所有可用的低息信用卡”
Amazon Kendra 突出显示与查询最相关的一个或多个表格单元格。搜索结果中会显示最相关的单元格及其对应的行、列和列名。表格摘录最多显示五列三行，具体取决于与查询相关的表格单元格数量以及原始表中有多少列可用。最相关的单元格与次要相关的单元格一起显示在表格摘录中。
响应包括置信度桶（`MEDIUM`,`HIGH`,`VERY_HIGH`），以显示表答案与查询的相关性。如果表格单元格的值是处于可信度的 `VERY_HIGH`，则该值将变为“最佳答案”并突出显示。对于置信度为 `HIGH` 的表格单元格值，则会突出显示这些值。对于可信的表格单元格值，则 `MEDIUM` 不会突出显示这些值。响应中会返回表答案的总体置信度。例如，如果表格主要包含有 `HIGH` 置信度的表格单元格，则表答案的响应中返回的总体置信度为 `HIGH` 置信度。
默认情况下，表格的重要性级别或权重不会高于文档的其他组成部分。在文档中，如果表与查询的相关性很小，但有一个高度相关的段落，则 Amazon Kendra 返回该段落的摘录。搜索结果显示同一文档或其他文档中提供最佳答案和最有用信息的内容。如果表格的置信度低于 `MEDIUM` 置信度，则响应中不会返回表格摘录。
要对现有索引使用表格搜索，必须将内容重新编入索引。
Amazon Kendra 表格搜索支持[同义词](https://docs.aws.amazon.com/kendra/latest/dg/index-synonyms.html)（包括自定义同义词）。 Amazon Kendra 仅支持带有表格标签内的 HTML 表格的英语文档。
以下示例显示了查询结果中包含的表摘录。要查看包含查询响应（包括表格摘录）的 JSON 示例，请参阅[查询响应和类型](https://docs.aws.amazon.com/kendra/latest/dg/query-responses-types.html)。
------
#### [ Python ]
```
import boto3
import pprint
kendra = boto3.client("kendra")
# Provide the index ID
index_id =
# Provide the query text
query = "search string"
response = kendra.query(
QueryText = query,
IndexId = index_id)
print("\nSearch results for query: " + query + "\n")
for query_result in response["ResultItems"]:
print("-------------------")
print("Type: " + str(query_result["Type"]))
print("Type: " + str(query_result["Format"]))
if query_result["Type"]=="ANSWER" and query_result["Format"]=="TABLE":
answer_table = query_result["TableExcerpt"]
print(answer_table)
if query_result["Type"]=="ANSWER" and query_result["Format"]=="TEXT":
answer_text = query_result["DocumentExcerpt"]
print(answer_text)
if query_result["Type"]=="QUESTION_ANSWER":
question_answer_text = query_result["DocumentExcerpt"]["Text"]
print(question_answer_text)
if query_result["Type"]=="DOCUMENT":
if "DocumentTitle" in query_result:
document_title = query_result["DocumentTitle"]["Text"]
print("Title: " + document_title)
document_text = query_result["DocumentExcerpt"]["Text"]
print(document_text)
print("------------------\n\n")
```
------
#### [ Java ]
```
package com.amazonaws.kendra;
import software.amazon.awssdk.services.kendra.KendraClient;
import software.amazon.awssdk.services.kendra.model.QueryRequest;
import software.amazon.awssdk.services.kendra.model.QueryResponse;
import software.amazon.awssdk.services.kendra.model.QueryResultItem;
public class SearchIndexExample {
public static void main(String[] args) {
KendraClient kendra = KendraClient.builder().build();
String query = "search string";
String indexId = "index-id";
QueryRequest queryRequest = QueryRequest
.builder()
.queryText(query)
.indexId(indexId)
.build();
QueryResponse queryResponse = kendra.query(queryRequest);
System.out.println(String.format("\nSearch results for query: %s", query));
for(QueryResultItem item: queryResponse.resultItems()) {
System.out.println("----------------------");
System.out.println(String.format("Type: %s", item.type()));
System.out.println(String.format("Format: %s", item.format()));
switch(item.format()) {
case TABLE:
String answerTable = item.TableExcerpt();
System.out.println(answerTable);
break;
}
switch(item.format()) {
case TEXT:
String answerText = item.DocumentExcerpt();
System.out.println(answerText);
break;
}
switch(item.type()) {
case QUESTION_ANSWER:
String questionAnswerText = item.documentExcerpt().text();
System.out.println(questionAnswerText);
break;
case DOCUMENT:
String documentTitle = item.documentTitle().text();
System.out.println(String.format("Title: %s", documentTitle));
String documentExcerpt = item.documentExcerpt().text();
System.out.println(String.format("Excerpt: %s", documentExcerpt));
break;
default:
System.out.println(String.format("Unknown query result type: %s", item.type()));
}
System.out.println("-----------------------\n");
}
}
}
```
------
# 查询建议
**注意**
功能支持因所用索引类型和搜索 API 而异。要查看您使用的索引类型和搜索 API 是否支持此功能，请参阅[索引类型](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html)。
Amazon Kendra *查询建议*可以帮助您的用户更快地键入搜索查询并引导他们搜索。
Amazon Kendra 根据以下其中一项建议与您的用户相关的查询：
+ 查询历史记录或查询日志中的热门查询
+ 文档字段/属性的内容
您可以通过将 `SuggestionTypes` 设置为 `QUERY` 或 `DOCUMENT_ATTRIBUTES` 并调用 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_GetQuerySuggestions.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_GetQuerySuggestions.html) 来设置使用查询历史记录或文档字段的首选项。默认情况下， Amazon Kendra 使用查询历史记录作为建议的基础。如果在您致电时查询历史记录和文档字段均已激活，[https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsConfig.html)并且您尚未将`SuggestionTypes`首选项设置为使用文档字段，则 Amazon Kendra 使用查询历史记录。
如果您使用控制台，则可以根据查询历史记录或文档字段提出查询建议。首先选择索引，然后在导航菜单的**富集**下选择**查询建议**。然后选择**配置查询建议**。配置查询建议后，系统会将您定向到搜索控制台，您可以在其中选择右侧面板中的**查询历史记录**或**文档字段**，然后在搜索栏中输入搜索查询。
默认情况下，使用查询历史记录和文档字段的查询建议均已激活，无需支付额外费用。您可以随时使用 `UpdateQuerySuggestionsConfig` API 停用这些类型的查询建议。要停用基于查询历史记录的查询建议，请在调用 `UpdateQuerySuggestionsConfig` 时将 `Mode` 设置为 `DISABLED`。要停用基于文档字段的查询建议，请在文档字段配置中将 `AttributeSuggestionsMode` 设置为 `INACTIVE`，然后调用 `UpdateQuerySuggestionsConfig>`。如果您使用控制台，则可以在**查询建议设置**中停用查询建议。
查询建议不区分大小写。 Amazon Kendra 将查询前缀和建议的查询转换为小写，忽略所有单引号和双引号，并将多个空格字符替换为单个空格。 Amazon Kendra 按原样匹配所有其他特殊字符。 Amazon Kendra 如果用户键入的字符少于两个或超过 60 个字符，则不会显示任何建议。
**Topics**
+ [基于查询历史记录提供查询建议](#query-suggestions-history)
+ [使用文档字段查询建议](#query-suggestions-doc-fields)
+ [从建议中屏蔽某些查询或文档字段内容](#query-suggestions-blocklist)
## 基于查询历史记录提供查询建议
**注意**
功能支持因所用索引类型和搜索 API 而异。要查看您使用的索引类型和搜索 API 是否支持此功能，请参阅[索引类型](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html)。
**Topics**
+ [为建议选择查询的设置](#query-suggestions-history-settings)
+ [在保留查询历史记录的同时清除建议](#query-suggestions-history-clear)
+ [没有可用的建议](#query-suggestions-history-none)
您可以选择根据查询历史记录或查询日志中的热门查询来建议与用户相关的查询。 Amazon Kendra 使用您的用户搜索并从这些查询中学到的所有查询来向您的用户提出建议。 Amazon Kendra 当用户开始键入查询时，向他们推荐热门查询。 Amazon Kendra 如果查询的前缀或前几个字符与用户开始键入的查询内容相匹配，则建议进行查询。
例如，用户开始键入查询“即将举行的活动”。 Amazon Kendra 从查询历史中了解到，许多用户已经多次搜索“2050 年即将举行的活动”。用户会看到“2050 年即将举行的活动”直接出现在他们的搜索栏下方，从而自动完成搜索查询。用户选择此查询建议，搜索结果中会返回文档“新事件：2050 年发生的事情”。
您可以指定如何 Amazon Kendra 选择符合条件的查询以向用户推荐。例如，您可以指定查询建议必须由至少 10 个独立用户进行搜索（默认值为 3 个），且在过去 30 天内搜索过，并且不包含[屏蔽列表](https://docs.aws.amazon.com/kendra/latest/dg/query-suggestions.html#query-suggestions-blocklist)中的任何单词或短语。 Amazon Kendra 要求查询至少有一个搜索结果并且包含至少一个超过四个字符的单词。
### 为建议选择查询的设置
您可以使用 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsConfig.html) API 配置以下设置，以便为建议选择查询：
+ **模式** - 使用查询历史记录为 `ENABLED` 或 `LEARN_ONLY` 的查询建议。 Amazon Kendra 默认情况下会激活查询建议。`LEARN_ONLY` 会关闭查询建议。如果禁用，则会 Amazon Kendra 继续学习建议，但不会向用户提出查询建议。
+ **查询日志时段** - 查询在查询日志时段中的最近查询时间。时段是从当天到过去几天的天数的整数值。
+ **不包含用户信息的查询** - 设置为 `TRUE` 以包含所有查询，或者设置为 `FALSE` 以仅包含具有用户信息的查询。如果您的搜索应用程序在用户发出查询时包含用户信息（例如用户 ID），则可以使用此设置。默认情况下，如果没有与查询关联的特定用户信息，则此设置不会筛选出查询。但是，您可以使用此设置仅根据包含用户信息的查询提出建议。
+ **唯一用户** - 必须搜索查询才有资格向您的用户推荐查询的最少唯一用户数。此数字是一个整数值。
+ **查询次数** - 必须搜索查询的最少次数，才有资格向用户推荐该查询。此数字是一个整数值。
这些设置会影响如何选择查询作为向用户推荐的热门查询。如何调整设置将取决于您的特定需求，例如：
+ 如果您的用户通常平均每月搜索一次，则可以将查询日志时段中的天数设置为 30 天。通过使用该设置，您可以在用户最近的大多数查询在时段内过时之前捕获这些查询。
+ 如果您的查询中只有少量包含用户信息，并且您不想根据较小的样本量建议查询，则可以将查询设置为包括所有用户。
+ 如果您将热门查询定义为至少有 10 个独立用户搜索并且搜索了至少 100 次，则可以将唯一用户设置为 10，将查询计数设置为 100。
**警告**
您对设置的更改可能不会立即生效。您可以使用 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html) API 跟踪设置更改。更新后的设置生效的时间取决于您所做的更新和索引中搜索查询的数量。在您更改设置或应用[屏蔽列表](https://docs.aws.amazon.com/kendra/latest/dg/query-suggestions.html#query-suggestions-blocklist)后， Amazon Kendra 每 24 小时自动更新一次建议。
------
#### [ CLI ]
**检索查询建议**
```
aws kendra get-query-suggestions \
--index-id index-id \
--query-text "query-text" \
--suggestion-types '["QUERY"]' \
--max-suggestions-count 1 // If you want to limit the number of suggestions
```
**更新查询建议**
例如，要更改查询日志的时段和必须搜索查询的最小次数，请执行以下操作：
```
aws kendra update-query-suggestions-config \
--index-id index-id \
--query-log-look-back-window-in-days 30 \
--minimum-query-count 100
```
------
#### [ Python ]
**检索查询建议**
```
import boto3
from botocore.exceptions import ClientError
kendra = boto3.client("kendra")
print("Get query suggestions.")
# Provide the index ID
index_id = "index-id"
# Provide the query text
query_text = "query"
# Provide the query suggestions type
query_suggestions_type = "QUERY"
# If you want to limit the number of suggestions
num_suggestions = 1
try:
query_suggestions_response = kendra.get_query_suggestions(
IndexId = index_id,
QueryText = query_text,
SuggestionTypes = query_suggestions_type,
MaxSuggestionsCount = num_suggestions
)
# Print out the suggestions you received
if ("Suggestions" in query_suggestions_response.keys()) {
for (suggestion: query_suggestions_response["Suggestions"]) {
print(suggestion["Value"]["Text"]["Text"]);
}
}
except ClientError as e:
print("%s" % e)
print("Program ends.")
```
**更新查询建议**
例如，要更改查询日志的时段和必须搜索查询的最小次数，请执行以下操作：
```
import boto3
from botocore.exceptions import ClientError
import pprint
import time
kendra = boto3.client("kendra")
print("Updating query suggestions settings/configuration for an index.")
# Provide the index ID
index_id = "index-id"
# Configure the settings you want to update
minimum_query_count = 100
query_log_look_back_window_in_days = 30
try:
kendra.update_query_suggestions_config(
IndexId = index_id,
MinimumQueryCount = minimum_query_count,
QueryLogLookBackWindowInDays = query_log_look_back_window_in_days
)
print("Wait for Amazon Kendra to update the query suggestions.")
while True:
# Get query suggestions description of settings/configuration
query_sugg_config_response = kendra.describe_query_suggestions_config(
IndexId = index_id
)
# If status is not UPDATING, then quit
status = query_sugg_config_response["Status"]
print(" Updating query suggestions config. Status: " + status)
if status != "UPDATING":
break
time.sleep(60)
except ClientError as e:
print("%s" % e)
print("Program ends.")
```
------
### 在保留查询历史记录的同时清除建议
**注意**
功能支持因所用索引类型和搜索 API 而异。要查看您使用的索引类型和搜索 API 是否支持此功能，请参阅[索引类型](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html)。
您可以使用 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html) API 清除查询建议。清除建议只会删除现有的查询建议，而不会删除查询历史记录中的查询。当您清除建议时， Amazon Kendra 会根据您清除建议后添加到查询日志中的新查询来学习新的建议。
------
#### [ CLI ]
**清除查询建议**
```
aws kendra clear-query-suggestions \
--index-id index-id
```
------
#### [ Python ]
**清除查询建议**
```
import boto3
from botocore.exceptions import ClientError
kendra = boto3.client("kendra")
print("Clearing out query suggestions for an index.")
# Provide the index ID
index_id = "index-id"
try:
kendra.clear_query_suggestions(
IndexId = index_id
)
# Confirm last cleared date-time and that there are no suggestions
query_sugg_config_response = kendra.describe_query_suggestions_config(
IndexId = index_id
)
print("Query Suggestions last cleared at: " + str(query_sugg_config_response["LastClearTime"]));
print("Number of suggestions available from the time of clearing: " + str(query_sugg_config_response["TotalSuggestionsCount"]));
except ClientError as e:
print("%s" % e)
print("Program ends.")
```
------
### 没有可用的建议
如果未看到查询建议，可能是出于以下原因之一：
+ 您的索引中没有足够的查询 Amazon Kendra 可供借鉴。
+ 您的查询建议设置过于严格，导致大多数查询都被从建议中筛选掉。
+ 您最近清除了建议， Amazon Kendra 但仍需要时间积累新的查询，以便学习新的建议。
您可以使用 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html) API 检查当前设置。
## 使用文档字段查询建议
**Topics**
+ [为建议选择字段的设置](#query-suggestions-doc-fields-settings)
+ [文档字段中的用户控制](#query-suggestions-doc-fields-user-control)
您可以选择根据文档字段的内容建议与用户相关的查询。您可以使用文档字段中包含的有助于自动完成查询的信息，而不是使用查询历史记录来建议其他常见的相关查询。 Amazon Kendra 在设置为`Suggestable`且与用户查询非常一致的字段中查找相关内容。然后，当您的用户开始键入查询内容时，向他们 Amazon Kendra 推荐这些内容。
例如，如果您指定了作为建议基础的标题字段，然后用户开始键入查询 “How amazon ken... '，可以建议使用最相关的标题 “ Amazon Kendra 工作原理” 来自动完成搜索。用户会看到 “ Amazon Kendra 工作原理” 直接出现在搜索栏下方，自动完成搜索查询。用户选择此查询建议，搜索结果中将返回 “ Amazon Kendra 工作原理” 文档。
您可以使用 `String` 和 `StringList` 类型的任意文档字段的内容来建议查询，方法是将该字段作为查询建议字段配置的一部分设置为 `Suggestable`。您也可以使用[屏蔽列表](https://docs.aws.amazon.com/kendra/latest/dg/query-suggestions.html#query-suggestions-blocklist)，这样就不会向用户显示包含某些单词或短语的建议文档字段。您可以使用一个阻止列表。无论您将查询建议设置为使用查询历史记录还是文档字段，屏蔽列表都适用。
### 为建议选择字段的设置
您可以使用 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeSuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeSuggestionsConfig.html) 并调用 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsConfig.html) API 来更新索引级别的设置来配置以下设置，以便为建议选择文档字段：
+ **字段/属性建议模式** - 使用文档字段为 `ACTIVE` 或 `INACTIVE` 的查询建议。 Amazon Kendra 在默认情况下会激活查询建议。
+ **可建议的字段/属性** - 作为建议基础的字段名称或字段键。作为字段配置的一部分，必须将这些字段设置为 `Suggestable` 的 `TRUE`。您可以在查询级别覆盖字段配置，同时保持索引级别的配置。使用 [GetQuerySuggestions](https://docs.aws.amazon.com/kendra/latest/APIReference/API_GetQuerySuggestions.html)API 在查询`AttributeSuggestionConfig`级别进行更改。查询级别的这种配置对于快速尝试使用不同的文档字段非常有用，而不必在索引级别更新配置。
+ **其他字段/属性** - 您要在查询建议的响应中包含的其他字段。这些字段用于在回复中提供额外信息；但是，它们不用于作为建议的依据。
**警告**
您对设置的更改可能不会立即生效。您可以使用 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html) API 跟踪设置更改。更新后的设置生效的时间取决于您所做的更新。 Amazon Kendra 在您更改设置后或应用[屏蔽列表](https://docs.aws.amazon.com/kendra/latest/dg/query-suggestions.html#query-suggestions-blocklist)后，每 24 小时自动更新一次建议。
------
#### [ CLI ]
在查询级别检索查询建议并覆盖文档字段配置，而不必在索引级别更改配置。
```
aws kendra get-query-suggestions \
--index-id index-id \
--query-text "query-text" \
--suggestion-types '["DOCUMENT_ATTRIBUTES"]' \
--attribute-suggestions-config '{"SuggestionAttributes":'["field/attribute key 1", "field/attribute key 2"]', "AdditionalResponseAttributes":'["response field/attribute key 1", "response field/attribute key 2"]'}' \
--max-suggestions-count 1 // If you want to limit the number of suggestions
```
**更新查询建议**
例如，要更改索引级别的文档字段配置，请执行以下操作：
```
aws kendra update-query-suggestions-config \
--index-id index-id \
--attribute-suggestions-config '{"SuggestableConfigList": '[{"SuggestableConfig": "_document_title", "Suggestable": true}]', "AttributeSuggestionsMode": "ACTIVE"}'
```
------
#### [ Python ]
在查询级别检索查询建议并覆盖文档字段配置，而不必在索引级别更改配置。
```
import boto3
from botocore.exceptions import ClientError
kendra = boto3.client("kendra")
print("Get query suggestions.")
# Provide the index ID
index_id = "index-id"
# Provide the query text
query_text = "query"
# Provide the query suggestions type
query_suggestions_type = "DOCUMENT_ATTRIBUTES"
# Override fields/attributes configuration at query level
configuration = {"SuggestionAttributes":
'["field/attribute key 1", "field/attribute key 2"]',
"AdditionalResponseAttributes":
'["response field/attribute key 1", "response field/attribute key 2"]'
}
# If you want to limit the number of suggestions
num_suggestions = 1
try:
query_suggestions_response = kendra.get_query_suggestions(
IndexId = index_id,
QueryText = query_text,
SuggestionTypes = [query_suggestions_type],
AttributeSuggestionsConfig = configuration,
MaxSuggestionsCount = num_suggestions
)
# Print out the suggestions you received
if ("Suggestions" in query_suggestions_response.keys()) {
for (suggestion: query_suggestions_response["Suggestions"]) {
print(suggestion["Value"]["Text"]["Text"]);
}
}
except ClientError as e:
print("%s" % e)
print("Program ends.")
```
**更新查询建议**
例如，要更改索引级别的文档字段配置，请执行以下操作：
```
import boto3
from botocore.exceptions import ClientError
import pprint
import time
kendra = boto3.client("kendra")
print("Updating query suggestions settings/configuration for an index.")
# Provide the index ID
index_id = "index-id"
# Configure the settings you want to update at the index level
configuration = {"SuggestableConfigList":
'[{"SuggestableConfig": "_document_title", "Suggestable": true}]',
"AttributeSuggestionsMode": "ACTIVE"
}
try:
kendra.update_query_suggestions_config(
IndexId = index_id,
AttributeSuggestionsConfig = configuration
)
print("Wait for Amazon Kendra to update the query suggestions.")
while True:
# Get query suggestions description of settings/configuration
query_sugg_config_response = kendra.describe_query_suggestions_config(
IndexId = index_id
)
# If status is not UPDATING, then quit
status = query_sugg_config_response["Status"]
print(" Updating query suggestions config. Status: " + status)
if status != "UPDATING":
break
time.sleep(60)
except ClientError as e:
print("%s" % e)
print("Program ends.")
```
------
### 文档字段中的用户控制
您可以将用户上下文筛选应用于要作为查询建议基础的文档字段。这会根据用户或其群组对文档的访问权限来筛选文档字段信息。例如，实习生搜索公司的门户网站，却无权访问公司绝密文档。因此，不会向实习生显示基于绝密文档标题或任何其他可建议字段的建议查询。
您可以使用访问控制列表（ACL）为文档编制索引，该列表定义为哪些用户和组分配了对哪些文档的访问权限。然后，您可以对文档字段应用用户上下文筛选以获得查询建议。当前为您的索引设置的用户上下文筛选与应用于您的文档字段配置的查询建议的用户上下文筛选相同。用户上下文筛选是您的文档字段配置的一部分。您使用 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeSuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeSuggestionsConfig.html) 并调用 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_GetQuerySuggestions.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_GetQuerySuggestions.html)。
## 从建议中屏蔽某些查询或文档字段内容
屏*蔽 Amazon Kendra 列表*不会向您的用户建议某些查询。屏蔽列表是您要从查询建议中排除的单词或短语的列表。 Amazon Kendra 不包括包含与屏蔽列表中的单词或短语完全匹配的查询。
您可以使用屏蔽列表来防范经常出现在您的查询历史记录或文档字段中，并且 Amazon Kendra 可能将其选为建议的冒犯性单词或短语。屏蔽列表还可以 Amazon Kendra 防止建议包含尚未准备好公开发布或宣布的信息的查询。例如，您的用户经常询问即将发布的潜在新产品。但是，您不想推荐该产品，因为您尚未准备好发布该产品。您可以屏蔽建议中包含产品名称和产品信息的查询。
您可以使用 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateQuerySuggestionsBlockList.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateQuerySuggestionsBlockList.html) API 为查询创建阻止列表。将每个屏蔽单词或短语放在文本文件中单独一行中。然后，您将文本文件上传到您的 Amazon S3 存储桶，并在中提供该文件的路径或位置 Amazon S3。 Amazon Kendra 目前仅支持创建一个阻止列表。
您可以替换 Amazon S3 存储桶中屏蔽的单词和短语的文本文件。要更新中的屏蔽列表 Amazon Kendra，请使用 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsBlockList.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsBlockList.html)API。
使用 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsBlockList.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsBlockList.html) API 获取屏蔽列表的状态。`DescribeQuerySuggestionsBlockList` 还可以为您提供其他有用的信息，例如以下信息：
+ 上次更新屏蔽名单的时间
+ 您当前的屏蔽列表中有多少个单词或短语
+ 创建屏蔽名单时的有用错误消息
您还可以使用 [https://docs.aws.amazon.com/kendra/latest/APIReference/API_ListQuerySuggestionsBlockLists.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_ListQuerySuggestionsBlockLists.html) API 获取索引的屏蔽列表摘要列表。
要删除您的屏蔽名单，请使用 [DeleteQuerySuggestionsBlockList](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DeleteQuerySuggestionsBlockList.html)API。
您对屏蔽列表的更新可能不会立即生效。您可以使用 `DescribeQuerySuggestionsBlockList` API 跟踪更新。
------
#### [ CLI ]
**创建屏蔽列表**
```
aws kendra create-query-suggestions-block-list \
--index-id index-id \
--name "block-list-name" \
--description "block-list-description" \
--source-s3-path "Bucket=bucket-name,Key=query-suggestions/block_list.txt" \
--role-arn role-arn
```
**更新屏蔽列表**
```
aws kendra update-query-suggestions-block-list \
--index-id index-id \
--name "new-block-list-name" \
--description "new-block-list-description" \
--source-s3-path "Bucket=bucket-name,Key=query-suggestions/new_block_list.txt" \
--role-arn role-arn
```
**删除屏蔽列表**
```
aws kendra delete-query-suggestions-block-list \
--index-id index-id \
--id block-list-id
```
------
#### [ Python ]
**创建屏蔽列表**
```
import boto3
from botocore.exceptions import ClientError
import pprint
import time
kendra = boto3.client("kendra")
print("Create a query suggestions block list.")
# Provide a name for the block list
block_list_name = "block-list-name"
# Provide an optional description for the block list
block_list_description = "block-list-description"
# Provide the IAM role ARN required for query suggestions block lists
block_list_role_arn = "role-arn"
# Provide the index ID
index_id = "index-id"
s3_bucket_name = "bucket-name"
s3_key = "query-suggestions/block_list.txt"
source_s3_path = {
'Bucket': s3_bucket_name,
'Key': s3_key
}
try:
block_list_response = kendra.create_query_suggestions_block_list(
Description = block_list_description,
Name = block_list_name,
RoleArn = block_list_role_arn,
IndexId = index_id,
SourceS3Path = source_s3_path
)
print(block_list_response)
block_list_id = block_list_response["Id"]
print("Wait for Amazon Kendra to create the block list.")
while True:
# Get block list description
block_list_description = kendra.describe_query_suggestions_block_list(
Id = block_list_id,
IndexId = index_id
)
# If status is not CREATING, then quit
status = block_list_description["Status"]
print("Creating block list. Status: " + status)
if status != "CREATING":
break
time.sleep(60)
except ClientError as e:
print("%s" % e)
print("Program ends.")
```
**更新屏蔽列表**
```
import boto3
from botocore.exceptions import ClientError
import pprint
import time
kendra = boto3.client("kendra")
print("Update a block list for query suggestions.")
# Provide the block list name you want to update
block_list_name = "new-block-list-name"
# Provide the block list description you want to update
block_list_description = "new-block-list-description"
# Provide the IAM role ARN required for query suggestions block lists
block_list_role_arn = "role-arn"
# Provide the block list ID
block_list_id = "block-list-id"
# Provide the index ID
index_id = "index-id"
s3_bucket_name = "bucket-name"
s3_key = "query-suggestions/new_block_list.txt"
source_s3_path = {
'Bucket': s3_bucket_name,
'Key': s3_key
}
try:
kendra.update_query_suggestions_block_list(
Id = block_list_id,
IndexId = index_id,
Description = block_list_description,
Name = block_list_name,
RoleArn = block_list_role_arn,
SourceS3Path = source_s3_path
)
print("Wait for Amazon Kendra to update the block list.")
while True:
# Get block list description
block_list_description = kendra.describe_query_suggestions_block_list(
Id = block_list_id,
IndexId = index_id
)
# If status is not UPDATING, then the update has finished
status = block_list_description["Status"]
print("Updating block list. Status: " + status)
if status != "UPDATING":
break
time.sleep(60)
except ClientError as e:
print("%s" % e)
print("Program ends.")
```
**删除屏蔽列表**
```
import boto3
from botocore.exceptions import ClientError
kendra = boto3.client("kendra")
print("Delete a block list for query suggestions.")
# provide the block list ID
query_suggestions_block_list_id = "query-suggestions-block-list-id"
# Provide the index ID
index_id = "index-id"
try:
kendra.delete_query_suggestions_block_list(
Id = query_suggestions_block_list_id,
IndexId = index_id
)
except ClientError as e:
print("%s" % e)
print("Program ends.")
```
------
# 查询拼写检查程序
**注意**
功能支持因所用索引类型和搜索 API 而异。要查看您使用的索引类型和搜索 API 是否支持此功能，请参阅[索引类型](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html)。
Amazon Kendra *拼写检查工具*会针对查询给出拼写更正建议。这可以帮助您将出现零搜索结果的次数降至最低，并返回相关结果。对于拼写错误的查询，您的用户可能会收到[零搜索结果为](https://docs.aws.amazon.com/kendra/latest/dg/search-analytics.html#search-analytics-metrics)，即没有匹配结果或未返回文档。或者，您的用户可能会从拼写错误的查询中收到[不相关的搜索结果](https://docs.aws.amazon.com/kendra/latest/dg/search-analytics.html#search-analytics-metrics)。
拼写检查器旨在根据索引文档中出现的单词以及更正后的单词与拼写错误的单词的匹配程度，对拼写错误的单词提出更正建议。例如，如果您的索引文档中出现“statements”一词，则这可能与查询“年终财务报表”中拼写错误的“statments”一词非常匹配。
拼写检查器返回替换原始查询文本中拼写错误的单词的预期或更正的单词。例如，“depoying kendre search”可能返回“deploying Kendra search”。您还可以使用 API 中提供的偏移位置在前端应用程序的查询中突出显示或斜体显示返回的更正单词。在控制台中，默认情况下，更正后的单词会突出显示或斜体显示。例如，“*deploying* *Kendra* search”。
对于索引文档中出现的业务特定术语或专业术语，拼写检查工具不会将这些术语误解为查询中的拼写错误。例如，“amazon macie”不会更正为“amazon mace”。
对于带连字符的单词，例如“year-end”，拼写检查器会将其视为单个单词，以建议对这些单词进行更正。例如，“yaer-end”的建议更正可能是“year-end”。
对于 `DOCUMENT` 和 `QUESTION_ANSWER` 查询响应类型，拼写检查器会根据文档正文中的单词建议更正拼写错误的单词。在建议与拼写错误的单词非常匹配的更正时，文档正文比标题更可靠。对于 `ANSWER` 查询响应类型，拼写检查器会根据索引中默认问答文档中的单词建议更正。
你可以使用该[SpellCorrectionConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_SpellCorrectionConfiguration.html)物体激活拼写检查器。将 `IncludeQuerySpellCheckSuggestions` 设置为 `TRUE`。默认情况下，控制台中的拼写检查器处于激活状态。默认情况下，它内置在控制台中。
拼写检查器还可以为多种语言的查询提供拼写更正建议，而不仅仅是英语。有关拼写检查器支持的语言列表，请参阅 [Amazon Kendra 支持的语言](https://docs.aws.amazon.com/kendra/latest/dg/in-adding-languages.html)。
## 使用带有默认限制的查询拼写检查器
拼写检查器设计有特定的默认值或限制。以下是激活拼写校正建议时适用的当前限制列表。
+ 对于长度少于三个字符或大于 30 个字符的单词，不能返回建议的拼写更正。要允许超过 30 个字符或少于三个字符，请联系[支持部门](https://aws.amazon.com/contact-us/)。
+ 建议的拼写更正不能根据用户访问控制或[用户上下文筛选](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html)的访问控制列表来限制建议。拼写校正基于已编入索引的文档中的所有单词，无论这些单词是否仅限于某些用户。如果您想避免某些单词出现在建议的查询拼写更正中，请不要激活 `SpellCorrectionConfiguration`。
+ 对于包含数字的单词，无法返回建议的拼写更正。例如，“how 2 not br8k ubun2”。
+ 建议的拼写更正不能使用未出现在已编入索引的文档中的单词。
+ 建议的拼写更正不能使用索引文档中出现频率低于 0.01% 的单词。要更改 0.01% 的阈值，请联系[支持部门](https://aws.amazon.com/contact-us/)。
# 筛选和分面搜索
**注意**
功能支持因所用索引类型和搜索 API 而异。要查看您使用的索引类型和搜索 API 是否支持此功能，请参阅[索引类型](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html)。
您可以使用筛选条件改善来自 [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) API 的搜索结果或响应。筛选条件将响应中的文档限制为直接应用于查询的文档。要创建分面搜索建议，请使用布尔逻辑从响应或不符合特定条件的文档中筛选出特定的文档属性。您可以使用 `Query` API 中的 `Facets` 参数指定分面。
要搜索已编入索引的 Amazon Kendra 文档 Amazon Lex，请使用[亚马逊。 KendraSearchIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_KendraConfiguration.html)。有关使用进行配置的示例 Amazon Kendra Amazon Lex，请参阅[为 Amazon Kendra 索引创建常见问题解答机器人](https://docs.aws.amazon.com/lexv2/latest/dg/faq-bot-kendra-search.html)。您也可以使用为响应提供过滤器[AttributeFilter](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeFilter.html)。这是配置 `AMAZON.KendraSearchIntent` 时采用 JSON 格式的查询筛选条件。要在控制台中配置搜索意图时提供属性筛选条件，请转到意图编辑器并选择 Amazon Kendra 查询以提供 JSON 格式的查询筛选条件。有关 `AMAZON.KendraSearchIntent` 的更多信息，请参阅 [Amazon Lex 文档](https://docs.aws.amazon.com/lexv2/latest/dg/built-in-intent-kendra-search.html)。
## 分面
分面是一组搜索结果的限定视图。例如，您可以为世界各地的城市提供搜索结果，其中文档按与其关联的特定城市进行筛选。或者，您可以创建分面来显示特定作者的结果。
您可以将与文档关联的文档属性或元数据字段用作分面，这样您的用户就可以按类别或该分面内的值进行搜索。您还可以在搜索结果中显示嵌套分面，这样您的用户不仅可以按类别或字段进行搜索，还可以按子类别或子字段进行搜索。
以下示例显示了如何获取“City”自定义属性的分面信息。
```
response=kendra.query(
QueryText = query,
IndexId = index,
Facets = [
{
"DocumentAttributeKey" : "City"
}
]
)
```
您可以使用嵌套分面来进一步缩小搜索范围。例如，文档属性或分面“City”包括一个名为“Seattle”的值。此外，文档属性或分面 “CityRegion” 包括分配给 “西雅图” 的文档的 “北” 和 “南” 值。您可以在搜索结果中显示嵌套的刻面及其计数，这样不仅可以按城市搜索文档，还可以按城市内的区域搜索文档。
请注意，嵌套分面可能会影响查询延迟。一般规则是，使用的术语和运算符越多，对延迟的潜在影响就越大。影响延迟的其他因素包括已编入索引的文档的平均大小、索引的大小、高度复杂的查询以及 Amazon Kendra 索引的总体负载。
以下示例说明如何获取 “” 自定义属性的分面信息，作为 “CityCityRegion” 中的嵌套分面。
```
response=kendra.query(
QueryText = query,
IndexId = index,
Facets = [
{
"DocumentAttributeKey" : "City",
"Facets": [
{
"DocumentAttributeKey" : "CityRegion"
}
]
}
]
)
```
分面信息（例如文档数量）将在 `FacetResults` 响应数组中返回。您可以使用这些内容在应用程序中显示分面搜索建议。例如，如果文档属性“City”包含可应用搜索的城市，则使用该信息显示城市搜索列表。用户可以选择城市来筛选搜索结果。要进行分面搜索，请调用 [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) API 并使用所选文档属性筛选结果。
对于查询，每个分面最多可以显示 10 个分面值，并且在一个分面内只能显示一个嵌套分面。如果要增加这些限制，请联系[支持部门](https://aws.amazon.com/contact-us/)。如果要将每个刻面的刻面值数限制为小于 10，则可以在 `Facet` 对象中进行指定。
以下 JSON 响应示例，显示了限于“City”文档属性的各个方面。响应包括分面值的文档数量。
```
{
'FacetResults': [
{
'DocumentAttributeKey': 'City',
'DocumentAttributeValueCountPairs': [
{
'Count': 3,
'DocumentAttributeValue': {
'StringValue': 'Dubai'
}
},
{
'Count': 3,
'DocumentAttributeValue': {
'StringValue': 'Seattle'
}
},
{
'Count': 1,
'DocumentAttributeValue': {
'StringValue': 'Paris'
}
}
]
}
]
```
您还可以显示嵌套分面（例如城市中的区域）的刻面信息，以进一步筛选搜索结果。
以下 JSON 响应示例，将范围限于 “CityRegion” 文档属性的分面显示为 “城市” 中的嵌套分面。响应包括嵌套分面值的文档数量。
```
{
'FacetResults': [
{
'DocumentAttributeKey': 'City',
'DocumentAttributeValueCountPairs': [
{
'Count': 3,
'DocumentAttributeValue': {
'StringValue': 'Dubai'
},
'FacetResults': [
{
'DocumentAttributeKey': 'CityRegion',
'DocumentAttributeValueCountPairs': [
{
'Count': 2,
'DocumentAttributeValue': {
'StringValue': 'Bur Dubai'
}
},
{
'Count': 1,
'DocumentAttributeValue': {
'StringValue': 'Deira'
}
}
]
}
]
},
{
'Count': 3,
'DocumentAttributeValue': {
'StringValue': 'Seattle'
},
'FacetResults': [
{
'DocumentAttributeKey': 'CityRegion',
'DocumentAttributeValueCountPairs': [
{
'Count': 1,
'DocumentAttributeValue': {
'StringValue': 'North'
}
},
{
'Count': 2,
'DocumentAttributeValue': {
'StringValue': 'South'
}
}
]
}
]
},
{
'Count': 1,
'DocumentAttributeValue': {
'StringValue': 'Paris'
},
'FacetResults': [
{
'DocumentAttributeKey': 'CityRegion',
'DocumentAttributeValueCountPairs': [
{
'Count': 1,
'DocumentAttributeValue': {
'StringValue': 'City center'
}
}
]
}
]
}
}
]
}
```
使用字符串列表字段创建分面时，返回的分面结果基于字符串列表的内容。例如，如果您有一个包含两个项目的字符串列表字段，一个列表为“dachshund”、“sausage dog”，另一个的值为“husky”，那么 `FacetResults` 就会得到三个分面。
有关更多信息，请参阅[查询响应和响应类型](query-responses-types.md)。
## 使用文档属性筛选搜索结果
默认情况下，`Query` 会返回所有搜索结果。要筛选响应，可以对文档属性执行逻辑操作。例如，如果您只需要特定城市的文档，则可以筛选“City”和“State”的自定义文档属性。您可以使用[AttributeFilter](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeFilter.html)对提供的过滤器创建布尔运算。
大多数属性可用于筛选所有[响应类型](https://docs.aws.amazon.com/kendra/latest/dg/query-responses-types.html)的响应。但是，`_excerpt_page_number` 属性仅适用于筛选响应时的 `ANSWER` 响应类型。
以下示例说明如何通过筛选特定城市（*西雅图*和*华盛顿*州）来执行逻辑 AND 运算。
```
response=kendra.query(
QueryText = query,
IndexId = index,
AttributeFilter = {'AndAllFilters':
[
{"EqualsTo": {"Key": "City","Value": {"StringValue": "Seattle"}}},
{"EqualsTo": {"Key": "State","Value": {"StringValue": "Washington"}}}
]
}
)
```
以下示例说明如何在`Fileformat`、`Author`或`SourceURI`键中任意一个与指定值匹配时执行逻辑 OR 运算。
```
response=kendra.query(
QueryText = query,
IndexId = index,
AttributeFilter = {'OrAllFilters':
[
{"EqualsTo": {"Key": "Fileformat","Value": {"StringValue": "AUTO_DETECT"}}},
{"EqualsTo": {"Key": "Author","Value": {"StringValue": "Ana Carolina"}}},
{"EqualsTo": {"Key": "SourceURI","Value": {"StringValue": "https://aws.amazonaws.com/234234242342"}}}
]
}
)
```
对于`StringList`字段，使用`ContainsAny`或`ContainsAll`属性筛选条件返回包含指定字符串的文档。以下示例说明如何返回`Locations`自定义属性中值为“Seattle”或“Portland”的所有文档。
```
response=kendra.query(
QueryText = query,
IndexId = index,
AttributeFilter = {
"ContainsAny": { "Key": "Locations", "Value": { "StringListValue": [ "Seattle", "Portland"] }}
}
)
```
## 筛选搜索结果中每个文档的属性
Amazon Kendra 返回搜索结果中每个文档的文档属性。您可以筛选要作为搜索结果一部分包含在响应中的某些文档属性。默认情况下，分配给文档的所有文档属性都将在响应中返回。
在以下示例中，`_author`文档的响应中仅包含`_source_uri`和文档属性。
```
response=kendra.query(
QueryText = query,
IndexId = index,
RequestedDocumentAttributes = ["_source_uri", "_author"]
)
```
# 根据用户上下文进行筛选
**注意**
功能支持因所用索引类型和搜索 API 而异。要查看您使用的索引类型和搜索 API 是否支持此功能，请参阅[索引类型](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html)。
您可以根据用户或其所在组对文档的访问权限来筛选用户的搜索结果。您可以使用用户令牌、用户 ID 或用户属性来筛选文档。
用户上下文筛选是一种个性化搜索，其优点是控制对文档的访问权限。例如，并非所有在公司门户网站上搜索信息的团队都应该访问绝密的公司文档，这些文档也不应与所有用户相关。只有获得绝密文档访问权限的特定用户或团队组才能在搜索结果中看到这些文档。
将文档编入索引后 Amazon Kendra，会为大多数文档提取相应的访问控制列表 (ACL)。ACL 指定允许或拒绝哪些用户名和组名访问文档。没有 ACL 的文档是公共文档。
Amazon Kendra 可以为大多数数据源提取与每个文档关联的用户或群组信息。例如，Quip 中的文档可以包含有权访问该文档的精选用户的“共享”列表。如果您使用 S3 存储桶作为数据来源，则需要为 ACL 提供一个 [JSON 文件](https://docs.aws.amazon.com/kendra/latest/dg/s3-acl.html)，并将该文件的 S3 路径作为数据来源配置的一部分。如果将文档直接添加到索引，则可以在 Princip [al](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Principal.html) 对象中指定 ACL 作为 [BatchPutDocument](https://docs.aws.amazon.com/kendra/latest/APIReference/API_BatchPutDocument.html)API 中文档对象的一部分。
如果您使用的是 Amazon Kendra Enterprise 索引或开发者版索引，则可以使用 [CreateAccessControlConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateAccessControlConfiguration.html)API 重新配置现有的文档级别访问控制，而无需再次为所有文档编制索引。例如，您的索引包含只有特定员工或用户才能访问的绝密公司文档。其中一位用户离开公司或转到应被禁止访问绝密文档的团队。用户仍然可以访问绝密文档，因为在您的文档之前被编入索引时，该用户拥有访问权限。您可以为具有拒绝访问权限的用户创建特定的访问控制配置。您可以稍后更新访问控制配置，以便在用户返回公司并重新加入“绝密”团队时允许访问。随着情况的变化，您可以重新配置文档的访问控制。
要将您的访问控制配置应用于某些文档，请使用 D [oc](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Document.html) ument 对象中`AccessControlConfigurationId`包含的 [BatchPutDocument](https://docs.aws.amazon.com/kendra/latest/APIReference/API_BatchPutDocument.html)API。如果您使用 S3 存储桶作为数据源，则`.metadata.json`使用更新`AccessControlConfigurationId`并同步您的数据源。 Amazon Kendra 目前仅支持对使用 `BatchPutDocument` API 编制索引的 S3 数据源和文档进行访问控制配置。
## 按用户令牌筛选
**重要**
Amazon Kendra GenAI 企业版索引不支持基于令牌的用户访问控制。
查询索引时，您可以使用用户令牌，根据用户或其所在组对文档的访问权限来筛选搜索结果。当您发出查询时， Amazon Kendra 提取并验证令牌，提取和检查用户和群组信息，然后运行查询。将返回用户有权访问的所有文档，包括公共文档。有关更多信息，请参阅[基于角色的访问控制](https://docs.aws.amazon.com/kendra/latest/dg/create-index-access-control.html)。
您在[UserContext](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UserContext.html)对象中提供用户令牌，然后在[查询](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) API 中传递该令牌。
以下命令说明如何添加用户令牌。
```
response = kendra.query(
QueryText = query,
IndexId = index,
UserToken = {
Token = "token"
})
```
您可以将用户映射到群组。使用用户上下文筛选时，无需在发出查询时包含用户所属的所有群组。使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API，您可以将用户映射到他们的群组。如果您不想使用 `PutPrincipalMapping` API，则必须在发出查询时提供用户名和该用户所属的所有群组。您还可以使用[UserGroupResolutionConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UserGroupResolutionConfiguration.html)对象获取 IAM Identity Center 身份源中群组和用户的访问级别。
## 按用户 ID 和群组筛选
查询索引时，您可以使用用户 ID 和群组，根据用户或其群组对文档的访问权限筛选搜索结果。当您发出查询时， Amazon Kendra 会检查用户和群组信息并运行查询。将返回与用户有权访问的查询相关的所有文档，包括公共文档。
您还可以按用户和群组有权访问的数据来源筛选搜索结果。如果一个组与多个数据来源相关联，但您只想让该组访问特定数据来源的文档，则指定数据来源非常有用。例如，“研究”、“工程”和“销售和营销”这三个组都与存储在数据来源Confluence和Salesforce中的公司文档相关联。但是，“销售和营销”团队只需要访问存储在Salesforce中的客户相关文档即可。因此，当销售和营销用户搜索与客户相关的文档时，他们可以在搜索结果中看到来自 Salesforce 的文档。不从事销售和市场营销工作的用户不会在搜索结果中看到 Salesforce 文档。
您在[UserContext](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UserContext.html)对象中提供用户、群组和数据源信息，然后在 [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) API 中传递这些信息。用户 ID 以及组和数据来源列表应与您在 Princip [al](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Principal.html) 对象中指定的名称相匹配，以标识用户、组和数据来源。使用该`Principal`对象，您可以将用户、组或数据来源添加到允许列表或拒绝列表中以访问文档。
您必须提供以下任一信息：
+ 用户和群组信息，以及（可选）数据来源信息。
+ 仅当您使用 [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API 将用户映射到群组和数据源时，才会显示用户信息。您还可以使用[UserGroupResolutionConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UserGroupResolutionConfiguration.html)对象获取 IAM Identity Center 身份源中群组和用户的访问级别。
如果查询中未包含此信息，则 Amazon Kendra 返回所有文档。如果您提供此信息，则仅返回具有匹配用户 IDs、组和数据源的文档。
以下内容显示了如何包括用户 ID、群组和数据来源。
```
response = kendra.query(
QueryText = query,
IndexId = index,
UserContext={'Token': 'string', 'UserId': 'string', 'Groups': [ 'string', ], 'DataSourceGroups': [ { 'GroupId': 'string', 'DataSourceId': 'string' }, ] },)
```
## 按属性筛选
查询索引时，您可以使用内置属性，`_user_id`并`_group_id`根据用户及其群组对文档的访问权限筛选搜索结果。您最多可以设置 100 个群组标识符。当您发出查询时， Amazon Kendra 会检查用户和群组信息并运行查询。将返回与用户有权访问的查询相关的所有文档，包括公共文档。
您在[AttributeFilter](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeFilter.html)对象中提供用户和群组属性，然后在[查询](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) API 中传递这些属性。
以下示例显示了一个请求，该请求根据用户 ID 以及用户所属的“HR”和“IT”组筛选查询响应。该查询将返回允许列表中包含用户或“HR”或“IT”组的所有文档。如果该用户或其中一个组在文档的拒绝列表中，则不会返回该文档。
```
response = kendra.query(
QueryText = query,
IndexId = index,
AttributeFilter = {
"OrAllFilters": [
{
"EqualsTo": {
"Key": "_user_id",
"Value": {
"StringValue": "user1"
}
}
},
{
"EqualsTo": {
"Key": "_group_ids",
"Value": {
"StringListValue": ["HR", "IT"]
}
}
}
]
}
)
```
您还可以在`Principal`对象中指定群组可以访问哪个数据来源。
**注意**
用户上下文筛选不是对内容的身份验证或授权控制。它不会对发送到 `Query` API 的用户和群组进行用户身份验证。您的应用程序有责任确保发送到 `Query` API 的用户和群组信息经过身份验证和授权。
每个数据来源都实现了用户上下文筛选。以下部分描述了每种实现。
**Topics**
+ [按用户令牌筛选](#context-filter-token)
+ [按用户 ID 和群组筛选](#context-filter-user-incl-datasources)
+ [按属性筛选](#context-filter-attribute)
+ [对直接添加到索引的文档进行用户上下文筛选](#context-filter-batch)
+ [筛选用户上下文以查找常见问题](#context-filter-faq)
+ [数据来源的用户上下文筛选](#datasource-context-filter)
## 对直接添加到索引的文档进行用户上下文筛选
使用 [BatchPutDocument](https://docs.aws.amazon.com/kendra/latest/APIReference/API_BatchPutDocument.html)API 将文档直接添加到索引时， Amazon Kendra 会从文档的`AccessControlList`字段中获取用户和群组信息。您为文档提供访问控制列表（ACL），ACL 随文档一起提取。
您可以在 `BatchPutDocument` API 中将 Princip [al](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Principal.html) 对象中的 ACL 指定为 [Doc](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Document.html) ument 对象的一部分。提供以下信息：
+ 用户或组应具有的访问权限。您可以指定为 `ALLOW` 或 `DENY`。
+ 实体的类型。您可以指定为 `USER` 或 `GROUP`。
+ 用户或组的名称。
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
## 筛选用户上下文以查找常见问题
向索引[中添加常见问题解答](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateFaq.html)时， Amazon Kendra 会从 FAQ JSON 文件中`AccessControlList` object/field 获取用户和群组信息。您也可以使用带有自定义字段或属性的常见问题 CSV 文件进行访问控制。
提供以下信息：
+ 用户或组应具有的访问权限。您可以指定为 `ALLOW` 或 `DENY`。
+ 实体的类型。您可以指定为 `USER` 或 `GROUP`。
+ 用户或组的名称。
有关更多信息，请参阅 [ 常见问题](https://docs.aws.amazon.com/kendra/latest/dg/in-creating-faq.html)。
## 数据来源的用户上下文筛选
Amazon Kendra 还会从支持的数据源连接器中搜寻用户和组访问控制列表 (ACL) 信息。这对于用户上下文筛选非常有用，在这种筛选中，搜索结果是根据用户或其所在组对文档的访问权限进行筛选的。
**重要**
Amazon Kendra GenAI 企业版索引仅支持 v2.0 Amazon Kendra 数据来源连接器。
**Topics**
+ [Adobe Experience Manager 数据来源的用户上下文筛选](#context-filter-aem)
+ [Alfresco 数据来源的用户上下文筛选](#context-filter-alfresco)
+ [针对 Aurora (MySQL) 数据源的用户上下文筛选](#context-filter-aurora-mysql)
+ [筛选 Aurora (PostgreSQL) 数据源的用户上下文](#context-filter-aurora-postgresql)
+ [Amazon FSx 数据源的用户上下文筛选](#context-filter-fsx)
+ [数据库数据来源的用户上下文筛选](#context-filter-jdbc)
+ [Amazon RDS （微软 SQL Server）数据源的用户上下文筛选](#context-filter-rds-ms-sql-server)
+ [针对 Amazon RDS (MySQL) 数据源的用户上下文筛选](#context-filter-rds-mysql)
+ [筛选 Amazon RDS (Oracle) 数据源的用户上下文](#context-filter-rds-oracle)
+ [筛选 Amazon RDS (PostgreSQL) 数据源的用户上下文](#context-filter-rds-postgresql)
+ [Amazon S3 数据源的用户上下文筛选](#context-filter-s3)
+ [Box 数据来源的用户上下文筛选](#context-filter-box)
+ [Confluence 数据来源的用户上下文筛选](#context-filter-confluence)
+ [针对 Dropbox 数据来源的用户上下文筛选](#context-filter-dropbox)
+ [Drupal 数据来源的用户上下文筛选](#context-filter-drupal)
+ [GitHub 数据源的用户上下文筛选](#context-filter-github)
+ [Gmail 数据来源的用户上下文筛选](#context-filter-gmail)
+ [筛选 Google 云端硬盘数据来源的用户上下文](#context-filter-google)
+ [筛选 IBM DB2 数据源的用户上下文](#context-filter-ibm-db2)
+ [Jira 数据来源的用户上下文筛选](#context-filter-jira)
+ [Microsoft Exchange 数据来源的用户上下文筛选](#context-filter-exchange)
+ [微软 OneDrive 数据源的用户上下文筛选](#context-filter-onedrive)
+ [微软 OneDrive v2.0 数据源的用户上下文筛选](#context-filter-onedrivev2)
+ [微软 SharePoint 数据源的用户上下文筛选](#context-filter-sharepoint-online)
+ [Microsoft SQL Server 数据来源的用户上下文筛选](#context-filter-ms-sql-server)
+ [Microsoft Teams 数据来源的用户上下文筛选](#context-filter-teams)
+ [Microsoft Yammer 数据来源的用户上下文筛选](#context-filter-yammer)
+ [针对 MySQL 数据来源的用户上下文筛选](#context-filter-mysql)
+ [筛选 Oracle 数据库数据来源的用户上下文](#context-filter-oracle-database)
+ [PostgreSQL 数据来源的用户上下文筛选](#context-filter-postgresql)
+ [Quip 数据来源的用户上下文筛选](#context-filter-quip)
+ [Salesforce 数据来源的用户上下文筛选](#context-filter-salesforce)
+ [ServiceNow 数据源的用户上下文筛选](#context-filter-servicenow)
+ [Slack 数据来源的用户上下文筛选](#context-filter-slack)
+ [Zendesk 数据来源的用户上下文筛选](#context-filter-zendesk)
### Adobe Experience Manager 数据来源的用户上下文筛选
当您使用 Adobe Experience Manager 数据源时， Amazon Kendra 会从 Adobe Experience Manager 实例获取用户和群组信息。
群组和用户映射 IDs 如下：
+ `_group_ids`—群组 IDs 存在于 Adobe Experience Manager 内容中，其中设置了访问权限。它们是从 Adobe 体验管理器中的群组名称映射出来的。
+ `_user_id`— 用户 IDs 存在于 Adobe Experience Manager 内容中，其中设置了访问权限。它们是从 Adobe 体验管理器中的用户电子邮件 IDs 中映射出来的。
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### Alfresco 数据来源的用户上下文筛选
当你使用 Alfresco 数据源时， Amazon Kendra 会从 Alfresco 实例中获取用户和群组信息。
群组和用户映射 IDs 如下：
+ `_group_ids`—在 Alfresco 中，群组 IDs 存在于设置了访问权限的文件上。它们是从 Alfresco 中组的系统名称（不是显示名称）映射出来的。
+ `_user_id`—用户 IDs 存在于 Alfresco 中已设置访问权限的文件上。它们是从用户电子邮件中映射出来的，就像 IDs 在 Alfresco 中一样。
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### 针对 Aurora (MySQL) 数据源的用户上下文筛选
使用 Aurora (MySQL) 数据源时， Amazon Kendra 会从源表中的一列中获取用户和组信息。您可以在控制台中指定此列，或者使用[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)对象作为 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API 的一部分。
Aurora (MySQL) 数据库数据源具有以下限制：
+ 您只能为数据库数据来源指定允许列表。您无法指定拒绝列表。
+ 您只能指定群组。您不能为允许列表指定单个用户。
+ 数据库列应是一个包含以分号分隔的组列表的字符串。
### 筛选 Aurora (PostgreSQL) 数据源的用户上下文
使用 Aurora (PostgreSQL) 数据源时 Amazon Kendra ，会从源表中的一列中获取用户和组信息。您可以在控制台中指定此列，或者使用[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)对象作为 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API 的一部分。
Aurora (PostgreSQL) 数据库数据源具有以下限制：
+ 您只能为数据库数据来源指定允许列表。您无法指定拒绝列表。
+ 您只能指定群组。您不能为允许列表指定单个用户。
+ 数据库列应是一个包含以分号分隔的组列表的字符串。
### Amazon FSx 数据源的用户上下文筛选
使用 Amazon FSx 数据源时， Amazon Kendra 会从 Amazon FSx 实例的目录服务中获取用户和组信息。
群 Amazon FSx 组和用户映射 IDs 如下：
+ `_group_ids`—群组 IDs 存在 Amazon FSx 于设置了访问权限的文件中。它们是从的目录服务中的系统组名称映射出来的 Amazon FSx。
+ `_user_id`—用户 IDs 存在 Amazon FSx 于设置了访问权限的文件中。它们是从的目录服务中的系统用户名映射出来的 Amazon FSx。
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### 数据库数据来源的用户上下文筛选
当您使用数据库数据源（例如）时 Amazon Aurora PostgreSQL， Amazon Kendra 会从源表的某一列中获取用户和组信息。您可以在 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API 中将此列指定为[AclConfiguration[DatabaseConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DatabaseConfiguration.html)](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AclConfiguration.html)对象的一部分。
数据库数据来源具有以下限制：
+ 您只能为数据库数据来源指定允许列表。您无法指定拒绝列表。
+ 您只能指定群组。您不能为允许列表指定单个用户。
+ 数据库列应是一个包含以分号分隔的组列表的字符串。
### Amazon RDS （微软 SQL Server）数据源的用户上下文筛选
当你使用 Amazon RDS （Microsoft SQL Server）数据源时， Amazon Kendra 会从源表中的一列中获取用户和组信息。您可以在控制台中指定此列，或者使用[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)对象作为 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API 的一部分。
Amazon RDS （微软 SQL Server）数据库数据源有以下限制：
+ 您只能为数据库数据来源指定允许列表。您无法指定拒绝列表。
+ 您只能指定群组。您不能为允许列表指定单个用户。
+ 数据库列应是一个包含以分号分隔的组列表的字符串。
### 针对 Amazon RDS (MySQL) 数据源的用户上下文筛选
使用 Amazon RDS (MySQL) 数据源时， Amazon Kendra 会从源表中的一列中获取用户和组信息。您可以在控制台中指定此列，或者使用[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)对象作为 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API 的一部分。
Amazon RDS (MySQL) 数据库数据源具有以下限制：
+ 您只能为数据库数据来源指定允许列表。您无法指定拒绝列表。
+ 您只能指定群组。您不能为允许列表指定单个用户。
+ 数据库列应是一个包含以分号分隔的组列表的字符串。
### 筛选 Amazon RDS (Oracle) 数据源的用户上下文
使用 Amazon RDS (Oracle) 数据源时， Amazon Kendra 会从源表中的一列中获取用户和组信息。您可以在控制台中指定此列，或者使用[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)对象作为 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API 的一部分。
Amazon RDS (Oracle) 数据库数据源具有以下限制：
+ 您只能为数据库数据来源指定允许列表。您无法指定拒绝列表。
+ 您只能指定群组。您不能为允许列表指定单个用户。
+ 数据库列应是一个包含以分号分隔的组列表的字符串。
### 筛选 Amazon RDS (PostgreSQL) 数据源的用户上下文
使用 Amazon RDS (PostgreSQL) 数据源时 Amazon Kendra ，会从源表中的一列中获取用户和组信息。您可以在控制台中指定此列，或者使用[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)对象作为 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API 的一部分。
Amazon RDS (PostgreSQL) 数据库数据源具有以下限制：
+ 您只能为数据库数据来源指定允许列表。您无法指定拒绝列表。
+ 您只能指定群组。您不能为允许列表指定单个用户。
+ 数据库列应是一个包含以分号分隔的组列表的字符串。
### Amazon S3 数据源的用户上下文筛选
您可以使用与文档关联的元数据文件向 Amazon S3 数据源中的文档添加用户上下文筛选。您可以将信息添加到 JSON 文档的`AccessControlList`字段中。有关向从数据来源编制索引的文档中添加元 Amazon S3 数据的更多信息，请参阅 [S3 文档元数据](https://docs.aws.amazon.com/kendra/latest/dg/s3-metadata.html)。
您提供三条信息：
+ 实体应拥有的访问权限。您可以说`ALLOW`或`DENY`。
+ 实体的类型。您可以说`USER`或`GROUP`。
+ 在 中，将实体命名为 。
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### Box 数据来源的用户上下文筛选
使用 Box 数据源时， Amazon Kendra 会从 Box 实例获取用户和群组信息。
Box 组和用户映射 IDs 如下：
+ `_group_ids`—群组 IDs 存在于 Box 中已设置访问权限的文件上。它们是从 Box 中群组的名称映射出来的。
+ `_user_id`—用户 IDs 存在于设置访问权限的文件的 Box 中。它们是从 Box 中的用户电子邮件 IDs 中映射出来的。
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### Confluence 数据来源的用户上下文筛选
当您使用 Confluence 数据源时， Amazon Kendra 会从 Confluence 实例获取用户和群组信息。
您可以使用空间权限页面配置用户和群组对空间的访问权限。对于页面和博客，您可以使用限制页面。有关空间权限的更多信息，请参阅 Confluence Support 网站上的[空间权限概述](https://confluence.atlassian.com/doc/space-permissions-overview-139521.html)。有关页面和博客限制的更多信息，请参阅 Confluence Support 网站上的[页面限制](https://confluence.atlassian.com/doc/page-restrictions-139414.html)。
Confluence 群组和用户名映射如下：
+ `_group_ids`-群组名称会出现在有限制的空间、页面和博客上。它们是根据 Confluence 中的群组名称映射出来的。群组名称始终为小写。
+ `_user_id`- 用户名出现在空间、页面或博客上有限制的地方。它们根据您使用的 Confluence 实例的类型进行映射。
**适用于 Confluence 连接程序 v1.0**
+ 服务器-`_user_id` 是用户名。用户名始终为小写。
+ 云端-`_user_id` 是用户的账户 ID。
**适用于 Confluence 连接器 v2.0**
+ 服务器 - `_user_id` 是用户名。用户名始终为小写。
+ Cloud-`_user_id` 是用户的电子邮件 ID。
**重要**
**要使用户上下文筛选功能在 Confluence 连接器上正常运行，您需要确保将获得 Confluence 页面访问权限的用户的可见性设置为“任何人”。**有关更多信息，请参阅 Atlassian 开发者文档中的[设置电子邮件可见性](https://support.atlassian.com/confluence-cloud/docs/configure-user-email-visibility/)。
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### 针对 Dropbox 数据来源的用户上下文筛选
当您使用 Dropbox 数据源时， Amazon Kendra 会从 Dropbox 实例中获取用户和群组信息。
群组和用户映射 IDs 如下：
+ `_group_ids`—群组 IDs 存在于 Dropbox 中已设置访问权限的文件上。它们是从 Dropbox 中群组的名称映射出来的。
+ `_user_id`—用户 IDs 存在于 Dropbox 中已设置访问权限的文件中。它们是从 Dropbox 中的用户电子邮件 IDs 中映射出来的。
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### Drupal 数据来源的用户上下文筛选
当你使用 Drupal 数据源时， Amazon Kendra 会从 DrupalInstance 中获取用户和群组信息。
群组和用户映射 IDs 如下：
+ `_group_ids`— 在 Drupal 中，在设置了访问权限的文件上存在群 IDs 组。它们是根据Drupal中群组的名称映射出来的。
+ `_user_id`— 在 Drupal 中，用户 IDs 存在于设置了访问权限的文件上。它们是从用户电子邮件中映射出来的，就像 IDs 在Drupal中一样。
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### GitHub 数据源的用户上下文筛选
当您使用 GitHub 数据源时， Amazon Kendra 会从该 GitHub 实例获取用户信息。
GitHub 用户映射 IDs 如下：
+ `_user_id`—用户 IDs 存在 GitHub 于设置了访问权限的文件中。它们是从用户电子邮件中映射出来 IDs 的 GitHub。
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### Gmail 数据来源的用户上下文筛选
当你使用 Gmail 数据源时， Amazon Kendra 会从 Gmail 实例中获取用户信息。
用户映射 IDs 如下：
+ `_user_id`— 用户 IDs 存在于 Gmail 中已设置访问权限的文件上。它们是从用户电子邮件中映射出来的，就像在 Gmail IDs 中一样。
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### 筛选 Google 云端硬盘数据来源的用户上下文
Google Workspace 云端硬盘数据来源会返回谷歌云端硬盘用户和群组的用户和群组信息。组和域成员资格映射到`_group_ids`索引字段。Google 云端硬盘用户名将映射到该`_user_id`字段。
当您在 `Query` API 中提供一个或多个用户电子邮件地址时，仅返回与这些电子邮件地址共享的文档。以下`AttributeFilter`参数仅返回与“martha@example.com”共享的文档。
```
"AttributeFilter": {
"EqualsTo":{
"Key": "_user_id",
"Value": {
"StringValue": "martha@example.com"
}
}
}
```
如果您在查询中提供一个或多个群组电子邮件地址，则仅返回与群组共享的文档。以下`AttributeFilter`参数仅返回与“hr@example.com”群组共享的文档。
```
"AttributeFilter": {
"EqualsTo":{
"Key": "_group_ids",
"Value": {
"StringListValue": ["hr@example.com"]
}
}
}
```
如果您在查询中提供了域，则会返回与该域共享的所有文档。以下`AttributeFilter`参数返回与“example.com”域共享的文档。
```
"AttributeFilter": {
"EqualsTo":{
"Key": "_group_ids",
"Value": {
"StringListValue": ["example.com"]
}
}
}
```
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### 筛选 IBM DB2 数据源的用户上下文
使用 IBM DB2 数据源时， Amazon Kendra 会从源表中的一列中获取用户和组信息。您可以在控制台中指定此列，或者使用[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)对象作为 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API 的一部分。
IBM DB2 数据库数据源有以下限制：
+ 您只能为数据库数据来源指定允许列表。您无法指定拒绝列表。
+ 您只能指定群组。您不能为允许列表指定单个用户。
+ 数据库列应是一个包含以分号分隔的组列表的字符串。
### Jira 数据来源的用户上下文筛选
使用 Jira 数据源时， Amazon Kendra 会从 Jira 实例获取用户和群组信息。
Jira 用户的映射 IDs 如下所示：
+ `_user_id`—用户 IDs 存在于 Jira 中已设置访问权限的文件上。它们是从用户电子邮件中映射为 Jira IDs 中的用户。
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### Microsoft Exchange 数据来源的用户上下文筛选
当你使用微软 Exchange 数据源时， Amazon Kendra 会从微软 Exchange 实例获取用户信息。
微软 Exchange 用户映射 IDs 如下：
+ `_user_id`— 用户在 Microsoft Exchange 中 IDs 存在访问某些内容的权限。它们是从微软 Exchange IDs 中的用户名映射出来的。
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### 微软 OneDrive 数据源的用户上下文筛选
Amazon Kendra 在 Microsoft 为站点上的文档编制索引 OneDrive 时，会从 Microsoft 检索用户和群组信息。用户和群组信息取自托管的底层 Microsoft SharePoint 站点 OneDrive。
使用 OneDrive 用户或群组筛选搜索结果时，按如下方式计算 ID：
1. 获取网站名称。例如，`https://host.onmicrosoft.com/sites/siteName.`
1. 以网站名称的 MD5 哈希值为例。例如 `430a6b90503eef95c89295c8999c7981`。
1. 通过将 MD5 哈希值与竖线 (\$1) 和 ID 连接起来，创建用户电子邮件或群组 ID。例如，如果群组名称是 localGroupName “”，则群组 ID 将是：
`"430a6b90503eef95c89295c8999c7981 | localGroupName"`
**注意**
竖线前后各留一个空格。竖条用于用其 MD5哈希值`localGroupName`进行标识。
对于用户名“someone@host.onmicrosoft.com”，用户 ID 将如下所示：
`"430a6b90503eef95c89295c8999c7981 | someone@host.onmicrosoft.com"`
调用[查询](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) API 时，将用户`_user_id`或群组 ID Amazon Kendra 作为或`_group_id`属性发送到。例如，使用群组筛选搜索结果的 AWS CLI 命令如下所示：
```
aws kendra query \
--index-id index ID
--query-text "query text"
--attribute-filter '{
"EqualsTo":{
"Key": "_group_id",
"Value": {"StringValue": "430a6b90503eef95c89295c8999c7981 | localGroupName"}
}}'
```
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### 微软 OneDrive v2.0 数据源的用户上下文筛选
Microsoft OneDrive v2.0 数据源返回来自 OneDrive 访问控制列表 (ACL) 实体的分区和页面信息。 Amazon Kendra 使用 OneDrive 租户域连接到 OneDrive 实例，然后可以根据用户或群组对分区和文件名的访问权限筛选搜索结果。
对于标准对象，`_user_id` 和 `_group_id` 的使用方式如下：
+ `_user_id`— 你的 Microsoft OneDrive 用户电子邮件 ID 已映射到该`_user_id`字段。
+ `_group_id`— 你的 Microsoft OneDrive 群组电子邮件已映射到该`_group_id`字段。
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### 微软 SharePoint 数据源的用户上下文筛选
Amazon Kendra 在 Microsoft 为站点文档编制索引 SharePoint 时，会从 Microsoft 检索用户和群组信息。要根据用户或组访问权限筛选搜索结果，请在调用 `Query` API 时提供用户和组信息。
要使用用户名进行筛选，请使用该用户的电子邮件地址。例如，johnstiles@example.com。
使用 SharePoint 群组筛选搜索结果时，按如下方式计算群组 ID：
**对于本地组**
1. 获取网站名称。例如，`https://host.onmicrosoft.com/sites/siteName.`
1. 以网站名称的 SHA256 哈希值为例。例如 `430a6b90503eef95c89295c8999c7981`。
1. 通过将 SHA256 哈希值与竖线 (\$1) 和群组名称连接起来来创建群组 ID。例如，如果群组名称是 localGroupName “”，则群组 ID 将是：
`"430a6b90503eef95c89295c8999c7981 | localGroupName"`
**注意**
竖线前后各留一个空格。竖条用于用其 SHA256哈希值`localGroupName`进行标识。
调用[查询 API](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) 时，将群组 ID Amazon Kendra 作为`_group_id`属性发送到。例如，该 AWS CLI 命令如下所示：
```
aws kendra query \
--index-id index ID
--query-text "query text"
--attribute-filter '{
"EqualsTo":{
"Key": "_group_id",
"Value": {"StringValue": "430a6b90503eef95c89295c8999c7981 | localGroupName"}
}}'
```
**对于 AD 组**
1. 使用 AD 组 ID 配置搜索结果的筛选条件。
调用[查询](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) API 时，将群组 ID Amazon Kendra 作为`_group_id`属性发送到。例如，该 AWS CLI 命令如下所示：
```
aws kendra query \
--index-id index ID
--query-text "query text"
--attribute-filter '{
"EqualsTo":{
"Key": "_group_id",
"Value": {"StringValue": "AD group"}
}}'
```
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### Microsoft SQL Server 数据来源的用户上下文筛选
当你使用 Microsoft SQL Server 数据源时， Amazon Kendra 会从源表中的一列中获取用户和组信息。您可以在控制台中指定此列，或者使用[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)对象作为 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API 的一部分。
Microsoft SQL Server 数据库数据来源有以下限制：
+ 您只能为数据库数据来源指定允许列表。您无法指定拒绝列表。
+ 您只能指定群组。您不能为允许列表指定单个用户。
+ 数据库列应是一个包含以分号分隔的组列表的字符串。
### Microsoft Teams 数据来源的用户上下文筛选
Amazon Kendra 在为文档编制索引时，会从 Microsoft Teams 中检索用户信息。用户信息取自底层的 Microsoft Teams 实例。
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### Microsoft Yammer 数据来源的用户上下文筛选
Amazon Kendra 在为文档编制索引时，会从 Microsoft Yammer 中检索用户信息。用户和组信息取自底层的 Microsoft Yammer 实例。
微软 Yammer 用户映射 IDs 如下：
+ `_email_id`：映射到 `_user_id` 字段的 Microsoft 电子邮件地址 ID。
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### 针对 MySQL 数据来源的用户上下文筛选
使用 MySQL 数据源时， Amazon Kendra 会从源表中的一列中获取用户和组信息。您可以在控制台中指定此列，或者使用[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)对象作为 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API 的一部分。
MySQL 数据库数据来源具有以下限制：
+ 您只能为数据库数据来源指定允许列表。您无法指定拒绝列表。
+ 您只能指定群组。您不能为允许列表指定单个用户。
+ 数据库列应是一个包含以分号分隔的组列表的字符串。
### 筛选 Oracle 数据库数据来源的用户上下文
使用 Oracle 数据库数据源时， Amazon Kendra 会从源表中的一列中获取用户和组信息。您可以在控制台中指定此列，或者使用[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)对象作为 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API 的一部分。
Oracle 数据库数据来源具有以下限制：
+ 您只能为数据库数据来源指定允许列表。您无法指定拒绝列表。
+ 您只能指定群组。您不能为允许列表指定单个用户。
+ 数据库列应是一个包含以分号分隔的组列表的字符串。
### PostgreSQL 数据来源的用户上下文筛选
使用 PostgreSQL 数据源时 Amazon Kendra ，会从源表中的一列中获取用户和组信息。您可以在控制台中指定此列，或者使用[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)对象作为 [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API 的一部分。
PostgreSQL 数据库数据来源具有以下限制：
+ 您只能为数据库数据来源指定允许列表。您无法指定拒绝列表。
+ 您只能指定群组。您不能为允许列表指定单个用户。
+ 数据库列应是一个包含以分号分隔的组列表的字符串。
### Quip 数据来源的用户上下文筛选
当您使用 Quip 数据源时， Amazon Kendra 会从 Quip 实例获取用户信息。
Quip 用户的映射 IDs 如下所示：
+ `_user_id`—用户 IDs 存在于 Quip 中已设置访问权限的文件上。它们是从 Quip 中的用户电子邮件 IDs 中映射出来的。
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### Salesforce 数据来源的用户上下文筛选
Salesforce 数据来源返回来自 Salesforce 访问控制列表（ACL）实体的用户和群组信息。您可以将用户上下文筛选应用于 Salesforce 标准对象和聊天提要。用户上下文筛选不适用于 Salesforce 知识文章。
如果您将任意 Salesforce 字段映射到 Amazon Kendra 的文档标题和正文字段，Amazon Kendra 将在搜索结果中使用来自这些标题和正文字段的数据。
对于标准对象，`_user_id` 和 `_group_ids` 的使用方式如下：
+ `_user_id` - Salesforce 用户的用户名。
+ `_group_ids`—
+ Salesforce 的名字 `Profile`
+ Salesforce `Group` 的名字
+ Salesforce `UserRole` 的名字
+ Salesforce 的名字 `PermissionSet`
对于 chatter Feed，`_user_id`和`_group_ids`的使用方式如下：
+ `_user_id`- Salesforce 用户的用户名。仅当该项目发布在用户的 Feed 中时才可用。
+ `_group_ids`—群组 IDs 的使用方式如下。仅当 Feed 项目在聊天或协作群组中发布时才可用。
+ 聊天群组或协作群组的名称。
+ 如果该群组是公开的，`PUBLIC:ALL`.
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### ServiceNow 数据源的用户上下文筛选
只有 TemplateConfiguration API 和 ServiceNow 连接器 v2.0 支持用户上下文筛选。 ServiceNow ServiceNowConfigurationAPI 和 ServiceNow 连接器 v1.0。不支持用户上下文筛选。
当您使用 ServiceNow 数据源时， Amazon Kendra 会从该 ServiceNow 实例获取用户和群组信息。
群组和用户映射 IDs 如下：
+ `_group_ids`—群组 IDs 存在 ServiceNow 于设置了访问权限的文件中。它们是根据中的角色名称映射而来`sys_ids`的 ServiceNow。
+ `_user_id`—用户 IDs 存在 ServiceNow 于设置了访问权限的文件中。它们是从用户电子邮件中映射出来 IDs 的 ServiceNow。
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### Slack 数据来源的用户上下文筛选
当你使用 Slack 数据源时， Amazon Kendra 会从 Slack 实例中获取用户信息。
Slack 用户的映射 IDs 如下所示：
+ `_user_id`—用户 IDs 存在于 Slack 中设置访问权限的消息和频道上。它们是从用户电子邮件中映射出来的，就像在 Slack IDs 中一样。
您最多可以在 `AccessControlList` 字段中添加 200 个条目。
### Zendesk 数据来源的用户上下文筛选
当你使用 Zendesk 数据源时， Amazon Kendra 会从 Zendesk 实例中获取用户和群组信息。
群组和用户映射 IDs 如下：
+ `_group_ids`—群组 IDs 存在于设置访问权限的 Zendesk 工单和文章中。它们是从 Zendesk 中的群组名称映射出来的。
+ `_user_id`—群组 IDs 存在于设置访问权限的 Zendesk 工单和文章中。它们是从用户电子邮件中映射出来的，就像 IDs 在 Zendesk 中一样。
您最多可以在`AccessControlList`字段中添加 200 个条目。
# 查询响应和响应类型
**注意**
功能支持因所用索引类型和搜索 API 而异。要查看您使用的索引类型和搜索 API 是否支持此功能，请参阅[索引类型](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html)。
Amazon Kendra 支持不同的查询响应和响应类型。
## 查询响应
调用 [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) API 会返回有关搜索结果的信息。结果以[QueryResultItem](https://docs.aws.amazon.com/kendra/latest/APIReference/API_QueryResultItem.html)对象数组 (`ResultItems`) 的形式出现。每`QueryResultItem`份都包含结果摘要。包括与查询结果关联的文档属性。
**摘要信息**
摘要信息因结果类型而异。在每种情况下，它都包含与搜索词匹配的文档文本。它还包括突出显示信息，可用于突出显示应用程序输出中的搜索文本。例如，如果搜索词是*太空针塔的高度是多少？* ，摘要信息包括*高度和*太空针塔*这两个*词的文本位置。有关响应卡的信息，请参阅 [查询响应和响应类型](#query-responses-types)。
**文档属性**
每个结果都包含与查询相匹配的文档的文档属性。有些属性是预定义的，例如`DocumentId``DocumentTitle`、和`DocumentUri`。其他属性是您定义的自定义属性。您可以使用文档属性来筛选来自 `Query` API 的响应。例如，您可能只需要由特定作者撰写的文档或文档的特定版本。有关更多信息，请参阅[筛选和分面搜索](filtering.md)。在向索引中添加文档时，可以指定文档属性。有关更多信息，请参阅[自定义字段和属性](https://docs.aws.amazon.com/kendra/latest/dg/custom-attributes.html)。
以下是查询结果的 JSON 代码示例。请注意`DocumentAttributes`和中的文档属性`AdditionalAttributes`。
```
{
"QueryId": "query-id",
"ResultItems": [
{
"Id": "result-id",
"Type": "ANSWER",
"AdditionalAttributes": [
{
"Key": "AnswerText",
"ValueType": "TEXT_WITH_HIGHLIGHTS_VALUE",
"Value": {
"TextWithHighlightsValue": {
"Text": "text",
"Highlights": [
{
"BeginOffset": 55,
"EndOffset": 90,
"TopAnswer": false
}
]
}
}
}
],
"DocumentId": "document-id",
"DocumentTitle": {
"Text": "title"
},
"DocumentExcerpt": {
"Text": "text",
"Highlights": [
{
"BeginOffset": 0,
"EndOffset": 300,
"TopAnswer": false
}
]
},
"DocumentURI": "uri",
"DocumentAttributes": [],
"ScoreAttributes": "score",
"FeedbackToken": "token"
},
{
"Id": "result-id",
"Type": "ANSWER",
"Format": "TABLE",
"DocumentId": "document-id",
"DocumentTitle": {
"Text": "title"
},
"TableExcerpt": {
"Rows": [{
"Cells": [{
"Header": true,
"Highlighted": false,
"TopAnswer": false,
"Value": "value"
}, {
"Header": true,
"Highlighted": false,
"TopAnswer": false,
"Value": "value"
}, {
"Header": true,
"Highlighted": false,
"TopAnswer": false,
"Value": "value"
}, {
"Header": true,
"Highlighted": false,
"TopAnswer": false,
"Value": "value"
}]
}, {
"Cells": [{
"Header": false,
"Highlighted": false,
"TopAnswer": false,
"Value": "value"
}, {
"Header": false,
"Highlighted": false,
"TopAnswer": false,
"Value": "value"
}, {
"Header": false,
"Highlighted": true,
"TopAnswer": true,
"Value": "value"
}, {
"Header": false,
"Highlighted": false,
"TopAnswer": false,
"Value": "value"
]}
}],
"TotalNumberofRows": number
},
"DocumentURI": "uri",
"ScoreAttributes": "score",
"FeedbackToken": "token"
},
{
"Id": "result-id",
"Type": "DOCUMENT",
"AdditionalAttributes": [],
"DocumentId": "document-id",
"DocumentTitle": {
"Text": "title",
"Highlights": []
},
"DocumentExcerpt": {
"Text": "text",
"Highlights": [
{
"BeginOffset": 74,
"EndOffset": 77,
"TopAnswer": false
}
]
},
"DocumentURI": "uri",
"DocumentAttributes": [
{
"Key": "_source_uri",
"Value": {
"StringValue": "uri"
}
}
],
"ScoreAttributes": "score",
"FeedbackToken": "token",
}
],
"FacetResults": [],
"TotalNumberOfResults": number
}
```
## 响应时间
Amazon Kendra 返回三种类型的查询响应。
+ 答案（包括表格答案）
+ 文档
+ 问答
响应的类型将在[QueryResultItem](https://docs.aws.amazon.com/kendra/latest/APIReference/API_QueryResultItem.html)对象的`Type`响应字段中返回。
### 回答
Amazon Kendra 在答案中检测到一个或多个问题答案。事实是对谁、什么、何时或何地问题的回应，例如*离我最近的服务中心在哪里*？ Amazon Kendra 返回索引中与查询最匹配的文本。文本位于`AnswerText`字段中，并在响应文本中包含搜索词的突出显示信息。 `AnswerText`包括带有突出显示文本的完整文档摘录，同时`DocumentExcerpt`包括带有突出显示文本的截断（290 个字符）文档摘录。
Amazon Kendra 每个文档只返回一个答案，这是可信度最高的答案。要从一个文档返回多个答案，必须将该文档拆分为多个文档。
```
{
'AnswerText': {
'TextWithHighlights': [
{
'BeginOffset': 271,
'EndOffset': 279,
'TopAnswer': False
},
{
'BeginOffset': 481,
'EndOffset': 489,
'TopAnswer': False
},
{
'BeginOffset': 547,
'EndOffset': 555,
'TopAnswer': False
},
{
'BeginOffset': 764,
'EndOffset': 772,
'TopAnswer': False
}
],
'Text': 'Asynchronousoperationscan\n''alsoprocess\n''documentsthatareinPDF''format.UsingPDFformatfilesallowsyoutoprocess''multi-page\n''documents.\n''Forinformationabouthow''AmazonTextractrepresents\n''documentsasBlockobjects,
''seeDocumentsandBlockObjects.\n''\n''\n''\n''Forinformationaboutdocument''limits,
seeLimitsinAmazonTextract.\n''\n''\n''\n''TheAmazonTextractsynchronous''operationscanprocessdocumentsstoredinanAmazon\n''S3Bucketoryoucanpass''base64encodedimagebytes.\n''Formoreinformation,
see''CallingAmazonTextractSynchronousOperations.''Asynchronousoperationsrequireinputdocuments\n''tobesuppliedinanAmazon''S3Bucket.'
},
'DocumentExcerpt': {
'Highlights': [
{
'BeginOffset': 0,
'EndOffset': 300,
'TopAnswer': False
}
],
'Text': 'Asynchronousoperationscan\n''alsoprocess\n''documentsthatareinPDF''format.UsingPDFformatfilesallowsyoutoprocess''multi-page\n''documents.\n''ForinformationabouthowAmazon''Textractrepresents\n'''
},
'Type': 'ANSWER'
}
```
### 文档
Amazon Kendra 返回与搜索词匹配的文档的排名文档。排名基于对搜索结果准确性的 Amazon Kendra 置信度。有关匹配文档的信息将在中返回[QueryResultItem](https://docs.aws.amazon.com/kendra/latest/APIReference/API_QueryResultItem.html)。它包括文档标题。摘录包括搜索文本的突出显示信息以及文档中匹配文本的部分。匹配文档的 URI 位于`SourceURI`文档属性中。以下示例 JSON 显示了匹配文档的文档摘要。
```
{
'DocumentTitle': {
'Highlights': [
{
'BeginOffset': 7,
'EndOffset': 15,
'TopAnswer': False
},
{
'BeginOffset': 97,
'EndOffset': 105,
'TopAnswer': False
}
],
'Text': 'AmazonTextractAPIPermissions: Actions,
\n''Permissions,
andResourcesReference-''AmazonTextract'
},
'DocumentExcerpt': {
'Highlights': [
{
'BeginOffset': 68,
'EndOffset': 76,
'TopAnswer': False
},
{
'BeginOffset': 121,
'EndOffset': 129,
'TopAnswer': False
}
],
'Text': '...LoggingandMonitoring\tMonitoring\n''\tCloudWatchMetricsforAmazonTextract\n''\tLoggingAmazonTextractAPICallswithAWSCloudTrail\n''\tAPIReference\tActions\tAnalyzeDocument\n''\tDetectDocumentText\n''\tGetDocumentAnalysis...'
},
'Type': 'DOCUMENT'
}
```
### 问答
当一个问题与索引中的一个常见问题 Amazon Kendra 匹配时，将返回问答响应。答案包括[QueryResultItem](https://docs.aws.amazon.com/kendra/latest/APIReference/API_QueryResultItem.html)字段中匹配的问题和答案。它还包括查询字符串中检测到的查询词的突出显示信息。以下 JSON 显示了问题和答案的回答。请注意，答案中包含问题文本。
```
{
'AnswerText': {
'TextWithHighlights': [
],
'Text': '605feet'
},
'DocumentExcerpt': {
'Highlights': [
{
'BeginOffset': 0,
'EndOffset': 8,
'TopAnswer': False
}
],
'Text': '605feet'
},
'Type': 'QUESTION_ANSWER',
'QuestionText': {
'Highlights': [
{
'BeginOffset': 12,
'EndOffset': 18,
'TopAnswer': False
},
{
'BeginOffset': 26,
'EndOffset': 31,
'TopAnswer': False
},
{
'BeginOffset': 32,
'EndOffset': 38,
'TopAnswer': False
}
],
'Text': 'whatistheheightoftheSpaceNeedle?'
}
}
```
有关向索引添加问题和答案文本的信息，请参阅[创建常见问题解答](https://docs.aws.amazon.com/kendra/latest/dg/in-creating-faq.html)。
# 调整和排序响应
**注意**
功能支持因所用索引类型和搜索 API 而异。要查看您使用的索引类型和搜索 API 是否支持此功能，请参阅[索引类型](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html)。
您可以通过相关性调整来修改字段或属性对搜索相关性的影响。您也可以按特定属性或字段对搜索结果进行排序。
**Topics**
+ [优化响应](#tuning-responses)
+ [对响应进行排序](#sorting-responses)
## 优化响应
您可以通过相关性调整来修改字段或属性对搜索相关性的影响。要快速测试相关性调整，请使用[查询](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) API 在查询中传递调整配置。然后，您可以看到从不同配置中获得的不同搜索结果。控制台不支持在查询级别进行相关性调整。您也可以仅`StringList`在索引级别调整该类型的字段或属性。有关更多信息，请参阅[调整搜索相关性](https://docs.aws.amazon.com/kendra/latest/dg/tuning.html)。
默认情况下，查询响应按响应中每个结果的 Amazon Kendra 相关性分数排序。
您可以调整以下任何内置类型或自定义 attribute/field 类型的结果：
+ 日期值
+ 长型值。
+ 字符串值
您无法对以下类型的属性进行排序：
+ 字符串列表值
**对文档结果进行排名和调整 (AWS SDK)**
将`Searchable`参数设置为 true 以增强文档元数据配置。
要调整查询中的属性，请设置 `Query` API 的`DocumentRelevanceOverrideConfigurations`参数并指定要调整的属性的名称。
以下 JSON 示例显示了一个`DocumentRelevanceOverrideConfigurations`对象，该对象会覆盖对索引中名为“部门”的属性的调整。
```
"DocumentRelevanceOverrideConfigurations" : [
"Name": "department",
"Relevance": {
"Importance": 1,
"ValueImportanceMap": {
"IT": 3,
"HR": 7
}
}
]
```
## 对响应进行排序
Amazon Kendra 使用排序属性或字段作为查询返回的文档的标准的一部分。例如，按“\$1created\$1at”排序的查询返回的结果可能与按“\$1version”排序的查询所包含的结果不一样。
默认情况下，查询响应按响应中每个结果的 Amazon Kendra 相关性分数排序。要更改排序顺序，请将文档属性设置为可排序，然后配置 Amazon Kendra 为使用该属性对响应进行排序。
您可以按以下任意内置类型或自定义类型 attribute/field 对结果进行排序：
+ 日期值
+ 长型值。
+ 字符串值
您无法对以下类型的属性进行排序：
+ 字符串列表值
您可以在每个查询中根据一个或多个文档属性进行排序。查询返回 100 个结果。如果设置了排序属性的文档少于 100 个，则在结果末尾返回没有排序属性值的文档，按与查询的相关性进行排序。
**对文档结果进行排序 (AWS SDK)**
1. 要使用 [UpdateIndex](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateIndex.html)API 使属性可排序，请将`Sortable`参数设置为。`true`以下 JSON 示例用于`DocumentMetadataConfigurationUpdates`向索引添加名为“部门”的属性并使其可排序。
```
"DocumentMetadataConfigurationUpdates": [
{
"Name": "Department",
"Type": "STRING_VALUE",
"Search": {
"Sortable": "true"
}
}
]
```
1. 要在查询中使用一个可排序的属性，请设置[查询](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) API 的`SortingConfiguration`参数。指定要排序的属性的名称以及是按升序还是降序对响应进行排序。
以下 JSON 示例显示了您用来按“部门”属性按升序对查询结果进行排序的`SortingConfiguration`参数。
```
"SortingConfiguration": {
"DocumentAttributeKey": "Department",
"SortOrder": "ASC"
}
```
1. 要在查询中使用多个可排序属性，请设置[查询](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) API 的`SortingConfigurations`参数。您最多可以设置 3 个对结果 Amazon Kendra 进行排序的字段。您还可以指定结果是按升序还是降序排序。排序字段配额可以增加。
如果您不提供排序配置，则按 Amazon Kendra 决定结果的相关性对结果进行排序。如果结果排序有平局，则按相关性对结果进行排序。
以下 JSON 示例显示了您用来按属性“名称”和“价格”升序对查询结果进行排序的`SortingConfigurations`参数。
```
"CollapseConfiguration" : {
"DocumentAttributeKey": "Name",
"SortingConfigurations": [
{
"DocumentAttributeKey": "Price",
"SortOrder": "ASC"
}
],
"MissingAttributeKeyStrategy": "IGNORE"
}
```
**对文档结果排序（控制台）**
**注意**
目前不支持多属性排序。 AWS 管理控制台
1. 要使属性可在控制台中排序，请在属性定义中选择“**可排序**”。可以在创建属性时对属性进行排序，也可以稍后对其进行修改。
1. 要在控制台中对查询响应进行排序，请从“排序”菜单中选择要对响应**进行排序**的属性。只有在数据来源配置期间标记为可排序的属性才会出现在列表中。
# 折叠/展开查询结果
**注意**
功能支持因所用索引类型和搜索 API 而异。要查看您使用的索引类型和搜索 API 是否支持此功能，请参阅[索引类型](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html)。
当您 Amazon Kendra 连接到数据时，它会抓取[文档元数据属性](https://docs.aws.amazon.com/kendra/latest/dg/hiw-document-attributes.html)（例如`_document_title``_created_at`、和`_document_id`），并在查询期间使用这些属性或字段提供高级搜索功能。
Amazon Kendra的“折叠和展开查询结果”功能允许您使用常用文档属性对搜索结果进行分组，并在指定的主文档下显示搜索结果（折叠或部分展开）。
**注意**
折叠和展开查询结果功能目前只能通过 [Amazon Kendra API](https://docs.aws.amazon.com/kendra/latest/APIReference/welcome.html) 使用。
这在以下几种搜索情况下很有用：
+ 索引中的文档中存在多个版本的内容。当您的最终用户查询索引时，您希望他们看到包含重复项hidden/collapsed. For example, if your index contains multiple versions of a document named "NYC leave policy" you can choose to collapse the documents for the specific groups "HR" and "Legal" using the "Type" attribute/field的最相关的文档版本。
![\[示例 1\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/images/expand-collapse-1.png)
+ 您的索引包含多个文档，其中包含有关一种商品或对象（例如产品库存）的唯一信息。为了方便地捕获项目信息以及对其排序，您希望最终用户能够将项目或对象链接的所有文档作为一个搜索结果进行访问。在以下示例中，客户搜索“animal print shirts”会返回按名称分组并按价格升序排序的结果。
![\[示例 2\]](http://docs.aws.amazon.com/zh_cn/kendra/latest/dg/images/expand-collapse-2.png)
## 折叠结果
要将相似或相关的文档组合在一起，必须指定要折叠的属性（例如，您可以按其折叠 collapse/group 文档`_category`）。为此，请调用 [Query API](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) 并使用[CollapseConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CollapseConfiguration.html)对象指定`DocumentAttributeKey`要折叠的。`DocumentAttributeKey`控制哪些字段的搜索结果将处于折叠状态。支持的属性键字段包括`String`和`Number`。 `String list`不支持和`Date`类型。
## 使用排序顺序选择主文档
要将主文档配置为在折叠的组中显示，请使用下面的`SortingConfigurations`参数[CollapseConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CollapseConfiguration.html)。例如，要获取文档的最新版本，可以按 `_version` 对每个折叠的组进行排序。您最多可以指定 3 attributes/fields 个作为排序依据，并 attribute/field 使用指定每个排序顺序`SortingConfigurations`。您可以请求增加排序属性的数量的限额。
默认情况下， Amazon Kendra 按其为响应中的每个结果确定的相关性分数对查询响应进行排序。要更改默认排序顺序，请将文档属性设置为可排序，然后配置 Amazon Kendra 为使用这些属性对响应进行排序。有关更多信息，请参阅 [ 响应](https://docs.aws.amazon.com/kendra/latest/dg/tuning-sorting-responses.html#sorting-responses)。
## 缺少文档密钥策略
如果您的文档没有折叠属性值，则会 Amazon Kendra 提供三个自定义选项：
+ 选择一个组中包含空值或缺失值`COLLAPSE`的所有文档。这是默认配置。
+ 选择值为空或缺失值的`IGNORE`文档。被忽略的文档不会出现在查询结果中。
+ 将`EXPAND`每个具有空值或缺失值的文档选择为一组。
## 扩大结果
您可以使用[CollapseConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CollapseConfiguration.html)对象中的`Expand`参数选择是否展开折叠的搜索结果组。展开的结果与为该组选择主文档时使用的排序顺序相同。
要配置要展开的折叠搜索结果组的数量，请使用[ExpandConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_ExpandConfiguration.html)对象中的`MaxResultItemstoExpand`参数。例如，如果将此值设置为 10，则只有 100 个结果组中的前 10 个具有扩展功能。
要配置每个折叠的主文档显示的展开结果数，请使用`MaxExpandResultsPerItem`参数。例如，如果您将此值设置为 3，则每个折叠的组最多会显示 3 个结果。
## 与其他 Amazon Kendra 功能的互动
+ 折叠和展开结果不会改变分面的数量，也不会影响显示的结果总数。
+ 即使Amazon Kendra [精选搜索结果](https://docs.aws.amazon.com/kendra/latest/dg/featured-results.html)的字段值与您配置的折叠字段相同，也不会折叠。
+ 折叠和展开结果仅适用于 `DOCUMENT` 类型的结果。