Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Recherche dans un index
**Note**
La prise en charge des fonctionnalités varie en fonction du type d'index et de l'API de recherche utilisés. Pour savoir si cette fonctionnalité est prise en charge pour le type d'index et l'API de recherche que vous utilisez, consultez la section [Types d'index](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Pour effectuer une recherche dans un Amazon Kendra index, vous utilisez l'API [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html). L'`Query`API renvoie des informations sur les documents indexés que vous utilisez dans votre application. Cette section explique comment effectuer une requête, exécuter des filtres et interpréter la réponse que vous obtenez de l'`Query`API.
Pour rechercher des documents que vous avez indexés avec Amazon Kendra for Amazon Lex, utilisez [AMAZON. KendraSearchIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_KendraConfiguration.html). Pour un exemple de configuration Amazon Kendra avec Amazon Lex, voir [Création d'un bot FAQ pour un Amazon Kendra index](https://docs.aws.amazon.com/lexv2/latest/dg/faq-bot-kendra-search.html).
**Topics**
+ [Interrogation d’un index](searching-example.md)
+ [Récupération de passages](searching-retrieve.md)
+ [Parcourir un index](browsing.md)
+ [Avec les résultats de recherche](featured-results.md)
+ [Recherche tabulaire pour le HTML](searching-tables.md)
+ [suggestions de requêtes](query-suggestions.md)
+ [Correcteur orthographique des requêtes](query-spell-check.md)
+ [Filtrage et recherche par facettes](filtering.md)
+ [Filtrage sur le contexte utilisateur](user-context-filter.md)
+ [Réponses aux requêtes et types de réponses](query-responses-types.md)
+ [Réglage et tri des réponses](tuning-sorting-responses.md)
+ [Réduction/extension des résultats de requête](expand-collapse-query-results.md)
# Interrogation d’un index
**Note**
La prise en charge des fonctionnalités varie en fonction du type d'index et de l'API de recherche utilisés. Pour savoir si cette fonctionnalité est prise en charge pour le type d'index et l'API de recherche que vous utilisez, consultez la section [Types d'index](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Lorsque vous effectuez une recherche dans votre index, il Amazon Kendra utilise toutes les informations que vous avez fournies sur vos documents pour déterminer les documents les plus pertinents par rapport aux termes de recherche saisis. Certains des éléments pris en Amazon Kendra compte sont les suivants :
+ Le texte ou le corps du document.
+ Titre du document.
+ Champs de texte personnalisés que vous avez marqués comme consultables.
+ Le champ de date que vous avez indiqué doit être utilisé pour déterminer la « fraîcheur » d'un document.
+ Tout autre champ susceptible de fournir des informations pertinentes.
Amazon Kendra peut également filtrer la réponse en fonction des field/attribute filtres que vous avez éventuellement définis pour la recherche. Par exemple, si vous avez un champ personnalisé appelé « département », vous pouvez filtrer la réponse pour ne renvoyer que les documents provenant d'un département appelé « juridique ». Pour plus d'informations, consultez la section [Champs ou attributs personnalisés](https://docs.aws.amazon.com/kendra/latest/dg/custom-attributes.html).
Les résultats de recherche renvoyés sont triés en fonction de la pertinence qui Amazon Kendra détermine chaque document. Les résultats sont paginés afin que vous puissiez montrer une page à la fois à votre utilisateur.
Pour rechercher des documents que vous avez indexés avec Amazon Kendra for Amazon Lex, utilisez [AMAZON. KendraSearchIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_KendraConfiguration.html). Pour un exemple de configuration Amazon Kendra avec Amazon Lex, voir [Création d'un bot FAQ pour un Amazon Kendra index](https://docs.aws.amazon.com/lexv2/latest/dg/faq-bot-kendra-search.html).
L'exemple suivant montre comment effectuer une recherche dans un index. Amazon Kendra détermine le type de résultat de recherche (réponse, document, question-réponse) le mieux adapté à la requête. Vous ne pouvez pas configurer Amazon Kendra pour renvoyer un type spécifique de réponse de recherche (réponse, document, question-réponse) à une requête.
Pour plus d'informations sur les réponses aux requêtes, consultez[Réponses aux requêtes et types de réponses](query-responses-types.md).
**Topics**
+ [Conditions préalables](#searching-prerequisites)
+ [Recherche dans un index (console)](#searching-index-console)
+ [Recherche dans un index (SDK)](#searching-index-sdk)
+ [Recherche dans un index (Postman)](#searching-index-postman)
+ [Recherche à l'aide d'une syntaxe de requête avancée](#searching-index-query-syntax)
+ [Recherche dans les langues](#searching-index-languages)
## Conditions préalables
Avant d'utiliser l'API [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) pour interroger un index :
+ Configurez les autorisations requises pour un index et connectez-vous à votre source de données ou téléchargez vos documents par lots. Pour plus d'informations, consultez la section [IAM Rôles](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html). Vous utilisez le nom de ressource Amazon du rôle lorsque vous appelez l'API pour créer un index et un connecteur de source de données ou pour télécharger des documents par lots.
+ Configurez un SDK ou accédez à la Amazon Kendra console. AWS Command Line Interface Pour plus d’informations, consultez [Configuration Amazon Kendra](https://docs.aws.amazon.com/kendra/latest/dg/setup.html).
+ Créez un index et connectez-vous à une source de données de documents ou téléchargez des documents par lots. Pour plus d'informations, consultez les sections [Création d'un index](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html) et [Création d'un connecteur de source de données](https://docs.aws.amazon.com/kendra/latest/dg/data-source.html).
## Recherche dans un index (console)
Vous pouvez utiliser la Amazon Kendra console pour rechercher et tester votre index. Vous pouvez effectuer des requêtes et voir les résultats.
**Pour rechercher un index à l'aide de la console**
1. Connectez-vous à la Amazon Kendra console AWS Management Console et ouvrez-la à l'[adresse http://console.aws.amazon.com/kendra/](https://console.aws.amazon.com/kendra).
1. Dans le volet de navigation, sélectionnez **Indexes.**
1. Choisissez votre index.
1. Dans le menu de navigation, choisissez l'option de recherche dans votre index.
1. Entrez une requête dans la zone de texte, puis appuyez sur Entrée.
1. Amazon Kendra renvoie les résultats de la recherche.
Vous pouvez également obtenir l'ID de requête pour la recherche en sélectionnant l'icône représentant une ampoule dans le panneau latéral.
## Recherche dans un index (SDK)
**Pour effectuer une recherche dans un index avec Python ou Java**
+ L'exemple suivant effectue une recherche dans un index. Modifiez la valeur `query` de votre requête de recherche `index_id` et/ou `indexId` de l'identifiant d'index de l'index que vous souhaitez rechercher.
Vous pouvez également obtenir l'ID de requête pour la recherche dans le cadre des éléments de réponse lorsque vous appelez l'API [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html).
------
#### [ 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");
}
}
}
```
------
## Recherche dans un index (Postman)
Vous pouvez utiliser [Postman](https://www.postman.com/) pour interroger et tester votre Amazon Kendra index.
**Pour effectuer une recherche dans un index à l'aide de Postman**
1. Créez une nouvelle collection dans Postman et définissez le type de demande sur **POST**.
1. Entrez l'URL du point de terminaison. Par exemple, *https://kendra. .amazonaws.com.*
1. Sélectionnez l'onglet **Autorisation** et entrez les informations suivantes.
+ **Type** —Sélectionnez une **AWS signature**.
+ **AccessKey**—Entrez la clé d'accès générée lors de la création d'un IAM utilisateur.
+ **SecretKey**—Entrez la clé secrète générée lors de la création d'un IAM utilisateur.
+ **AWS Région** —Entrez la région de votre index. Par exemple, *us-west-2*.
+ **Nom du service** —Entrez *kendra*. Ceci distingue les majuscules et minuscules, donc ce doit être fait en minuscules.
**Avertissement**
Si vous entrez un nom de service incorrect ou si vous n'utilisez pas de minuscules, une erreur est générée lorsque vous sélectionnez **Envoyer pour envoyer** la demande : « Les informations d'identification doivent être limitées au bon service « kendra ». »
Vous devez également vérifier que vous avez saisi la bonne clé d'accès et la bonne clé secrète.
1. Sélectionnez l'onglet **En-têtes** et entrez les informations de clé et de valeur suivantes.
+ Clé : *X-Amz-Target*
Valeur : *com.amazonaws.kendra. AWSKendraFrontendService.Requête*
+ Clé : Encodage *du contenu*
Valeur : *amz-1.0*
1. Sélectionnez l'onglet **Body** et procédez comme suit.
+ Choisissez le type JSON **brut** pour le corps de la demande.
+ Entrez un JSON qui inclut votre identifiant d'index et le texte de votre requête.
```
{
"IndexId": "index-id",
"QueryText": "enter a query here"
}
```
**Avertissement**
Si votre JSON n'utilise pas l'indendation correcte, une erreur est renvoyée : « »SerializationException. Vérifiez l'indendation dans votre JSON.
1. Sélectionnez **Envoyer** (en haut à droite).
## Recherche à l'aide d'une syntaxe de requête avancée
Vous pouvez créer des requêtes plus spécifiques que de simples requêtes par mots clés ou en langage naturel en utilisant une syntaxe ou des opérateurs de requête avancés. Cela inclut les plages, les booléens, les caractères génériques, etc. En utilisant des opérateurs, vous pouvez donner plus de contexte à votre requête et affiner les résultats de recherche.
Amazon Kendra prend en charge les opérateurs suivants.
+ Booléen : logique permettant de limiter ou d'élargir la recherche. Par exemple, `amazon AND sports` limite la recherche aux seuls documents contenant les deux termes.
+ Parenthèses : lit les termes de requête imbriqués par ordre de priorité. Par exemple, `(amazon AND sports) NOT rainforest` lit `(amazon AND sports)` avant`NOT rainforest`.
+ Plages : dates ou valeurs de plage numériques. Les plages peuvent être inclusives, exclusives ou illimitées. Par exemple, vous pouvez rechercher des documents qui ont été mis à jour pour la dernière fois entre le 1er janvier 2020 et le 31 décembre 2020, y compris ces dates.
+ Champs : Utilise un champ spécifique pour limiter la recherche. Par exemple, vous pouvez rechercher des documents dont le champ « localisation » contient « États-Unis ».
+ Caractères génériques : correspondent partiellement à une chaîne de texte. Par exemple, `Cloud*` pourrait correspondre CloudFormation. Amazon Kendra ne prend actuellement en charge que les caractères génériques de fin.
+ Guillemets exacts : correspondent exactement à une chaîne de texte. Par exemple, les documents contenant`"Amazon Kendra" "pricing"`.
Vous pouvez utiliser une combinaison de n'importe lequel des opérateurs ci-dessus.
Notez qu'une utilisation excessive d'opérateurs ou des requêtes très complexes peuvent avoir un impact sur la latence des requêtes. Les Wildcards font partie des opérateurs les plus chers en termes de latence. En règle générale, plus vous utilisez de termes et d'opérateurs, plus l'impact potentiel sur la latence est important. Parmi les autres facteurs qui influent sur la latence, citons la taille moyenne des documents indexés, la taille de votre index, le filtrage des résultats de recherche et la charge globale de votre Amazon Kendra index.
### Booléen
Vous pouvez combiner ou exclure des mots à l'aide des opérateurs booléens`AND`,,`OR`. `NOT`
Voici des exemples d'utilisation d'opérateurs booléens.
**`amazon AND sports`**
Renvoie les résultats de recherche qui contiennent à la fois les termes « amazon » et « sports » dans le texte, tels que Amazon Prime Video Sports ou tout autre contenu similaire.
**`sports OR recreation`**
Renvoie les résultats de recherche qui contiennent les termes « sports » ou « loisirs », ou les deux, dans le texte.
**`amazon NOT rainforest`**
Renvoie les résultats de recherche qui contiennent le terme « amazone » mais pas le terme « forêt tropicale » dans le texte. Il s'agit de rechercher des documents sur l'entreprise Amazon, et non sur la forêt amazonienne.
### Parenthèses
Vous pouvez interroger les mots imbriqués par ordre de priorité en utilisant des parenthèses. Les parenthèses indiquent Amazon Kendra comment une requête doit être lue.
Voici des exemples d'utilisation d'opérateurs entre parenthèses.
**`(amazon AND sports) NOT rainforest`**
Renvoie les documents qui contiennent à la fois les termes « amazon » et « sports » dans le texte, mais pas le terme « forêt tropicale ». Il s'agit de rechercher des vidéos sur Amazon Prime, des sports ou d'autres contenus similaires, et non des sports d'aventure dans la forêt amazonienne. Les parenthèses aident à indiquer que cela `amazon AND sports` doit être lu avant`NOT rainforest`. La requête ne doit pas être lue comme telle`amazon AND (sports NOT rainforest)`.
**`(amazon AND (sports OR recreation)) NOT rainforest`**
Renvoie les documents contenant les termes « sport » ou « loisirs », ou les deux, et le terme « Amazon ». Mais le terme « forêt tropicale » n'y figure pas. Il s'agit de rechercher des vidéos sportives ou récréatives sur Amazon Prime, et non des sports d'aventure dans la forêt amazonienne. Les parenthèses indiquent qu'il `sports OR recreation` faut le lire avant de le combiner avec « amazon », qui est lu avant`NOT rainforest`. La requête ne doit pas être lue comme telle`amazon AND (sports OR (recreation NOT rainforest))`.
### Gammes
Vous pouvez utiliser une plage de valeurs pour filtrer les résultats de recherche. Vous spécifiez un attribut et les valeurs de plage. Il peut s'agir d'une date ou d'un type numérique.
Les plages de dates doivent respecter les formats suivants :
+ Epoch
+ YYYY
+ YYYY-mm
+ YYYY-MM-DD
+ YYYY-MM-DD'T'HH
Vous pouvez également spécifier s'il faut inclure ou exclure les valeurs inférieures et supérieures de la plage.
Voici des exemples d'utilisation des opérateurs de plage.
**`_processed_date:>2019-12-31 AND _processed_date:<2021-01-01`**
Renvoie les documents qui ont été traités en 2020, plus tard que le 31 décembre 2019 et moins que le 1er janvier 2021.
**`_processed_date:>=2020-01-01 AND _processed_date:<=2020-12-31`**
Renvoie les documents traités en 2020, supérieurs ou égaux au 1er janvier 2020 et inférieurs ou égaux au 31 décembre 2020.
**`_document_likes:<1`**
Renvoie les documents n'ayant reçu aucun « j'aime » ou aucun commentaire de la part de l'utilisateur, c'est-à-dire moins d'un « j'aime ».
Vous pouvez spécifier si une plage doit être traitée comme incluant ou excluant les valeurs de plage données.
**Inclusif**
**`_last_updated_at:[2020-01-01 TO 2020-12-31]`**
Les documents de retour ont été mis à jour pour la dernière fois en 2020, y compris les jours du 1er décembre 2020 et du 31 décembre 2020.
**Exclusif**
**`_last_updated_at:{2019-12-31 TO 2021-01-01}`**
Les documents de retour ont été mis à jour pour la dernière fois en 2020, à l'exception des jours du 31 décembre 2019 et du 1er janvier 2021.
< and >Pour les plages illimitées qui ne sont ni inclusives ni exclusives, utilisez simplement les opérateurs. Par exemple, `_last_updated_at:>2019-12-31 AND _last_updated_at:<2021-01-01`
#### Champs
Vous pouvez limiter votre recherche pour ne renvoyer que les documents correspondant à une valeur dans un champ spécifique. Le champ peut être de n'importe quel type.
Voici des exemples d'utilisation d'opérateurs de contexte au niveau du champ.
**`status:"Incomplete" AND financial_year:2021`**
Renvoie les documents de l'exercice 2021 avec leur statut incomplet.
**`(sports OR recreation) AND country:"United States" AND level:"professional"`**
Renvoie les documents qui traitent des sports professionnels ou des loisirs aux États-Unis d'Amérique.
#### Caractères génériques
Vous pouvez élargir votre recherche pour prendre en compte les variantes de mots et d'expressions à l'aide de l'opérateur générique. Cela est utile lors de la recherche de variantes de noms. Amazon Kendra ne prend actuellement en charge que les caractères génériques de fin. Le nombre de caractères de préfixe pour un caractère générique final doit être supérieur à deux.
Vous trouverez ci-dessous des exemples d'utilisation d'opérateurs génériques.
**`Cloud*`**
Renvoie les documents contenant des variantes telles que CloudFormation et CloudWatch.
**`kendra*aws`**
Renvoie les documents contenant des variantes telles que kendra.amazonaws.
**`kendra*aws*`**
Renvoie les documents contenant des variantes, tels que kendra.amazonaws.com
#### Citations exactes
Vous pouvez utiliser des guillemets pour rechercher une correspondance exacte entre un texte.
Voici des exemples d'utilisation de guillemets.
**`"Amazon Kendra" "pricing"`**
Renvoie les documents contenant à la fois l'expression « Amazon Kendra » et le terme « tarification ». Les documents doivent contenir à la fois des Amazon Kendra« » et des « prix » pour que les résultats puissent être renvoyés.
**`"Amazon Kendra" "pricing" cost`**
Renvoie les documents contenant à la fois l'expression « Amazon Kendra » et le terme « tarification », et éventuellement le terme « coût ». Les documents doivent contenir à la fois le terme « Amazon Kendra » et le « prix » afin de fournir les résultats, mais ils ne doivent pas nécessairement inclure le « coût ».
#### Syntaxe de requête non valide
Amazon Kendra émet un avertissement en cas de problème de syntaxe de votre requête ou si votre requête n'est actuellement pas prise en charge par Amazon Kendra. Pour plus d'informations, consultez la [documentation de l'API pour les avertissements relatifs aux requêtes](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Warning.html).
Les requêtes suivantes sont des exemples de syntaxe de requête non valide.
**`_last_updated_at:<2021-12-32`**
Date non valide. Le jour 32 n'existe pas dans le calendrier grégorien, qui est utilisé par Amazon Kendra.
**`_view_count:ten`**
Valeur numérique non valide. Les chiffres doivent être utilisés pour représenter des valeurs numériques.
**`nonExistentField:123`**
Recherche par champ non valide. Le champ doit exister pour pouvoir utiliser la recherche par champ.
**`Product:[A TO D]`**
Plage non valide. Des valeurs numériques ou des dates doivent être utilisées pour les plages.
**`OR Hello`**
Booléen non valide. Les opérateurs doivent être utilisés avec des termes et placés entre les termes.
## Recherche dans les langues
Vous pouvez rechercher des documents dans une langue prise en charge. Vous devez saisir le code de langue [AttributeFilter](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeFilter.html)pour renvoyer les documents filtrés dans la langue de votre choix. Vous pouvez saisir la requête dans une langue prise en charge.
Si vous ne spécifiez aucune langue, Amazon Kendra interroge les documents en anglais par défaut. Pour plus d'informations sur les langues prises en charge, y compris leurs codes, voir [Ajout de documents dans des langues autres que l'anglais](https://docs.aws.amazon.com/kendra/latest/dg/in-adding-languages.html).
Pour rechercher des documents dans une langue prise en charge dans la console, sélectionnez votre index, puis sélectionnez l'option permettant de rechercher dans votre index dans le menu de navigation. Choisissez la langue dans laquelle vous souhaitez renvoyer les documents en sélectionnant les paramètres de recherche, puis en sélectionnant une langue dans le menu déroulant **Langue**.
Les exemples suivants montrent comment rechercher des documents en espagnol.
**Pour rechercher un index en espagnol dans la console**
1. Connectez-vous à la Amazon Kendra console AWS Management Console et ouvrez-la à l'[adresse http://console.aws.amazon.com/kendra/](https://console.aws.amazon.com/kendra).
1. Dans le menu de navigation, choisissez **Index** et choisissez votre index.
1. Dans le menu de navigation, choisissez l'option de recherche dans votre index.
1. Dans les paramètres de recherche, sélectionnez le menu déroulant **Langues** et choisissez Espagnol.
1. Entrez une requête dans la zone de texte, puis appuyez sur Entrée.
1. Amazon Kendra renvoie les résultats de la recherche en espagnol.
**Pour rechercher un index en espagnol à l'aide de la CLI, de Python ou de Java**
+ L'exemple suivant recherche un index en espagnol. Modifiez la valeur `searchString` de votre requête de recherche et la valeur `indexID` de l'identifiant de l'index que vous souhaitez rechercher. Le code de langue pour l'espagnol est`es`. Vous pouvez le remplacer par votre propre code de langue.
------
#### [ 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");
}
}
}
```
------
# Récupération de passages
Vous pouvez utiliser l'[https://docs.aws.amazon.com/kendra/latest/APIReference/API_Retrieve.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Retrieve.html)API en tant que récupérateur pour les systèmes de génération augmentée (RAG).
Les systèmes RAG utilisent l'intelligence artificielle générative pour créer des applications de réponse aux questions. Les systèmes RAG se composent d'un récupérateur et de grands modèles linguistiques (LLM). À la suite d'une requête, le récupérateur identifie les parties de texte les plus pertinentes d'un corpus de documents et les transmet au LLM pour fournir la réponse la plus utile. Ensuite, le LLM analyse les fragments ou passages de texte pertinents et génère une réponse complète à la requête.
L'`Retrieve`API examine les fragments de texte ou les extraits appelés *passages* et renvoie les premiers passages les plus pertinents pour la requête.
Tout comme l'[https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html)API, l'`Retrieve`API recherche également des informations pertinentes. La récupération d'informations de l'API Retrieve prend en compte le contexte de la requête et toutes les informations disponibles à partir des documents indexés. Toutefois, par défaut, l'`Query`API renvoie uniquement des extraits contenant jusqu'à 100 mots symboliques. Grâce à l'`Retrieve`API, vous pouvez récupérer des passages plus longs contenant jusqu'à 200 mots symboliques et jusqu'à 100 passages pertinents du point de vue sémantique. Cela n'inclut pas les réponses de type question-réponse ou FAQ de votre index. Les passages, également appelés fragments, sont des extraits de texte qui peuvent être extraits sémantiquement de plusieurs documents et de plusieurs parties d'un même document. L'indice GenAI Enterprise Edition de Kendra fournit des résultats de haute précision à récupérer, en utilisant une recherche hybride sur des indices de vecteurs et de mots clés, ainsi qu'un classement par modèles d'apprentissage en profondeur.
Vous pouvez également effectuer les opérations suivantes avec l'`Retrieve`API :
+ Annuler le boost au niveau de l'indice
+ Filtrer en fonction des champs ou des attributs du document
+ Filtrer en fonction de l'accès de l'utilisateur ou de son groupe aux documents
+ Consultez le compartiment des scores de confiance pour obtenir un résultat de passage récupéré. Le bucket de confiance fournit un classement relatif qui indique dans quelle mesure la réponse est pertinente par rapport à la requête. Amazon Kendra
**Note**
Les buckets de scores de confiance ne sont actuellement disponibles qu'en anglais.
Vous pouvez également inclure dans la réponse certains champs susceptibles de fournir des informations supplémentaires utiles.
[L'`Retrieve`API ne prend actuellement pas en charge les fonctionnalités suivantes : requêtes utilisant une [syntaxe de requête avancée](https://docs.aws.amazon.com/kendra/latest/dg/searching-example.html#searching-index-query-syntax), [corrections orthographiques suggérées](https://docs.aws.amazon.com/kendra/latest/dg/query-spell-check.html) pour les requêtes, [facettage](https://docs.aws.amazon.com/kendra/latest/dg/filtering.html#search-facets), [suggestions de requêtes](https://docs.aws.amazon.com/kendra/latest/dg/query-suggestions.html) pour compléter automatiquement les requêtes de recherche et apprentissage progressif.](https://docs.aws.amazon.com/kendra/latest/dg/submitting-feedback.html) Aucune requête d'API de récupération n'apparaîtra dans le tableau de bord d'analyse.
L'`Retrieve`API partage le nombre d'[unités de capacité de requête](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CapacityUnitsConfiguration.html) que vous définissez pour votre index. Pour plus d'informations sur ce qui est inclus dans une unité de capacité unique et sur la capacité de base par défaut d'un indice, consultez la section [Ajustement de la capacité](https://docs.aws.amazon.com/kendra/latest/dg/adjusting-capacity.html).
**Note**
Vous ne pouvez pas ajouter de capacité si vous utilisez l'édition Amazon Kendra Developer ; vous ne pouvez ajouter de la capacité que si vous utilisez l'édition Amazon Kendra Enterprise. Pour plus d'informations sur ce qui est inclus dans les éditions Developer et Enterprise, consultez la section [Amazon Kendra Éditions](https://docs.aws.amazon.com/kendra/latest/dg/what-is-kendra.html#kendra-editions).
Voici un exemple d'utilisation de l'`Retrieve`API pour récupérer les 100 passages les plus pertinents des documents dans un index pour la requête. "how does amazon kendra work?"
------
#### [ 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");
}
}
}
```
------
# Parcourir un index
**Note**
La prise en charge des fonctionnalités varie en fonction du type d'index et de l'API de recherche utilisés. Pour savoir si cette fonctionnalité est prise en charge pour le type d'index et l'API de recherche que vous utilisez, consultez la section [Types d'index](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Vous pouvez parcourir les documents en fonction de leurs attributs ou de leurs facettes sans avoir à saisir de requête de recherche. Amazon Kendra *Index Browse* peut aider vos utilisateurs à découvrir des documents en parcourant librement un index sans avoir à répondre à une requête spécifique. Cela permet également à vos utilisateurs de parcourir largement un index comme point de départ de leur recherche.
Index Browse ne peut être utilisé que pour effectuer une recherche par attribut ou facette du document avec un type de tri. Vous ne pouvez pas effectuer de recherche dans un index complet à l'aide de l'outil Index Browse. Si le texte de la requête est absent, Amazon Kendra demande un filtre d'attribut de document ou une facette, ainsi qu'un type de tri.
Pour autoriser la navigation dans les index à l'aide de l'API [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html), vous devez inclure [AttributeFilter](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeFilter.html)ou [Facet](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Facet.html), et [SortingConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_SortingConfiguration.html). Pour autoriser la navigation par index dans la console, sélectionnez votre **index** sous Index dans le menu de navigation, puis sélectionnez l'option permettant de rechercher dans votre index. Dans le champ de recherche, appuyez deux fois sur la touche *Entrée*. Sélectionnez le menu déroulant **Filtrer les résultats de recherche** pour choisir un filtre et sélectionnez le menu déroulant **Trier** pour choisir un type de tri.
Voici un exemple de navigation dans un index de documents en espagnol par ordre décroissant de date de création du document.
------
#### [ 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");
}
}
}
```
------
# Avec les résultats de recherche
**Note**
La prise en charge des fonctionnalités varie en fonction du type d'index et de l'API de recherche utilisés. Pour savoir si cette fonctionnalité est prise en charge pour le type d'index et l'API de recherche que vous utilisez, consultez la section [Types d'index](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Vous pouvez faire apparaître certains documents dans les résultats de recherche lorsque vos utilisateurs émettent certaines requêtes. Cela permet de rendre les résultats plus visibles et plus visibles pour vos utilisateurs. Les résultats présentés sont séparés de la liste de résultats habituelle et affichés en haut de la page de recherche. Vous pouvez essayer de proposer différents documents pour différentes requêtes ou vous assurer que certains documents obtiennent la visibilité qu'ils méritent.
Vous associez des requêtes spécifiques à des documents spécifiques pour les inclure dans les résultats. Si une requête contient une correspondance exacte, un ou plusieurs documents spécifiques apparaissent dans les résultats de recherche.
Par exemple, vous pouvez spécifier que si vos utilisateurs émettent la requête « nouveaux produits 2023 », ils sélectionnent les documents intitulés « Nouveautés » et « Prochainement » à afficher en haut de la page des résultats de recherche. Cela permet de garantir que ces documents sur les nouveaux produits obtiennent la visibilité qu'ils méritent.
Amazon Kendra ne duplique pas les résultats de recherche si un résultat est déjà sélectionné pour figurer en haut de la page des résultats de recherche. Un résultat en vedette n'est pas à nouveau classé comme premier résultat s'il figure déjà au-dessus de tous les autres résultats.
Pour obtenir certains résultats, vous devez spécifier une correspondance exacte à une requête en texte intégral, et non une correspondance partielle à une requête utilisant un mot clé ou une phrase contenue dans une requête. Par exemple, si vous spécifiez uniquement la requête « Kendra » dans un ensemble de résultats en vedette, des requêtes telles que « Comment Kendra classe-t-elle sémantiquement les résultats ? » n'affichera pas les résultats présentés. Les résultats présentés sont conçus pour des requêtes spécifiques, plutôt que pour des requêtes dont la portée est trop large. Amazon Kendra gère naturellement les requêtes de type mot clé afin de classer les documents les plus utiles dans les résultats de recherche, évitant ainsi une présentation excessive des résultats basés sur des mots clés simples.
Si certaines requêtes sont fréquemment utilisées par vos utilisateurs, vous pouvez les spécifier pour obtenir des résultats en vedette. Par exemple, si vous examinez vos principales requêtes à l'aide [Amazon Kendra d'Analytics](https://docs.aws.amazon.com/kendra/latest/dg/search-analytics.html) et que vous trouvez des requêtes spécifiques, telles que « Comment Kendra classe-t-elle sémantiquement les résultats ? » et « Kendra Semantic Search » sont fréquemment utilisées. Il peut donc être utile de spécifier ces requêtes pour présenter le document intitulé « search 101 ».Amazon Kendra
Amazon Kendra traite les requêtes portant sur les résultats présentés sans distinction majuscules/minuscules. Amazon Kendra convertit une requête en minuscules et remplace les espaces blancs de fin par un seul espace. Amazon Kendra correspond à tous les autres caractères tels qu'ils sont lorsque vous spécifiez vos requêtes pour les résultats présentés.
Vous créez un ensemble de résultats en vedette que vous associez à certaines requêtes à l'aide de l'[CreateFeaturedResultsSet](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateFeaturedResultsSet.html)API. Si vous utilisez la console, vous sélectionnez votre index, puis sélectionnez **Résultats en vedette** dans le menu de navigation pour créer un ensemble de résultats sélectionnés. Vous pouvez créer jusqu'à 50 ensembles de résultats en vedette par index, jusqu'à quatre documents à présenter par ensemble et jusqu'à 49 textes de requête par ensemble de résultats en vedette. Vous pouvez demander à augmenter ces limites en contactant le [Support](https://aws.amazon.com/contact-us/).
Vous pouvez sélectionner le même document parmi plusieurs ensembles de résultats présentés. Toutefois, vous ne devez pas utiliser le même texte de requête de correspondance exacte dans plusieurs ensembles. Les requêtes que vous spécifiez pour les résultats en vedette doivent être uniques par résultat en vedette défini pour chaque index.
Vous pouvez organiser l'ordre des documents lorsque vous sélectionnez jusqu'à quatre documents en vedette. Si vous utilisez l'API, l'ordre dans lequel vous listez les documents en vedette est le même que celui affiché dans les résultats présentés. Si vous utilisez la console, vous pouvez simplement glisser-déposer l'ordre des documents lorsque vous sélectionnez les documents à inclure dans les résultats.
Le contrôle d'accès, selon lequel certains utilisateurs et groupes ont accès à certains documents et d'autres non, est toujours respecté lors de la configuration des résultats présentés. Cela vaut également pour le filtrage du contexte utilisateur. Par exemple, l'utilisateur A appartient au groupe d'entreprises « Stagiaires », qui ne doit pas accéder aux documents relatifs aux secrets de l'entreprise. Si l'utilisateur A saisit une requête contenant un document secret d'entreprise, l'utilisateur A ne voit pas ce document apparaître dans ses résultats. Cela vaut également pour tous les autres résultats de la page des résultats de recherche. Vous pouvez également utiliser des balises pour contrôler l'accès à un ensemble de résultats en vedette, qui est une Amazon Kendra ressource pour laquelle vous contrôlez l'accès.
Voici un exemple de création d'un ensemble de résultats en vedette avec les requêtes « nouveaux produits 2023 », « nouveaux produits disponibles » mappées aux documents intitulés « Nouveautés » (doc-id-1) et « Prochainement » (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.")
```
------
# Recherche tabulaire pour le HTML
**Note**
La prise en charge des fonctionnalités varie en fonction du type d'index et de l'API de recherche utilisés. Pour savoir si cette fonctionnalité est prise en charge pour le type d'index et l'API de recherche que vous utilisez, consultez la section [Types d'index](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Amazon Kendra La fonction de recherche tabulaire permet de rechercher et d'extraire des réponses à partir de tableaux intégrés dans des documents HTML. Lorsque vous effectuez une recherche dans votre index, Amazon Kendra inclut un extrait d'un tableau s'il est pertinent pour la requête et fournit des informations utiles.
Amazon Kendra examine toutes les informations contenues dans le corps du texte d'un document, y compris les informations utiles contenues dans les tableaux. Par exemple, un index contient des rapports commerciaux avec des tableaux sur les coûts d'exploitation, les revenus et d'autres informations financières. Pour la question, « quel est le coût de fonctionnement annuel de 2020 à 2022 ? » , Amazon Kendra peut renvoyer un extrait d'un tableau contenant les colonnes pertinentes « Opérations (millions de dollars américains) » et « Exercice financier », ainsi que des lignes de tableau contenant les valeurs des revenus pour 2020, 2021 et 2022. L'extrait du tableau est inclus dans le résultat, ainsi que le titre du document, un lien vers le document complet et tout autre champ du document que vous choisissez d'inclure.
Des extraits de tableau peuvent être affichés dans les résultats de recherche, que les informations se trouvent dans une ou plusieurs cellules d'un tableau. Par exemple, Amazon Kendra vous pouvez afficher un extrait de tableau adapté à chacun de ces types de requêtes :
+ « carte de crédit au taux d'intérêt le plus élevé en 2020 »
+ « carte de crédit au taux d'intérêt le plus élevé de 2020-2022"
+ « Les 3 cartes de crédit ayant le taux d'intérêt le plus élevé en 2020-2022"
+ « cartes de crédit dont le taux d'intérêt est inférieur à 10 % »
+ « toutes les cartes de crédit à faible taux d'intérêt disponibles »
Amazon Kendra met en évidence la ou les cellules du tableau les plus pertinentes pour la requête. Les cellules les plus pertinentes avec leurs lignes, colonnes et noms de colonnes correspondants sont affichées dans les résultats de recherche. L'extrait du tableau affiche jusqu'à cinq colonnes et trois lignes, selon le nombre de cellules du tableau correspondant à la requête et le nombre de colonnes disponibles dans le tableau d'origine. La cellule la plus pertinente du haut est affichée dans l'extrait du tableau, ainsi que les cellules les plus pertinentes suivantes.
La réponse inclut le compartiment de confiance (`MEDIUM`,`HIGH`,`VERY_HIGH`) pour montrer dans quelle mesure la réponse de la table est pertinente par rapport à la requête. Si la valeur d'une cellule de tableau est `VERY_HIGH` confidentielle, elle devient la « première réponse » et est surlignée. Pour les valeurs de cellule de tableau qui sont `HIGH` fiables, elles sont mises en surbrillance. Pour les valeurs de cellule de tableau qui sont `MEDIUM` confidentielles, elles ne sont pas surlignées. La confiance globale pour la réponse du tableau est renvoyée dans la réponse. Par exemple, si un tableau contient principalement des cellules fiables, le niveau de `HIGH` confiance global renvoyé dans la réponse pour la réponse du tableau est le niveau de `HIGH` confiance.
Par défaut, les tableaux n'ont pas une importance ou un poids supérieurs à ceux des autres composants d'un document. Dans un document, si un tableau n'est que légèrement pertinent pour une requête, mais qu'il contient un paragraphe très pertinent, Amazon Kendra renvoie un extrait du paragraphe. Les résultats de recherche affichent le contenu qui fournit la meilleure réponse possible et les informations les plus utiles, dans le même document ou dans d'autres documents. Si le niveau de confiance d'un tableau est inférieur à celui de `MEDIUM` confiance, l'extrait du tableau n'est pas renvoyé dans la réponse.
Pour utiliser la recherche tabulaire sur un index existant, vous devez réindexer votre contenu.
Amazon Kendra la recherche tabulaire prend en charge les [synonymes](https://docs.aws.amazon.com/kendra/latest/dg/index-synonyms.html) (y compris les synonymes personnalisés). Amazon Kendra ne prend en charge que les documents en anglais contenant des tableaux HTML inclus dans la balise table.
L'exemple suivant montre un extrait de table inclus dans le résultat de la requête. Pour afficher un exemple de JSON avec des réponses à des requêtes, y compris des extraits de tableau, voir [Réponses et types de requêtes](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");
}
}
}
```
------
# suggestions de requêtes
**Note**
La prise en charge des fonctionnalités varie en fonction du type d'index et de l'API de recherche utilisés. Pour savoir si cette fonctionnalité est prise en charge pour le type d'index et l'API de recherche que vous utilisez, consultez la section [Types d'index](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Amazon Kendra Les *suggestions de requêtes* peuvent aider vos utilisateurs à saisir leurs requêtes de recherche plus rapidement et à orienter leur recherche.
Amazon Kendra suggère des requêtes pertinentes pour vos utilisateurs sur la base de l'un des éléments suivants :
+ Requêtes populaires dans l'historique des requêtes ou le journal des requêtes
+ Le contenu des champs/attributs du document
Vous pouvez définir vos préférences pour l'utilisation de l'historique des requêtes ou des champs du document en les définissant `SuggestionTypes` comme `QUERY` suit ou `DOCUMENT_ATTRIBUTES` en appelant [https://docs.aws.amazon.com/kendra/latest/APIReference/API_GetQuerySuggestions.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_GetQuerySuggestions.html). Amazon Kendra Utilise par défaut l'historique des requêtes pour baser ses suggestions. Si l'historique des requêtes et les champs du document sont tous deux activés lorsque vous appelez [https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsConfig.html)et que vous n'avez pas défini votre `SuggestionTypes` préférence pour l'utilisation des champs de document, Amazon Kendra utilise l'historique des requêtes.
Si vous utilisez la console, vous pouvez baser vos suggestions de requêtes sur l'historique des requêtes ou sur les champs du document. Vous devez d'abord sélectionner votre index, puis sélectionner **Suggestions de requêtes** sous **Enrichissements** dans le menu de navigation. Sélectionnez ensuite **Configurer les suggestions de requêtes**. Après avoir configuré les suggestions de requêtes, vous êtes dirigé vers une console de recherche dans laquelle vous pouvez sélectionner les **champs **Historique des requêtes** ou Document** dans le panneau de droite et saisir une requête de recherche dans la barre de recherche.
Par défaut, les suggestions de requêtes utilisant l'historique des requêtes et les champs du document sont toutes deux activées sans frais supplémentaires. Vous pouvez désactiver ces types de suggestions de requêtes à tout moment à l'aide de l'`UpdateQuerySuggestionsConfig`API. Pour désactiver les suggestions de requêtes en fonction de l'historique des requêtes, définissez cette option sur `DISABLED` lors `Mode` de l'appel`UpdateQuerySuggestionsConfig`. Pour désactiver les suggestions de requêtes basées sur les champs du document, définissez `AttributeSuggestionsMode` ce paramètre `INACTIVE` dans la configuration des champs du document, puis appelez`UpdateQuerySuggestionsConfig>`. Si vous utilisez la console, vous pouvez désactiver les suggestions de requêtes dans les **paramètres des suggestions de requêtes**.
Les suggestions de requêtes ne distinguent pas les majuscules et minuscules. Amazon Kendra convertit le préfixe de requête et la requête suggérée en minuscules, ignore tous les guillemets simples et doubles et remplace plusieurs espaces blancs par un seul espace. Amazon Kendra correspond à tous les autres caractères spéciaux tels quels. Amazon Kendra n'affiche aucune suggestion si un utilisateur saisit moins de deux caractères ou plus de 60 caractères.
**Topics**
+ [Suggestions de requêtes utilisant l'historique des requêtes](#query-suggestions-history)
+ [Suggestions de requêtes à l'aide de champs](#query-suggestions-doc-fields)
+ [Empêcher les suggestions de certaines requêtes ou de certains contenus de champs de documents](#query-suggestions-blocklist)
## Suggestions de requêtes utilisant l'historique des requêtes
**Note**
La prise en charge des fonctionnalités varie en fonction du type d'index et de l'API de recherche utilisés. Pour savoir si cette fonctionnalité est prise en charge pour le type d'index et l'API de recherche que vous utilisez, consultez la section [Types d'index](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
**Topics**
+ [Paramètres de sélection des requêtes pour les suggestions](#query-suggestions-history-settings)
+ [Suggestions claires tout en conservant l'historique des requêtes](#query-suggestions-history-clear)
+ [Aucune suggestion disponible](#query-suggestions-history-none)
Vous pouvez choisir de suggérer des requêtes pertinentes pour vos utilisateurs en fonction des requêtes courantes figurant dans l'historique des requêtes ou le journal des requêtes. Amazon Kendra utilise toutes les requêtes recherchées par vos utilisateurs et en tire des leçons pour faire des suggestions à vos utilisateurs. Amazon Kendra suggère des requêtes populaires aux utilisateurs lorsqu'ils commencent à taper leur requête. Amazon Kendra suggère une requête si le préfixe ou les premiers caractères de la requête correspondent à ce que l'utilisateur commence à taper comme requête.
Par exemple, un utilisateur commence à taper la requête « événements à venir ». Amazon Kendra a appris de l'historique des requêtes que de nombreux utilisateurs ont recherché à de nombreuses reprises « événements à venir en 2050 ». L'utilisateur voit « événements à venir 2050 » apparaître directement sous sa barre de recherche, complétant automatiquement sa requête de recherche. L'utilisateur sélectionne cette suggestion de requête, et le document « Nouveaux événements : que se passe-t-il en 2050 » apparaît dans les résultats de recherche.
Vous pouvez définir le mode Amazon Kendra de sélection des requêtes éligibles à suggérer à vos utilisateurs. Par exemple, vous pouvez spécifier qu'une suggestion de requête doit avoir été recherchée par au moins 10 utilisateurs uniques (la valeur par défaut est trois), avoir été recherchée au cours des 30 derniers jours et ne contenir aucun mot ou expression de votre [liste de blocage](https://docs.aws.amazon.com/kendra/latest/dg/query-suggestions.html#query-suggestions-blocklist). Amazon Kendra exige qu'une requête comporte au moins un résultat de recherche et contienne au moins un mot de plus de quatre caractères.
### Paramètres de sélection des requêtes pour les suggestions
Vous pouvez configurer les paramètres suivants pour sélectionner des requêtes de suggestions à l'aide de l'[https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsConfig.html)API :
+ **Mode** —Les suggestions de requêtes utilisant l'historique des requêtes sont soit, `ENABLED` soit`LEARN_ONLY`. Amazon Kendra active les suggestions de requêtes par défaut. `LEARN_ONLY`désactive les suggestions de requêtes. Si cette option est désactivée, elle Amazon Kendra continue à apprendre les suggestions, mais ne propose pas de suggestions de requêtes aux utilisateurs.
+ **Fenêtre temporelle du journal des requêtes** : date de la date de vos requêtes dans la fenêtre du journal des requêtes. La fenêtre temporelle est une valeur entière correspondant au nombre de jours entre le jour actuel et les jours précédents.
+ **Requêtes sans informations utilisateur** : définissez ce `TRUE` paramètre sur pour inclure toutes les requêtes ou sur uniquement `FALSE` les requêtes contenant des informations utilisateur. Vous pouvez utiliser ce paramètre si votre application de recherche inclut des informations utilisateur, telles que l'ID utilisateur, lorsqu'un utilisateur émet une requête. Par défaut, ce paramètre ne filtre pas les requêtes si aucune information utilisateur spécifique n'est associée aux requêtes. Toutefois, vous ne pouvez utiliser ce paramètre que pour faire des suggestions basées sur des requêtes contenant des informations utilisateur.
+ **Utilisateurs uniques** : nombre minimum d'utilisateurs uniques qui doivent effectuer une recherche pour que celle-ci puisse être suggérée à vos utilisateurs. Ce nombre est une valeur entière.
+ **Nombre de requêtes** : nombre minimum de fois qu'une requête doit être recherchée pour qu'elle puisse être suggérée à vos utilisateurs. Ce nombre est une valeur entière.
Ces paramètres affectent la manière dont les requêtes sont sélectionnées en tant que requêtes populaires à suggérer à vos utilisateurs. La façon dont vous réglerez vos paramètres dépendra de vos besoins spécifiques, par exemple :
+ Si vos utilisateurs effectuent généralement une recherche une fois par mois en moyenne, vous pouvez définir le nombre de jours dans la fenêtre du journal des requêtes à 30 jours. En utilisant ce paramètre, vous capturez la plupart des requêtes récentes de vos utilisateurs avant qu'elles ne deviennent obsolètes dans la fenêtre temporelle.
+ Si seul un petit nombre de vos requêtes incluent des informations utilisateur et que vous ne souhaitez pas suggérer de requêtes basées sur un échantillon de petite taille, vous pouvez définir des requêtes pour inclure tous les utilisateurs.
+ Si vous définissez les requêtes populaires comme étant recherchées par au moins 10 utilisateurs uniques et recherchées au moins 100 fois, vous définissez les utilisateurs uniques sur 10 et le nombre de requêtes sur 100.
**Avertissement**
Les modifications que vous avez apportées aux paramètres peuvent ne pas prendre effet immédiatement. Vous pouvez suivre les modifications des paramètres à l'aide de l'[https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html)API. Le délai d'entrée en vigueur de vos paramètres mis à jour dépend des mises à jour que vous effectuez et du nombre de requêtes de recherche dans votre index. Amazon Kendra met automatiquement à jour les suggestions toutes les 24 heures, après avoir modifié un paramètre ou après avoir appliqué une [liste de blocage](https://docs.aws.amazon.com/kendra/latest/dg/query-suggestions.html#query-suggestions-blocklist).
------
#### [ CLI ]
**Pour récupérer des suggestions de requêtes**
```
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
```
**Pour mettre à jour les suggestions de requêtes**
Par exemple, pour modifier la fenêtre temporelle du journal des requêtes et le nombre minimum de fois qu'une requête doit être recherchée :
```
aws kendra update-query-suggestions-config \
--index-id index-id \
--query-log-look-back-window-in-days 30 \
--minimum-query-count 100
```
------
#### [ Python ]
**Pour récupérer des suggestions de requêtes**
```
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.")
```
**Pour mettre à jour les suggestions de requêtes**
Par exemple, pour modifier la fenêtre temporelle du journal des requêtes et le nombre minimum de fois qu'une requête doit être recherchée :
```
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.")
```
------
### Suggestions claires tout en conservant l'historique des requêtes
**Note**
La prise en charge des fonctionnalités varie en fonction du type d'index et de l'API de recherche utilisés. Pour savoir si cette fonctionnalité est prise en charge pour le type d'index et l'API de recherche que vous utilisez, consultez la section [Types d'index](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Vous pouvez effacer les suggestions de requêtes à l'aide de l'[https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html)API. La suppression des suggestions supprime uniquement les suggestions de requêtes existantes, et non les requêtes de l'historique des requêtes. Lorsque vous effacez des suggestions, Amazon Kendra apprend les nouvelles suggestions en fonction des nouvelles requêtes ajoutées au journal des requêtes à partir du moment où vous avez effacé les suggestions.
------
#### [ CLI ]
**Pour effacer les suggestions de requêtes**
```
aws kendra clear-query-suggestions \
--index-id index-id
```
------
#### [ Python ]
**Pour effacer les suggestions de requêtes**
```
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.")
```
------
### Aucune suggestion disponible
Si aucune suggestion de requête ne s'affiche, cela peut être dû à l'une des raisons suivantes :
+ Votre index ne contient pas suffisamment de requêtes pour en Amazon Kendra tirer des leçons.
+ Vos paramètres de suggestions de requêtes sont trop stricts, de sorte que la plupart des requêtes sont exclues des suggestions.
+ Vous avez récemment effacé des suggestions et vous avez Amazon Kendra encore besoin de temps pour que les nouvelles requêtes s'accumulent afin de connaître de nouvelles suggestions.
Vous pouvez vérifier vos paramètres actuels à l'aide de l'[https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html)API.
## Suggestions de requêtes à l'aide de champs
**Topics**
+ [Paramètres de sélection des champs pour les suggestions](#query-suggestions-doc-fields-settings)
+ [Contrôle par l'utilisateur dans les champs du document](#query-suggestions-doc-fields-user-control)
Vous pouvez choisir de suggérer des requêtes pertinentes pour vos utilisateurs en fonction du contenu des champs du document. Au lieu d'utiliser l'historique des requêtes pour suggérer d'autres requêtes pertinentes populaires, vous pouvez utiliser les informations contenues dans un champ de document qui sont utiles pour compléter automatiquement la requête. Amazon Kendra recherche le contenu pertinent dans les champs définis sur `Suggestable` et correspondant étroitement à la requête de votre utilisateur. Amazon Kendra Suggère ensuite ce contenu à votre utilisateur lorsqu'il commence à taper sa requête.
Par exemple, si vous spécifiez le champ de titre sur lequel baser les suggestions et qu'un utilisateur commence à taper la requête « How amazon ken... », le titre le plus pertinent « Comment Amazon Kendra fonctionne » pourrait être suggéré pour compléter automatiquement la recherche. L'utilisateur voit « Comment Amazon Kendra fonctionne » apparaître directement sous sa barre de recherche, complétant automatiquement sa requête de recherche. L'utilisateur sélectionne cette suggestion de requête et le document « Comment Amazon Kendra fonctionne » apparaît dans les résultats de recherche.
Vous pouvez utiliser le contenu de n'importe quel champ `String` et `StringList` type de document pour suggérer une requête en définissant le champ sur dans le cadre de `Suggestable` la configuration de vos champs pour les suggestions de requêtes. Vous pouvez également utiliser une [liste de blocage](https://docs.aws.amazon.com/kendra/latest/dg/query-suggestions.html#query-suggestions-blocklist) afin que les champs de document suggérés contenant certains mots ou expressions ne soient pas affichés à vos utilisateurs. Vous pouvez utiliser une seule liste de blocage. La liste de blocage s'applique, que vous définissiez des suggestions de requêtes pour utiliser l'historique des requêtes ou les champs du document.
### Paramètres de sélection des champs pour les suggestions
Vous pouvez configurer les paramètres suivants pour sélectionner les champs du document pour les suggestions en utilisant [https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeSuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeSuggestionsConfig.html)et en appelant l'[https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsConfig.html)API pour mettre à jour les paramètres au niveau de l'index :
+ **Mode suggestions de champs/attributs : les suggestions** de requêtes utilisant des champs de document sont soit, soit. `ACTIVE` `INACTIVE` Amazon Kendra active les suggestions de requêtes par défaut.
+ **Champs/attributs suggestibles : noms de champs** ou clés de champ sur lesquels baser les suggestions. Ces champs doivent être définis sur `TRUE` for`Suggestable`, dans le cadre de la configuration des champs. Vous pouvez modifier la configuration des champs au niveau de la requête tout en conservant la configuration au niveau de l'index. Utilisez l'[GetQuerySuggestions](https://docs.aws.amazon.com/kendra/latest/APIReference/API_GetQuerySuggestions.html)API pour modifier `AttributeSuggestionConfig` au niveau de la requête. Cette configuration au niveau de la requête peut être utile pour expérimenter rapidement l'utilisation de différents champs de document sans avoir à mettre à jour la configuration au niveau de l'index.
+ **Champs/attributs** supplémentaires : champs supplémentaires que vous souhaitez inclure dans la réponse à une suggestion de requête. Ces champs sont utilisés pour fournir des informations supplémentaires dans la réponse, mais ils ne sont pas utilisés pour baser les suggestions.
**Avertissement**
Les modifications que vous avez apportées aux paramètres peuvent ne pas prendre effet immédiatement. Vous pouvez suivre les modifications des paramètres à l'aide de l'[https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html)API. Le délai d'entrée en vigueur de vos paramètres mis à jour dépend des mises à jour que vous effectuez. Amazon Kendra met automatiquement à jour les suggestions toutes les 24 heures, après avoir modifié un paramètre ou après avoir appliqué une [liste de blocage](https://docs.aws.amazon.com/kendra/latest/dg/query-suggestions.html#query-suggestions-blocklist).
------
#### [ CLI ]
Pour récupérer des suggestions de requêtes et modifier la configuration des champs du document au niveau de la requête au lieu de modifier la configuration au niveau de l'index.
```
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
```
**Pour mettre à jour les suggestions de requêtes**
Par exemple, pour modifier la configuration des champs du document au niveau de l'index :
```
aws kendra update-query-suggestions-config \
--index-id index-id \
--attribute-suggestions-config '{"SuggestableConfigList": '[{"SuggestableConfig": "_document_title", "Suggestable": true}]', "AttributeSuggestionsMode": "ACTIVE"}'
```
------
#### [ Python ]
Pour récupérer des suggestions de requêtes et modifier la configuration des champs du document au niveau de la requête au lieu de modifier la configuration au niveau de l'index.
```
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.")
```
**Pour mettre à jour les suggestions de requêtes**
Par exemple, pour modifier la configuration des champs du document au niveau de l'index :
```
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.")
```
------
### Contrôle par l'utilisateur dans les champs du document
Vous pouvez appliquer un filtrage contextuel utilisateur aux champs du document sur lesquels vous souhaitez baser les suggestions de requêtes. Cela filtre les informations des champs du document en fonction de l'accès de l'utilisateur ou de son groupe aux documents. Par exemple, un stagiaire effectue une recherche sur le portail de l'entreprise et n'a pas accès à un document top secret de l'entreprise. Par conséquent, les requêtes suggérées basées sur le titre du document top secret, ou sur tout autre champ suggestible, ne sont pas présentées au stagiaire.
Vous pouvez indexer vos documents à l'aide d'une liste de contrôle d'accès (ACL), qui définit quels utilisateurs et groupes sont autorisés à accéder à quels documents. Vous pouvez ensuite appliquer un filtrage contextuel utilisateur aux champs de vos documents pour les suggestions de requêtes. Le filtrage du contexte utilisateur actuellement défini pour votre index est le même que celui appliqué à la configuration des champs de votre document pour les suggestions de requêtes. Le filtrage du contexte utilisateur fait partie de la configuration des champs de votre document. Vous utilisez le [https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeSuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeSuggestionsConfig.html)et appelez [https://docs.aws.amazon.com/kendra/latest/APIReference/API_GetQuerySuggestions.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_GetQuerySuggestions.html).
## Empêcher les suggestions de certaines requêtes ou de certains contenus de champs de documents
Une *liste de blocage* Amazon Kendra empêche de suggérer certaines requêtes à vos utilisateurs. Une liste de blocage est une liste de mots ou d'expressions que vous souhaitez exclure des suggestions de requêtes. Amazon Kendra exclut les requêtes contenant une correspondance exacte avec les mots ou expressions de la liste de blocage.
Vous pouvez utiliser une liste de blocage pour vous protéger contre les mots ou expressions offensants qui apparaissent fréquemment dans l'historique de vos requêtes ou dans les champs du document et qui Amazon Kendra pourraient être sélectionnés comme suggestions. Une liste de blocage peut également Amazon Kendra empêcher de suggérer des requêtes contenant des informations qui ne sont pas prêtes à être publiées ou annoncées. Par exemple, vos utilisateurs posent fréquemment des questions sur la sortie prochaine d'un nouveau produit potentiel. Toutefois, vous ne souhaitez pas suggérer le produit car vous n'êtes pas prêt à le lancer. Vous pouvez bloquer les requêtes contenant le nom du produit et des informations sur le produit dans les suggestions.
Vous pouvez créer une liste de blocage pour les requêtes à l'aide de l'[https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateQuerySuggestionsBlockList.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateQuerySuggestionsBlockList.html)API. Vous placez chaque mot ou phrase en bloc sur une ligne distincte d'un fichier texte. Ensuite, vous chargez le fichier texte dans votre compartiment Amazon S3 et vous indiquez le chemin ou l'emplacement du fichier Amazon S3. Amazon Kendra prend actuellement en charge la création d'une seule liste de blocage.
Vous pouvez remplacer le fichier texte contenant les mots et expressions bloqués dans votre Amazon S3 compartiment. Pour mettre à jour la liste de blocage dans Amazon Kendra, utilisez l'[https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsBlockList.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsBlockList.html)API.
Utilisez l'[https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsBlockList.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsBlockList.html)API pour connaître le statut de votre liste de blocage. `DescribeQuerySuggestionsBlockList`peut également vous fournir d'autres informations utiles, telles que les suivantes :
+ Quand votre liste de blocage a été mise à jour pour la dernière fois
+ Combien de mots ou d'expressions se trouvent dans votre liste de blocage actuelle
+ Messages d'erreur utiles lors de la création d'une liste de blocage
Vous pouvez également utiliser l'[https://docs.aws.amazon.com/kendra/latest/APIReference/API_ListQuerySuggestionsBlockLists.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_ListQuerySuggestionsBlockLists.html)API pour obtenir une liste de résumés de listes de blocage pour un index.
Pour supprimer votre liste de blocage, utilisez l'[DeleteQuerySuggestionsBlockList](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DeleteQuerySuggestionsBlockList.html)API.
Les mises à jour de la liste de blocage risquent de ne pas prendre effet immédiatement. Vous pouvez suivre les mises à jour à l'aide de l'`DescribeQuerySuggestionsBlockList`API.
------
#### [ CLI ]
**Pour créer une liste de blocage**
```
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
```
**Pour mettre à jour une liste de blocage**
```
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
```
**Pour supprimer une liste de blocage**
```
aws kendra delete-query-suggestions-block-list \
--index-id index-id \
--id block-list-id
```
------
#### [ Python ]
**Pour créer une liste de blocage**
```
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.")
```
**Pour mettre à jour une liste de blocage**
```
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.")
```
**Pour supprimer une liste de blocage**
```
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.")
```
------
# Correcteur orthographique des requêtes
**Note**
La prise en charge des fonctionnalités varie en fonction du type d'index et de l'API de recherche utilisés. Pour savoir si cette fonctionnalité est prise en charge pour le type d'index et l'API de recherche que vous utilisez, consultez la section [Types d'index](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Amazon Kendra *Le correcteur orthographique* suggère des corrections orthographiques pour une requête. Cela peut vous aider à réduire au minimum les occurrences de zéro résultat de recherche et à renvoyer des résultats pertinents. Vos utilisateurs peuvent ne recevoir [aucun résultat de recherche](https://docs.aws.amazon.com/kendra/latest/dg/search-analytics.html#search-analytics-metrics) en raison de requêtes mal orthographiées sans résultats correspondants ou sans documents renvoyés. Il se peut également que vos utilisateurs reçoivent des [résultats de recherche non pertinents en raison](https://docs.aws.amazon.com/kendra/latest/dg/search-analytics.html#search-analytics-metrics) de requêtes mal orthographiées.
Le correcteur orthographique est conçu pour suggérer des corrections pour les mots mal orthographiés en fonction des mots qui apparaissent dans vos documents indexés et de la mesure dans laquelle un mot corrigé correspond à un mot mal orthographié. Par exemple, si le mot « relevés » apparaît dans vos documents indexés, il peut correspondre étroitement au mot mal orthographié « relevés » dans la requête « états financiers de fin d'année ».
Le correcteur orthographique renvoie les mots prévus ou corrigés qui remplacent les mots mal orthographiés dans le texte de la requête d'origine. Par exemple, « déployer la recherche Kendre » peut renvoyer « déployer la recherche Kendra ». Vous pouvez également utiliser les emplacements de décalage fournis dans l'API pour surligner ou mettre en italique les mots corrigés renvoyés dans une requête de votre application frontale. Dans la console, les mots corrigés sont surlignés ou en italique par défaut. Par exemple, « *déployer la recherche* *Kendra* ».
Pour les termes spécifiques à une entreprise ou spécialisés qui apparaissent dans vos documents indexés, le correcteur orthographique ne les interprète pas à tort comme des fautes d'orthographe dans la requête. Par exemple, « Amazon Macie » n'est pas remplacé par « Amazon Mace ».
Pour les mots comportant un trait d'union, tels que « fin d'année », le correcteur orthographique les traite comme des mots individuels afin de suggérer des corrections pour ces mots. Par exemple, la correction suggérée pour « fin d'année » pourrait être « fin d'année ».
Pour les types de réponses aux `QUESTION_ANSWER` requêtes `DOCUMENT` et aux requêtes, le correcteur orthographique suggère de corriger les mots mal orthographiés en fonction des mots présents dans le corps du document. Le corps du document est plus fiable que le titre pour suggérer des corrections correspondant étroitement aux mots mal orthographiés. Pour les types de réponses aux `ANSWER` requêtes, le correcteur orthographique suggère des corrections basées sur les mots figurant dans le document de questions-réponses par défaut de votre index.
Vous pouvez activer le correcteur orthographique à l'aide de l'[SpellCorrectionConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_SpellCorrectionConfiguration.html)objet. Vous avez réglé `IncludeQuerySpellCheckSuggestions` sur`TRUE`. Le correcteur orthographique est activé par défaut dans la console. Il est intégré à la console par défaut.
Le correcteur orthographique peut également suggérer des corrections orthographiques pour les requêtes dans plusieurs langues, pas seulement en anglais. Pour obtenir la liste des langues prises en charge par le correcteur orthographique, consultez la section [Langues Amazon Kendra prises en charge](https://docs.aws.amazon.com/kendra/latest/dg/in-adding-languages.html).
## Utilisation du correcteur orthographique des requêtes avec des limites par défaut
Le correcteur orthographique est conçu avec certaines valeurs par défaut ou limites. Voici une liste des limites actuelles qui s'appliquent lorsque vous activez les suggestions de correction orthographique.
+ Les corrections orthographiques suggérées ne peuvent pas être renvoyées pour les mots de moins de trois caractères ou de plus de 30 caractères. Pour autoriser plus de 30 caractères ou moins de trois caractères, contactez le [Support](https://aws.amazon.com/contact-us/).
+ Les corrections orthographiques suggérées ne peuvent pas restreindre les suggestions basées sur le contrôle d'accès des utilisateurs ou sur votre liste de contrôle d'accès pour [le filtrage du contexte utilisateur](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html). Les corrections orthographiques sont basées sur tous les mots de vos documents indexés, qu'ils soient réservés à certains utilisateurs ou non. Si vous souhaitez éviter que certains mots apparaissent dans les corrections orthographiques suggérées pour les requêtes, n'activez pas`SpellCorrectionConfiguration`.
+ Les corrections orthographiques suggérées ne peuvent pas être renvoyées pour les mots contenant des chiffres. Par exemple, « how 2 not br8k ubun2 ».
+ Les corrections orthographiques suggérées ne peuvent pas utiliser de mots qui n'apparaissent pas dans vos documents indexés.
+ Les corrections orthographiques suggérées ne peuvent pas utiliser de mots qui sont fréquentés à moins de 0,01 % dans vos documents indexés. Pour modifier le seuil de 0,01 %, contactez le [Support](https://aws.amazon.com/contact-us/).
# Filtrage et recherche par facettes
**Note**
La prise en charge des fonctionnalités varie en fonction du type d'index et de l'API de recherche utilisés. Pour savoir si cette fonctionnalité est prise en charge pour le type d'index et l'API de recherche que vous utilisez, consultez la section [Types d'index](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Vous pouvez améliorer les résultats de recherche ou les réponses de l'API [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) en utilisant des filtres. Les filtres limitent les documents de la réponse à ceux qui s'appliquent directement à la requête. Pour créer des suggestions de recherche à facettes, utilisez la logique booléenne pour filtrer les attributs de document spécifiques de la réponse ou les documents qui ne correspondent pas à des critères spécifiques. Vous pouvez spécifier des facettes à l'aide du `Facets` paramètre de l'`Query`API.
Pour rechercher des documents que vous avez indexés avec Amazon Kendra for Amazon Lex, utilisez [AMAZON. KendraSearchIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_KendraConfiguration.html). Pour un exemple de configuration Amazon Kendra avec Amazon Lex, voir [Création d'un bot FAQ pour un Amazon Kendra index](https://docs.aws.amazon.com/lexv2/latest/dg/faq-bot-kendra-search.html). Vous pouvez également fournir un filtre pour la réponse en utilisant [AttributeFilter](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeFilter.html). Il s'agit du filtre de requête en JSON lors de la configuration`AMAZON.KendraSearchIntent`. Pour fournir un filtre d'attributs lors de la configuration d'une intention de recherche dans la console, accédez à l'éditeur d'intention et choisissez Amazon Kendra query pour fournir un filtre de requête au format JSON. Pour plus d'informations`AMAZON.KendraSearchIntent`, consultez le [guide de Amazon Lex documentation](https://docs.aws.amazon.com/lexv2/latest/dg/built-in-intent-kendra-search.html).
## Facettes
Les facettes sont des vues étendues d'un ensemble de résultats de recherche. Par exemple, vous pouvez fournir des résultats de recherche pour des villes du monde entier, où les documents sont filtrés en fonction de la ville à laquelle ils sont associés. Vous pouvez également créer des facettes pour afficher les résultats d'un auteur spécifique.
Vous pouvez utiliser un attribut de document ou un champ de métadonnées associé à un document en tant que facette afin que vos utilisateurs puissent effectuer une recherche par catégorie ou par valeur au sein de cette facette. Vous pouvez également afficher des facettes imbriquées dans les résultats de recherche afin que vos utilisateurs puissent effectuer une recherche non seulement par catégorie ou par champ, mais également par sous-catégorie ou sous-champ.
L'exemple suivant montre comment obtenir des informations facettaires pour l'attribut personnalisé « Ville ».
```
response=kendra.query(
QueryText = query,
IndexId = index,
Facets = [
{
"DocumentAttributeKey" : "City"
}
]
)
```
Vous pouvez utiliser des facettes imbriquées pour affiner davantage la recherche. Par exemple, l'attribut ou la facette « Ville » du document inclut une valeur appelée « Seattle ». En outre, l'attribut ou la facette du document « CityRegion » inclut les valeurs « Nord » et « Sud » pour les documents affectés à « Seattle ». Vous pouvez afficher les facettes imbriquées avec leur nombre dans les résultats de recherche afin que les documents puissent être recherchés non seulement par ville, mais également par région au sein d'une ville.
Notez que les facettes imbriquées peuvent avoir un impact sur la latence des requêtes. En règle générale, plus vous utilisez de facettes imbriquées, plus l'impact potentiel sur la latence est important. Parmi les autres facteurs qui influent sur la latence, citons la taille moyenne des documents indexés, la taille de votre index, les requêtes très complexes et la charge globale de votre Amazon Kendra index.
L'exemple suivant montre comment obtenir des informations de facette pour l'attribut personnalisé « CityRegion », sous forme de facette imbriquée dans « City ».
```
response=kendra.query(
QueryText = query,
IndexId = index,
Facets = [
{
"DocumentAttributeKey" : "City",
"Facets": [
{
"DocumentAttributeKey" : "CityRegion"
}
]
}
]
)
```
Les informations relatives aux facettes, telles que le nombre de documents, sont renvoyées dans le tableau de `FacetResults` réponses. Vous utilisez le contenu pour afficher des suggestions de recherche à facettes dans votre application. Par exemple, si l'attribut « Ville » du document contient la ville à laquelle une recherche pourrait s'appliquer, utilisez ces informations pour afficher une liste des villes recherchées. Les utilisateurs peuvent choisir une ville pour filtrer leurs résultats de recherche. Pour effectuer la recherche à facettes, appelez l'API [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) et utilisez l'attribut de document choisi pour filtrer les résultats.
Vous pouvez afficher jusqu'à 10 valeurs de facette par facette pour une requête, et une seule facette imbriquée par facette. Si vous souhaitez augmenter ces limites, contactez le [Support](https://aws.amazon.com/contact-us/). Si vous souhaitez limiter le nombre de valeurs de facette par facette à moins de 10, vous pouvez le spécifier dans l'`Facet`objet.
L'exemple de réponse JSON suivant montre les facettes dont la portée est limitée à l'attribut de document « Ville ». La réponse inclut le nombre de documents pour la valeur de facette.
```
{
'FacetResults': [
{
'DocumentAttributeKey': 'City',
'DocumentAttributeValueCountPairs': [
{
'Count': 3,
'DocumentAttributeValue': {
'StringValue': 'Dubai'
}
},
{
'Count': 3,
'DocumentAttributeValue': {
'StringValue': 'Seattle'
}
},
{
'Count': 1,
'DocumentAttributeValue': {
'StringValue': 'Paris'
}
}
]
}
]
```
Vous pouvez également afficher les informations relatives à une facette imbriquée, telle qu'une région au sein d'une ville, afin de filtrer davantage les résultats de recherche.
L'exemple de réponse JSON suivant montre les facettes limitées à l'attribut de document « CityRegion », sous la forme d'une facette imbriquée dans « City ». La réponse inclut le nombre de documents pour les valeurs de facettes imbriquées.
```
{
'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'
}
}
]
}
]
}
}
]
}
```
Lorsque vous utilisez un champ de liste de chaînes pour créer des facettes, les résultats des facettes renvoyés sont basés sur le contenu de la liste de chaînes. Par exemple, si vous avez un champ de liste de chaînes contenant deux éléments, l'un avec la liste « teckel », « saucisson » et l'autre avec la valeur « husky », vous obtenez `FacetResults` trois facettes.
Pour de plus amples informations, veuillez consulter [Réponses aux requêtes et types de réponses](query-responses-types.md).
## Utilisation des attributs du document pour filtrer les résultats de recherche
Par défaut, `Query` renvoie tous les résultats de recherche. Pour filtrer les réponses, vous pouvez effectuer des opérations logiques sur les attributs du document. Par exemple, si vous souhaitez uniquement des documents pour une ville spécifique, vous pouvez filtrer selon les attributs de document personnalisés « Ville » et « État ». Vous pouvez l'utiliser [AttributeFilter](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeFilter.html)pour créer une opération booléenne sur les filtres que vous fournissez.
La plupart des attributs peuvent être utilisés pour filtrer les réponses pour tous les [types de réponses](https://docs.aws.amazon.com/kendra/latest/dg/query-responses-types.html). Toutefois, l'`_excerpt_page_number`attribut ne s'applique qu'aux types de `ANSWER` réponses lors du filtrage des réponses.
L'exemple suivant montre comment effectuer une opération logique AND en filtrant sur une ville spécifique, *Seattle*, et sur l'État, *Washington*.
```
response=kendra.query(
QueryText = query,
IndexId = index,
AttributeFilter = {'AndAllFilters':
[
{"EqualsTo": {"Key": "City","Value": {"StringValue": "Seattle"}}},
{"EqualsTo": {"Key": "State","Value": {"StringValue": "Washington"}}}
]
}
)
```
L'exemple suivant montre comment effectuer une opération logique OR lorsque l'une des `SourceURI` touches `Fileformat``Author`, ou correspond aux valeurs spécifiées.
```
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"}}}
]
}
)
```
Pour `StringList` les champs, utilisez les filtres `ContainsAll` d'attributs `ContainsAny` ou pour renvoyer les documents contenant la chaîne spécifiée. L'exemple suivant montre comment renvoyer tous les documents dont l'attribut `Locations` personnalisé contient les valeurs « Seattle » ou « Portland ».
```
response=kendra.query(
QueryText = query,
IndexId = index,
AttributeFilter = {
"ContainsAny": { "Key": "Locations", "Value": { "StringListValue": [ "Seattle", "Portland"] }}
}
)
```
## Filtrer les attributs de chaque document dans les résultats de recherche
Amazon Kendra renvoie les attributs de document pour chaque document figurant dans les résultats de recherche. Vous pouvez filtrer certains attributs de document que vous souhaitez inclure dans la réponse dans les résultats de recherche. Par défaut, tous les attributs de document assignés à un document sont renvoyés dans la réponse.
Dans l'exemple suivant, seuls les attributs `_source_uri` et du `_author` document sont inclus dans la réponse d'un document.
```
response=kendra.query(
QueryText = query,
IndexId = index,
RequestedDocumentAttributes = ["_source_uri", "_author"]
)
```
# Filtrage sur le contexte utilisateur
**Note**
La prise en charge des fonctionnalités varie en fonction du type d'index et de l'API de recherche utilisés. Pour savoir si cette fonctionnalité est prise en charge pour le type d'index et l'API de recherche que vous utilisez, consultez la section [Types d'index](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Vous pouvez filtrer les résultats de recherche d'un utilisateur en fonction de l'accès de celui-ci ou de son groupe aux documents. Vous pouvez utiliser un jeton utilisateur, un ID utilisateur ou un attribut utilisateur pour filtrer les documents.
Le filtrage du contexte utilisateur est une sorte de recherche personnalisée qui a l'avantage de contrôler l'accès aux documents. Par exemple, les équipes qui recherchent des informations sur le portail de l'entreprise ne doivent pas toutes accéder aux documents top secrets de l'entreprise, et ces documents ne sont pas pertinents pour tous les utilisateurs. Seuls des utilisateurs ou des groupes d'équipes spécifiques ayant accès à des documents top secrets devraient voir ces documents dans leurs résultats de recherche.
Lorsqu'un document est indexé dans Amazon Kendra, une liste de contrôle d'accès (ACL) correspondante est ingérée pour la plupart des documents. L'ACL indique les noms d'utilisateur et de groupe auxquels l'accès au document est autorisé ou refusé. Les documents sans ACL sont des documents publics.
Amazon Kendra peut extraire les informations d'utilisateur ou de groupe associées à chaque document pour la plupart des sources de données. Par exemple, un document dans Quip peut inclure une liste « partagée » de certains utilisateurs autorisés à accéder au document. Si vous utilisez un compartiment S3 comme source de données, vous fournissez un [fichier JSON](https://docs.aws.amazon.com/kendra/latest/dg/s3-acl.html) pour votre ACL et vous incluez le chemin S3 vers ce fichier dans le cadre de la configuration de la source de données. Si vous ajoutez des documents directement à un index, vous spécifiez l'ACL dans l'objet [Principal](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Principal.html) en tant que partie intégrante de l'objet document dans l'[BatchPutDocument](https://docs.aws.amazon.com/kendra/latest/APIReference/API_BatchPutDocument.html)API.
Si vous utilisez un index Amazon Kendra Enterprise ou Developer Edition, vous pouvez utiliser l'[CreateAccessControlConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateAccessControlConfiguration.html)API pour reconfigurer le contrôle d'accès au niveau des documents existant sans devoir indexer à nouveau tous vos documents. Par exemple, votre index contient des documents d'entreprise top secrets auxquels seuls certains employés ou utilisateurs peuvent accéder. L'un de ces utilisateurs quitte l'entreprise ou rejoint une équipe qui devrait être empêchée d'accéder à des documents top secrets. L'utilisateur a toujours accès aux documents top secrets car il y avait accès lors de l'indexation précédente de vos documents. Vous pouvez créer une configuration de contrôle d'accès spécifique pour l'utilisateur en lui refusant l'accès. Vous pouvez ultérieurement mettre à jour la configuration du contrôle d'accès pour autoriser l'accès au cas où l'utilisateur reviendrait dans l'entreprise et rejoindrait l'équipe « top-secrète ». Vous pouvez reconfigurer le contrôle d'accès à vos documents en fonction de l'évolution des circonstances.
Pour appliquer votre configuration de contrôle d'accès à certains documents, vous appelez l'[BatchPutDocument](https://docs.aws.amazon.com/kendra/latest/APIReference/API_BatchPutDocument.html)API avec l'objet `AccessControlConfigurationId` inclus dans le [document](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Document.html). Si vous utilisez un compartiment S3 comme source de données, vous le mettez à jour `.metadata.json` avec la source de données `AccessControlConfigurationId` et vous le synchronisez. Amazon Kendra ne prend actuellement en charge que la configuration du contrôle d'accès pour les sources de données S3 et les documents indexés à l'aide de l'`BatchPutDocument`API.
## Filtrage par jeton utilisateur
**Important**
Les indices Amazon Kendra GenAI Enterprise Edition ne prennent pas en charge le contrôle d'accès utilisateur basé sur des jetons.
Lorsque vous interrogez un index, vous pouvez utiliser un jeton utilisateur pour filtrer les résultats de recherche en fonction de l'accès de l'utilisateur ou de son groupe aux documents. Lorsque vous émettez une requête, Amazon Kendra extrayez et validez le jeton, extrayez et vérifiez les informations relatives à l'utilisateur et au groupe, puis exécutez la requête. Tous les documents auxquels l'utilisateur a accès, y compris les documents publics, sont renvoyés. Pour plus d'informations, consultez la section Contrôle d'[accès utilisateur basé sur des jetons](https://docs.aws.amazon.com/kendra/latest/dg/create-index-access-control.html).
Vous fournissez le jeton utilisateur dans l'[UserContext](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UserContext.html)objet et vous le transmettez à l'API [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html).
Ce qui suit montre comment inclure un jeton utilisateur.
```
response = kendra.query(
QueryText = query,
IndexId = index,
UserToken = {
Token = "token"
})
```
Vous pouvez associer des utilisateurs à des groupes. Lorsque vous utilisez le filtrage du contexte utilisateur, il n'est pas nécessaire d'inclure tous les groupes auxquels appartient un utilisateur lorsque vous émettez la requête. Avec l'[PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API, vous pouvez associer les utilisateurs à leurs groupes. Si vous ne souhaitez pas utiliser l'`PutPrincipalMapping`API, vous devez fournir le nom d'utilisateur et tous les groupes auxquels il appartient lorsque vous émettez une requête. Vous pouvez également récupérer les niveaux d'accès des groupes et des utilisateurs dans votre source d'identité IAM Identity Center à l'aide de l'[UserGroupResolutionConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UserGroupResolutionConfiguration.html)objet.
## Filtrage par nom d'utilisateur et par groupe
Lorsque vous interrogez un index, vous pouvez utiliser l'ID utilisateur et le groupe pour filtrer les résultats de recherche en fonction de l'accès de l'utilisateur ou de son groupe aux documents. Lorsque vous émettez une requête, Amazon Kendra vérifie les informations relatives à l'utilisateur et au groupe et exécute la requête. Tous les documents relatifs à la requête auxquels l'utilisateur a accès, y compris les documents publics, sont renvoyés.
Vous pouvez également filtrer les résultats de recherche en fonction des sources de données auxquelles les utilisateurs et les groupes ont accès. La spécification d'une source de données est utile si un groupe est lié à plusieurs sources de données, mais que vous souhaitez uniquement que le groupe accède aux documents d'une certaine source de données. Par exemple, les groupes « Recherche », « Ingénierie » et « Ventes et marketing » sont tous liés aux documents de l'entreprise stockés dans les sources de données Confluence et Salesforce. Toutefois, l'équipe « Ventes et marketing » n'a besoin d'accéder qu'aux documents relatifs aux clients stockés dans Salesforce. Ainsi, lorsque les utilisateurs des ventes et du marketing recherchent des documents relatifs aux clients, ils peuvent voir les documents de Salesforce dans leurs résultats. Les utilisateurs qui ne travaillent pas dans le domaine des ventes et du marketing ne voient pas les documents Salesforce dans leurs résultats de recherche.
Vous fournissez les informations relatives aux utilisateurs, aux groupes et aux sources de données dans l'[UserContext](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UserContext.html)objet et vous les transmettez à l'API [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html). L'ID utilisateur et la liste des groupes et des sources de données doivent correspondre au nom que vous spécifiez dans l'objet [Principal](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Principal.html) pour identifier l'utilisateur, les groupes et les sources de données. Avec `Principal` cet objet, vous pouvez ajouter un utilisateur, un groupe ou une source de données à une liste d'autorisation ou de refus d'accès à un document.
Vous devez fournir l'un des éléments suivants :
+ Informations sur les utilisateurs et les groupes, et informations (facultatives) sur les sources de données.
+ Uniquement les informations utilisateur si vous mappez vos utilisateurs à des groupes et à des sources de données à l'aide de l'[PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API. Vous pouvez également récupérer les niveaux d'accès des groupes et des utilisateurs dans votre source d'identité IAM Identity Center à l'aide de l'[UserGroupResolutionConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UserGroupResolutionConfiguration.html)objet.
Si ces informations ne sont pas incluses dans la requête, Amazon Kendra renvoie tous les documents. Si vous fournissez ces informations, seuls les documents avec des utilisateurs IDs, des groupes et des sources de données correspondants sont renvoyés.
Ce qui suit montre comment inclure l'ID utilisateur, les groupes et les sources de données.
```
response = kendra.query(
QueryText = query,
IndexId = index,
UserContext={'Token': 'string', 'UserId': 'string', 'Groups': [ 'string', ], 'DataSourceGroups': [ { 'GroupId': 'string', 'DataSourceId': 'string' }, ] },)
```
## Filtrage par attribut utilisateur
Lorsque vous interrogez un index, vous pouvez utiliser des attributs intégrés `_user_id` et filtrer `_group_id` les résultats de recherche en fonction de l'accès de l'utilisateur et de son groupe aux documents. Vous pouvez configurer jusqu'à 100 identifiants de groupe. Lorsque vous émettez une requête, Amazon Kendra vérifie les informations relatives à l'utilisateur et au groupe et exécute la requête. Tous les documents relatifs à la requête auxquels l'utilisateur a accès, y compris les documents publics, sont renvoyés.
Vous fournissez les attributs d'utilisateur et de groupe dans l'[AttributeFilter](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeFilter.html)objet et vous les transmettez à l'API [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html).
L'exemple suivant montre une demande qui filtre la réponse à la requête en fonction de l'ID utilisateur et des groupes « HR » et « IT » auxquels appartient l'utilisateur. La requête renverra tout document dont l'utilisateur ou les groupes « RH » ou « IT » figurent dans la liste des documents autorisés. Si l'utilisateur ou l'un des groupes figure dans la liste de refus d'un document, le document n'est pas renvoyé.
```
response = kendra.query(
QueryText = query,
IndexId = index,
AttributeFilter = {
"OrAllFilters": [
{
"EqualsTo": {
"Key": "_user_id",
"Value": {
"StringValue": "user1"
}
}
},
{
"EqualsTo": {
"Key": "_group_ids",
"Value": {
"StringListValue": ["HR", "IT"]
}
}
}
]
}
)
```
Vous pouvez également spécifier à quelle source de données un groupe peut accéder dans l'`Principal`objet.
**Note**
Le filtrage du contexte utilisateur n'est pas un contrôle d'authentification ou d'autorisation pour votre contenu. Il n'authentifie pas l'utilisateur et les groupes envoyés à l'`Query`API. Il appartient à votre application de s'assurer que les informations relatives aux utilisateurs et aux groupes envoyées à `Query` l'API sont authentifiées et autorisées.
Il existe une implémentation du filtrage du contexte utilisateur pour chaque source de données. La section suivante décrit chaque implémentation.
**Topics**
+ [Filtrage par jeton utilisateur](#context-filter-token)
+ [Filtrage par nom d'utilisateur et par groupe](#context-filter-user-incl-datasources)
+ [Filtrage par attribut utilisateur](#context-filter-attribute)
+ [Filtrage du contexte utilisateur pour les documents ajoutés directement à un index](#context-filter-batch)
+ [Filtrage du contexte utilisateur pour les questions fréquemment posées](#context-filter-faq)
+ [Filtrage du contexte utilisateur pour les sources de données](#datasource-context-filter)
## Filtrage du contexte utilisateur pour les documents ajoutés directement à un index
Lorsque vous ajoutez des documents directement à un index à l'aide de l'[BatchPutDocument](https://docs.aws.amazon.com/kendra/latest/APIReference/API_BatchPutDocument.html)API, les informations relatives aux utilisateurs et aux groupes sont Amazon Kendra extraites du `AccessControlList` champ du document. Vous fournissez une liste de contrôle d'accès (ACL) pour vos documents et l'ACL est ingérée avec vos documents.
Vous spécifiez l'ACL dans l'objet [Principal](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Principal.html) dans le cadre de l'objet [Document](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Document.html) de l'`BatchPutDocument`API. Vous fournissez les informations suivantes :
+ L'accès que l'utilisateur ou le groupe doit avoir. Tu peux dire `ALLOW` ou`DENY`.
+ Le type de l’entité. Tu peux dire `USER` ou`GROUP`.
+ Nom de l'utilisateur ou du groupe.
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
## Filtrage du contexte utilisateur pour les questions fréquemment posées
Lorsque vous [ajoutez une FAQ](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateFaq.html) à un index, Amazon Kendra vous obtenez des informations sur les utilisateurs et les groupes à partir `AccessControlList` object/field du fichier JSON de la FAQ. Vous pouvez également utiliser un fichier CSV de FAQ avec des champs ou des attributs personnalisés pour le contrôle d'accès.
Vous fournissez les informations suivantes :
+ L'accès que l'utilisateur ou le groupe doit avoir. Tu peux dire `ALLOW` ou`DENY`.
+ Le type de l’entité. Tu peux dire `USER` ou`GROUP`.
+ Nom de l'utilisateur ou du groupe.
Pour plus d'informations, consultez les [fichiers de FAQ](https://docs.aws.amazon.com/kendra/latest/dg/in-creating-faq.html).
## Filtrage du contexte utilisateur pour les sources de données
Amazon Kendra analyse également les informations des listes de contrôle d'accès (ACL) des utilisateurs et des groupes à partir des connecteurs de source de données pris en charge. Cela est utile pour le filtrage du contexte utilisateur, où les résultats de recherche sont filtrés en fonction de l'accès de l'utilisateur ou de son groupe aux documents.
**Important**
Les indices Amazon Kendra GenAI Enterprise Edition ne prennent en charge que les connecteurs de source de données Amazon Kendra v2.0.
**Topics**
+ [Filtrage du contexte utilisateur pour les sources de données Adobe Experience Manager](#context-filter-aem)
+ [Filtrage du contexte utilisateur pour les sources de données Alfresco](#context-filter-alfresco)
+ [Filtrage du contexte utilisateur pour les sources de données Aurora (MySQL)](#context-filter-aurora-mysql)
+ [Filtrage du contexte utilisateur pour les Aurora sources de données (PostgreSQL)](#context-filter-aurora-postgresql)
+ [Filtrage du contexte utilisateur pour les sources Amazon FSx de données](#context-filter-fsx)
+ [Filtrage du contexte utilisateur pour les sources de données de base de données](#context-filter-jdbc)
+ [Filtrage du contexte utilisateur pour les sources de données Amazon RDS (Microsoft SQL Server)](#context-filter-rds-ms-sql-server)
+ [Filtrage du contexte utilisateur pour les sources de données Amazon RDS (MySQL)](#context-filter-rds-mysql)
+ [Filtrage du contexte utilisateur pour les sources de données Amazon RDS (Oracle)](#context-filter-rds-oracle)
+ [Filtrage du contexte utilisateur pour les Amazon RDS sources de données (PostgreSQL)](#context-filter-rds-postgresql)
+ [Filtrage du contexte utilisateur pour les sources Amazon S3 de données](#context-filter-s3)
+ [Filtrage du contexte utilisateur pour les sources de données Box](#context-filter-box)
+ [Filtrage du contexte utilisateur pour les sources de données Confluence](#context-filter-confluence)
+ [Filtrage du contexte utilisateur pour les sources de données Dropbox](#context-filter-dropbox)
+ [Filtrage du contexte utilisateur pour les sources de données Drupal](#context-filter-drupal)
+ [Filtrage du contexte utilisateur pour les sources GitHub de données](#context-filter-github)
+ [Filtrage du contexte utilisateur pour les sources de données Gmail](#context-filter-gmail)
+ [Filtrage du contexte utilisateur pour les sources de données Google Drive](#context-filter-google)
+ [Filtrage du contexte utilisateur pour les sources DB2 de données IBM](#context-filter-ibm-db2)
+ [Filtrage du contexte utilisateur pour les sources de données Jira](#context-filter-jira)
+ [Filtrage du contexte utilisateur pour les sources de données Microsoft Exchange](#context-filter-exchange)
+ [Filtrage du contexte utilisateur pour les sources OneDrive de données Microsoft](#context-filter-onedrive)
+ [Filtrage du contexte utilisateur pour les sources de données Microsoft OneDrive v2.0](#context-filter-onedrivev2)
+ [Filtrage du contexte utilisateur pour les sources SharePoint de données Microsoft](#context-filter-sharepoint-online)
+ [Filtrage du contexte utilisateur pour les sources de données Microsoft SQL Server](#context-filter-ms-sql-server)
+ [Filtrage du contexte utilisateur pour les sources de données Microsoft Teams](#context-filter-teams)
+ [Filtrage du contexte utilisateur pour les sources de données Microsoft Yammer](#context-filter-yammer)
+ [Filtrage du contexte utilisateur pour les sources de données MySQL](#context-filter-mysql)
+ [Filtrage du contexte utilisateur pour les sources de données Oracle Database](#context-filter-oracle-database)
+ [Filtrage du contexte utilisateur pour les sources de données PostgreSQL](#context-filter-postgresql)
+ [Filtrage du contexte utilisateur pour les sources de données Quip](#context-filter-quip)
+ [Filtrage du contexte utilisateur pour les sources de données Salesforce](#context-filter-salesforce)
+ [Filtrage du contexte utilisateur pour les sources ServiceNow de données](#context-filter-servicenow)
+ [Filtrage du contexte utilisateur pour les sources de données Slack](#context-filter-slack)
+ [Filtrage du contexte utilisateur pour les sources de données Zendesk](#context-filter-zendesk)
### Filtrage du contexte utilisateur pour les sources de données Adobe Experience Manager
Lorsque vous utilisez une source de données Adobe Experience Manager, vous obtenez les Amazon Kendra informations relatives aux utilisateurs et aux groupes à partir de l'instance d'Adobe Experience Manager.
Le groupe et l'utilisateur IDs sont mappés comme suit :
+ `_group_ids`—Les groupes IDs existent dans le contenu d'Adobe Experience Manager pour lesquels des autorisations d'accès sont définies. Ils sont mappés à partir des noms des groupes dans Adobe Experience Manager.
+ `_user_id`—L'utilisateur IDs existe dans le contenu d'Adobe Experience Manager pour lequel des autorisations d'accès sont définies. Ils sont mappés à partir des e-mails des utilisateurs, comme IDs dans Adobe Experience Manager.
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources de données Alfresco
Lorsque vous utilisez une source de données Alfresco, Amazon Kendra elle obtient les informations relatives aux utilisateurs et aux groupes à partir de l'instance Alfresco.
Le groupe et l'utilisateur IDs sont mappés comme suit :
+ `_group_ids`—Les groupes IDs existent dans Alfresco sur les fichiers pour lesquels des autorisations d'accès sont définies. Ils sont mappés à partir des noms système des groupes (et non des noms d'affichage) dans Alfresco.
+ `_user_id`—Les utilisateurs IDs existent dans Alfresco sur les fichiers pour lesquels des autorisations d'accès sont définies. Ils sont mappés à partir des e-mails des utilisateurs comme IDs dans Alfresco.
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources de données Aurora (MySQL)
Lorsque vous utilisez une source de données Aurora (MySQL), les informations relatives aux utilisateurs et aux groupes sont Amazon Kendra extraites d'une colonne de la table source. Vous spécifiez cette colonne dans la console ou en utilisant l'[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objet dans le cadre de l'[CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Une source de données de base de données Aurora (MySQL) présente les limites suivantes :
+ Vous pouvez uniquement spécifier une liste d’autorisations pour une source de données de la base de données. Vous ne pouvez pas spécifier de liste de refus.
+ Vous ne pouvez spécifier que des groupes. Vous ne pouvez pas spécifier d’utilisateurs individuels pour la liste d’autorisations.
+ La colonne de base de données doit être une chaîne contenant une liste de groupes délimitée par des points-virgules.
### Filtrage du contexte utilisateur pour les Aurora sources de données (PostgreSQL)
Lorsque vous utilisez une source de données Aurora (PostgreSQL) Amazon Kendra , les informations relatives aux utilisateurs et aux groupes sont extraites d'une colonne de la table source. Vous spécifiez cette colonne dans la console ou en utilisant l'[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objet dans le cadre de l'[CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Une source de données de base de données Aurora (PostgreSQL) présente les limites suivantes :
+ Vous pouvez uniquement spécifier une liste d’autorisations pour une source de données de la base de données. Vous ne pouvez pas spécifier de liste de refus.
+ Vous ne pouvez spécifier que des groupes. Vous ne pouvez pas spécifier d’utilisateurs individuels pour la liste d’autorisations.
+ La colonne de base de données doit être une chaîne contenant une liste de groupes délimitée par des points-virgules.
### Filtrage du contexte utilisateur pour les sources Amazon FSx de données
Lorsque vous utilisez une source de Amazon FSx données, Amazon Kendra elle obtient des informations sur les utilisateurs et les groupes à partir du service d'annuaire de l' Amazon FSx instance.
Le Amazon FSx groupe et l'utilisateur IDs sont mappés comme suit :
+ `_group_ids`—Le groupe IDs existe dans Amazon FSx les fichiers pour lesquels des autorisations d'accès sont définies. Ils sont mappés à partir des noms de groupes de systèmes dans le service d'annuaire de Amazon FSx.
+ `_user_id`—L'utilisateur IDs existe dans Amazon FSx les fichiers pour lesquels des autorisations d'accès sont définies. Ils sont mappés à partir des noms d'utilisateur du système dans le service d'annuaire de Amazon FSx.
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources de données de base de données
Lorsque vous utilisez une source de données de base de données, telle que Amazon Aurora PostgreSQL, Amazon Kendra obtient des informations sur les utilisateurs et les groupes à partir d'une colonne de la table source. Vous spécifiez cette colonne dans l'[AclConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AclConfiguration.html)objet en tant que partie intégrante de l'[DatabaseConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DatabaseConfiguration.html)objet dans l'[CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Une source de données de base de données présente les limitations suivantes :
+ Vous pouvez uniquement spécifier une liste d’autorisations pour une source de données de la base de données. Vous ne pouvez pas spécifier de liste de refus.
+ Vous ne pouvez spécifier que des groupes. Vous ne pouvez pas spécifier d’utilisateurs individuels pour la liste d’autorisations.
+ La colonne de base de données doit être une chaîne contenant une liste de groupes délimitée par des points-virgules.
### Filtrage du contexte utilisateur pour les sources de données Amazon RDS (Microsoft SQL Server)
Lorsque vous utilisez une source de données Amazon RDS (Microsoft SQL Server), les informations relatives aux utilisateurs et aux groupes sont Amazon Kendra extraites d'une colonne de la table source. Vous spécifiez cette colonne dans la console ou en utilisant l'[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objet dans le cadre de l'[CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Une source de données de base de données Amazon RDS (Microsoft SQL Server) présente les limites suivantes :
+ Vous pouvez uniquement spécifier une liste d’autorisations pour une source de données de la base de données. Vous ne pouvez pas spécifier de liste de refus.
+ Vous ne pouvez spécifier que des groupes. Vous ne pouvez pas spécifier d’utilisateurs individuels pour la liste d’autorisations.
+ La colonne de base de données doit être une chaîne contenant une liste de groupes délimitée par des points-virgules.
### Filtrage du contexte utilisateur pour les sources de données Amazon RDS (MySQL)
Lorsque vous utilisez une source de données Amazon RDS (MySQL), les informations relatives aux utilisateurs et aux groupes sont Amazon Kendra extraites d'une colonne de la table source. Vous spécifiez cette colonne dans la console ou en utilisant l'[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objet dans le cadre de l'[CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Une source de données de base de données Amazon RDS (MySQL) présente les limites suivantes :
+ Vous pouvez uniquement spécifier une liste d’autorisations pour une source de données de la base de données. Vous ne pouvez pas spécifier de liste de refus.
+ Vous ne pouvez spécifier que des groupes. Vous ne pouvez pas spécifier d’utilisateurs individuels pour la liste d’autorisations.
+ La colonne de base de données doit être une chaîne contenant une liste de groupes délimitée par des points-virgules.
### Filtrage du contexte utilisateur pour les sources de données Amazon RDS (Oracle)
Lorsque vous utilisez une source de données Amazon RDS (Oracle), les informations relatives aux utilisateurs et aux groupes sont Amazon Kendra extraites d'une colonne de la table source. Vous spécifiez cette colonne dans la console ou en utilisant l'[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objet dans le cadre de l'[CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Une source de données de base de données Amazon RDS (Oracle) présente les limites suivantes :
+ Vous pouvez uniquement spécifier une liste d’autorisations pour une source de données de la base de données. Vous ne pouvez pas spécifier de liste de refus.
+ Vous ne pouvez spécifier que des groupes. Vous ne pouvez pas spécifier d’utilisateurs individuels pour la liste d’autorisations.
+ La colonne de base de données doit être une chaîne contenant une liste de groupes délimitée par des points-virgules.
### Filtrage du contexte utilisateur pour les Amazon RDS sources de données (PostgreSQL)
Lorsque vous utilisez une source de données Amazon RDS (PostgreSQL) Amazon Kendra , les informations relatives aux utilisateurs et aux groupes sont extraites d'une colonne de la table source. Vous spécifiez cette colonne dans la console ou en utilisant l'[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objet dans le cadre de l'[CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Une source de données de base de données Amazon RDS (PostgreSQL) présente les limites suivantes :
+ Vous pouvez uniquement spécifier une liste d’autorisations pour une source de données de la base de données. Vous ne pouvez pas spécifier de liste de refus.
+ Vous ne pouvez spécifier que des groupes. Vous ne pouvez pas spécifier d’utilisateurs individuels pour la liste d’autorisations.
+ La colonne de base de données doit être une chaîne contenant une liste de groupes délimitée par des points-virgules.
### Filtrage du contexte utilisateur pour les sources Amazon S3 de données
Vous ajoutez un filtrage contextuel utilisateur à un document dans une source de Amazon S3 données à l'aide d'un fichier de métadonnées associé au document. Vous ajoutez les informations dans le `AccessControlList` champ du document JSON. Pour plus d'informations sur l'ajout de métadonnées aux documents indexés à partir d'une source de Amazon S3 données, consultez la section [Métadonnées des documents S3](https://docs.aws.amazon.com/kendra/latest/dg/s3-metadata.html).
Vous fournissez trois informations :
+ L’accès que l’entité devrait avoir. Tu peux dire `ALLOW` ou`DENY`.
+ Le type de l’entité. Tu peux dire `USER` ou`GROUP`.
+ Le nom de l’entité.
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources de données Box
Lorsque vous utilisez une source de données Box, Amazon Kendra vous obtenez des informations sur les utilisateurs et les groupes à partir de l'instance Box.
Le groupe Box et l'utilisateur IDs sont mappés comme suit :
+ `_group_ids`—Le groupe IDs existe dans Box sur les fichiers pour lesquels des autorisations d'accès sont définies. Ils sont mappés à partir des noms des groupes dans Box.
+ `_user_id`—L'utilisateur IDs existe dans Box sur les fichiers pour lesquels des autorisations d'accès sont définies. Ils sont mappés à partir des e-mails de l'utilisateur en tant qu'utilisateur IDs dans Box.
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources de données Confluence
Lorsque vous utilisez une source de données Confluence, Amazon Kendra elle obtient des informations sur les utilisateurs et les groupes à partir de l'instance Confluence.
Vous configurez l’accès des utilisateurs et des groupes aux espaces à l’aide de la page des autorisations d’espace. Pour les pages et les blogs, utilisez la page des restrictions. Pour plus d’informations sur les autorisations d’espace, consultez [Vue d’ensemble des autorisations d’espace](https://confluence.atlassian.com/doc/space-permissions-overview-139521.html) sur le site Web d’assistance de Confluence. Pour plus d’informations sur les restrictions relatives aux pages et aux blogs, consultez [Restrictions relatives aux pages](https://confluence.atlassian.com/doc/page-restrictions-139414.html) sur le site Web d’assistance de Confluence.
Le groupe Confluence et les noms d'utilisateur sont mappés comme suit :
+ `_group_ids`—Les noms de groupes sont présents sur les espaces, les pages et les blogs soumis à des restrictions. Ils sont mappés à partir du nom du groupe dans Confluence. Les noms de groupes sont toujours en minuscules.
+ `_user_id`—Les noms d'utilisateur sont présents sur l'espace, la page ou le blog soumis à des restrictions. Ils sont mappés en fonction du type d'instance Confluence que vous utilisez.
**Pour connecteur Confluence v1.0**
+ Serveur : il `_user_id` s'agit du nom d'utilisateur. Le nom d'utilisateur est toujours en minuscules.
+ Cloud : il `_user_id` s'agit de l'ID de compte de l'utilisateur.
**Pour connecteur Confluence v2.0**
+ Serveur : il `_user_id` s'agit du nom d'utilisateur. Le nom d'utilisateur est toujours en minuscules.
+ Cloud : il `_user_id` s'agit de l'identifiant e-mail de l'utilisateur.
**Important**
**Pour que le filtrage du contexte utilisateur fonctionne correctement pour votre connecteur Confluence, vous devez vous assurer que la visibilité d'un utilisateur autorisé à accéder à une page Confluence est définie sur Tout le monde.** Pour plus d’informations, consultez [Configurer la visibilité de vos e-mails](https://support.atlassian.com/confluence-cloud/docs/configure-user-email-visibility/) dans la documentation Atlassian destinée aux développeurs.
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources de données Dropbox
Lorsque vous utilisez une source de données Dropbox, les informations relatives aux utilisateurs et aux groupes sont Amazon Kendra extraites de l'instance Dropbox.
Le groupe et l'utilisateur IDs sont mappés comme suit :
+ `_group_ids`—Les groupes IDs existent dans Dropbox sur les fichiers pour lesquels des autorisations d'accès sont définies. Ils sont mappés à partir des noms des groupes dans Dropbox.
+ `_user_id`—L'utilisateur IDs existe dans Dropbox sur les fichiers pour lesquels des autorisations d'accès sont définies. Ils sont mappés à partir des e-mails des utilisateurs, comme IDs dans Dropbox.
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources de données Drupal
Lorsque vous utilisez une source de données Drupal, Amazon Kendra elle obtient les informations de l'utilisateur et du groupe à partir de l'instance Drupal.
Le groupe et l'utilisateur IDs sont mappés comme suit :
+ `_group_ids`— Les groupes IDs existent dans Drupal sur les fichiers pour lesquels des autorisations d'accès sont définies. Ils sont mappés à partir des noms des groupes dans Drupal.
+ `_user_id`— L'utilisateur IDs existe dans Drupal sur les fichiers pour lesquels des autorisations d'accès sont définies. Ils sont mappés à partir des e-mails des utilisateurs comme IDs dans Drupal.
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources GitHub de données
Lorsque vous utilisez une source de GitHub données, Amazon Kendra obtient les informations utilisateur de l' GitHub instance.
Les GitHub utilisateurs IDs sont mappés comme suit :
+ `_user_id`—L'utilisateur IDs existe dans GitHub les fichiers pour lesquels des autorisations d'accès sont définies. Ils sont mappés à partir des e-mails des utilisateurs sous forme d'entrée IDs . GitHub
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources de données Gmail
Lorsque vous utilisez une source de données Gmail, Amazon Kendra obtient les informations utilisateur de l'instance Gmail.
Les utilisateurs IDs sont mappés comme suit :
+ `_user_id`— L'utilisateur IDs existe dans Gmail sur les fichiers pour lesquels des autorisations d'accès sont définies. Ils sont mappés à partir des e-mails des utilisateurs comme IDs dans Gmail.
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources de données Google Drive
Une source de données Google Workspace Drive renvoie des informations sur les utilisateurs et les groupes relatifs aux utilisateurs et aux groupes de Google Drive. L'appartenance au groupe et au domaine est mappée au champ d'`_group_ids`index. Le nom d'utilisateur Google Drive est associé au `_user_id` champ.
Lorsque vous fournissez une ou plusieurs adresses e-mail utilisateur dans l'`Query`API, seuls les documents partagés avec ces adresses e-mail sont renvoyés. Le `AttributeFilter` paramètre suivant renvoie uniquement les documents partagés avec "martha@example.com ».
```
"AttributeFilter": {
"EqualsTo":{
"Key": "_user_id",
"Value": {
"StringValue": "martha@example.com"
}
}
}
```
Si vous fournissez une ou plusieurs adresses e-mail de groupe dans la requête, seuls les documents partagés avec les groupes sont renvoyés. Le `AttributeFilter` paramètre suivant renvoie uniquement les documents partagés avec le groupe « hr@example.com ».
```
"AttributeFilter": {
"EqualsTo":{
"Key": "_group_ids",
"Value": {
"StringListValue": ["hr@example.com"]
}
}
}
```
Si vous indiquez le domaine dans la requête, tous les documents partagés avec le domaine sont renvoyés. Le `AttributeFilter` paramètre suivant renvoie les documents partagés avec le domaine « exemple.com ».
```
"AttributeFilter": {
"EqualsTo":{
"Key": "_group_ids",
"Value": {
"StringListValue": ["example.com"]
}
}
}
```
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources DB2 de données IBM
Lorsque vous utilisez une source de DB2 données IBM, vous obtenez Amazon Kendra des informations sur les utilisateurs et les groupes à partir d'une colonne de la table source. Vous spécifiez cette colonne dans la console ou en utilisant l'[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objet dans le cadre de l'[CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Une source DB2 de données de base de données IBM présente les limites suivantes :
+ Vous pouvez uniquement spécifier une liste d’autorisations pour une source de données de la base de données. Vous ne pouvez pas spécifier de liste de refus.
+ Vous ne pouvez spécifier que des groupes. Vous ne pouvez pas spécifier d’utilisateurs individuels pour la liste d’autorisations.
+ La colonne de base de données doit être une chaîne contenant une liste de groupes délimitée par des points-virgules.
### Filtrage du contexte utilisateur pour les sources de données Jira
Lorsque vous utilisez une source de données Jira, Amazon Kendra elle obtient des informations sur les utilisateurs et les groupes à partir de l'instance Jira.
Les utilisateurs Jira IDs sont mappés comme suit :
+ `_user_id`—L'utilisateur IDs existe dans Jira sur les fichiers pour lesquels des autorisations d'accès sont définies. Ils sont mappés à partir des e-mails de l'utilisateur en tant qu'utilisateur IDs dans Jira.
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources de données Microsoft Exchange
Lorsque vous utilisez une source de données Microsoft Exchange, Amazon Kendra obtient les informations utilisateur de l'instance Microsoft Exchange.
Les utilisateurs Microsoft Exchange IDs sont mappés comme suit :
+ `_user_id`—L'utilisateur IDs existe dans Microsoft Exchange des autorisations lui permettant d'accéder à certains contenus. Ils sont mappés à partir des noms d'utilisateur comme IDs dans Microsoft Exchange.
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources OneDrive de données Microsoft
Amazon Kendra récupère les informations relatives aux utilisateurs et aux groupes auprès de Microsoft OneDrive lorsqu'il indexe les documents du site. Les informations relatives aux utilisateurs et aux groupes sont extraites du SharePoint site Microsoft sous-jacent qui les héberge OneDrive.
Lorsque vous utilisez un OneDrive utilisateur ou un groupe pour filtrer les résultats de recherche, calculez l'ID comme suit :
1. Obtenez le nom du site. Par exemple, `https://host.onmicrosoft.com/sites/siteName.`
1. Prenez le MD5 hachage du nom du site. Par exemple, `430a6b90503eef95c89295c8999c7981`.
1. Créez l'adresse e-mail ou l'identifiant de groupe de l'utilisateur en concaténant le MD5 hachage avec une barre verticale (\$1) et l'identifiant. Par exemple, si le nom d'un groupe est localGroupName « », l'ID du groupe serait :
`"430a6b90503eef95c89295c8999c7981 | localGroupName"`
**Note**
Incluez un espace avant et après la barre verticale. La barre verticale est utilisée pour s'identifier `localGroupName` avec son MD5 hachage.
Pour le nom d'utilisateur « someone@host.onmicrosoft.com », l'ID utilisateur serait le suivant :
`"430a6b90503eef95c89295c8999c7981 | someone@host.onmicrosoft.com"`
Envoyez l'ID d'utilisateur ou de groupe Amazon Kendra sous forme d'`_group_id`attribut `_user_id` or lorsque vous appelez l'API [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html). Par exemple, la AWS CLI commande qui utilise un groupe pour filtrer les résultats de recherche ressemble à ceci :
```
aws kendra query \
--index-id index ID
--query-text "query text"
--attribute-filter '{
"EqualsTo":{
"Key": "_group_id",
"Value": {"StringValue": "430a6b90503eef95c89295c8999c7981 | localGroupName"}
}}'
```
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources de données Microsoft OneDrive v2.0
Une source de données Microsoft OneDrive v2.0 renvoie des informations de section et de page à partir d'entités de liste de contrôle d' OneDrive accès (ACL). Amazon Kendra utilise le domaine du OneDrive locataire pour se connecter à l' OneDrive instance, puis peut filtrer les résultats de recherche en fonction de l'accès des utilisateurs ou des groupes aux sections et aux noms de fichiers.
Pour les objets standard, les `_user_id` et `_group_id` sont utilisés comme suit :
+ `_user_id`— Votre adresse e-mail OneDrive utilisateur Microsoft est mappée `_user_id` sur le champ.
+ `_group_id`— L'e-mail de votre OneDrive groupe Microsoft est mappé `_group_id` sur le champ.
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources SharePoint de données Microsoft
Amazon Kendra récupère les informations relatives aux utilisateurs et aux groupes auprès de Microsoft SharePoint lorsqu'il indexe les documents du site. Pour filtrer les résultats de recherche en fonction de l'accès des utilisateurs ou des groupes, fournissez des informations sur les utilisateurs et les groupes lorsque vous appelez l'`Query`API.
Pour filtrer à l'aide d'un nom d'utilisateur, utilisez son adresse e-mail. Par exemple, johnstiles@example.com.
Lorsque vous utilisez un SharePoint groupe pour filtrer les résultats de recherche, calculez l'ID du groupe comme suit :
**Pour les groupes locaux**
1. Obtenez le nom du site. Par exemple, `https://host.onmicrosoft.com/sites/siteName.`
1. Prenez le SHA256 hachage du nom du site. Par exemple, `430a6b90503eef95c89295c8999c7981`.
1. Créez l'ID du groupe en concaténant le SHA256 hachage avec une barre verticale (\$1) et le nom du groupe. Par exemple, si le nom du groupe est localGroupName « », l'ID du groupe serait :
`"430a6b90503eef95c89295c8999c7981 | localGroupName"`
**Note**
Incluez un espace avant et après la barre verticale. La barre verticale est utilisée pour s'identifier `localGroupName` avec son SHA256 hachage.
Envoyez l'ID de groupe en Amazon Kendra tant qu'`_group_id`attribut lorsque vous appelez l'[API Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html). Par exemple, la AWS CLI commande ressemble à ceci :
```
aws kendra query \
--index-id index ID
--query-text "query text"
--attribute-filter '{
"EqualsTo":{
"Key": "_group_id",
"Value": {"StringValue": "430a6b90503eef95c89295c8999c7981 | localGroupName"}
}}'
```
**Pour les groupes AD**
1. Utilisez l'ID du groupe AD pour configurer le filtrage des résultats de recherche.
Envoyez l'ID de groupe en Amazon Kendra tant qu'`_group_id`attribut lorsque vous appelez l'API [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html). Par exemple, la AWS CLI commande ressemble à ceci :
```
aws kendra query \
--index-id index ID
--query-text "query text"
--attribute-filter '{
"EqualsTo":{
"Key": "_group_id",
"Value": {"StringValue": "AD group"}
}}'
```
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources de données Microsoft SQL Server
Lorsque vous utilisez une source de données Microsoft SQL Server, les informations relatives aux utilisateurs et aux groupes sont Amazon Kendra extraites d'une colonne de la table source. Vous spécifiez cette colonne dans la console ou en utilisant l'[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objet dans le cadre de l'[CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Une source de données de base de données Microsoft SQL Server présente les limites suivantes :
+ Vous pouvez uniquement spécifier une liste d’autorisations pour une source de données de la base de données. Vous ne pouvez pas spécifier de liste de refus.
+ Vous ne pouvez spécifier que des groupes. Vous ne pouvez pas spécifier d’utilisateurs individuels pour la liste d’autorisations.
+ La colonne de base de données doit être une chaîne contenant une liste de groupes délimitée par des points-virgules.
### Filtrage du contexte utilisateur pour les sources de données Microsoft Teams
Amazon Kendra récupère les informations utilisateur de Microsoft Teams lorsqu'il indexe les documents. Les informations utilisateur sont extraites de l'instance Microsoft Teams sous-jacente.
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources de données Microsoft Yammer
Amazon Kendra récupère les informations utilisateur de Microsoft Yammer lorsqu'il indexe les documents. Les informations relatives à l'utilisateur et au groupe sont extraites de l'instance Microsoft Yammer sous-jacente.
Les utilisateurs de Microsoft Yammer IDs sont mappés comme suit :
+ `_email_id`— L'adresse e-mail Microsoft mappée au `_user_id` champ.
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources de données MySQL
Lorsque vous utilisez une source de données MySQL, les informations relatives aux utilisateurs et aux groupes sont Amazon Kendra extraites d'une colonne de la table source. Vous spécifiez cette colonne dans la console ou en utilisant l'[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objet dans le cadre de l'[CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Une source de données de base de données MySQL présente les limites suivantes :
+ Vous pouvez uniquement spécifier une liste d’autorisations pour une source de données de la base de données. Vous ne pouvez pas spécifier de liste de refus.
+ Vous ne pouvez spécifier que des groupes. Vous ne pouvez pas spécifier d’utilisateurs individuels pour la liste d’autorisations.
+ La colonne de base de données doit être une chaîne contenant une liste de groupes délimitée par des points-virgules.
### Filtrage du contexte utilisateur pour les sources de données Oracle Database
Lorsque vous utilisez une source de données Oracle Database, les informations relatives aux utilisateurs et aux groupes sont Amazon Kendra extraites d'une colonne de la table source. Vous spécifiez cette colonne dans la console ou en utilisant l'[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objet dans le cadre de l'[CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Une source de données de base de données Oracle Database présente les limites suivantes :
+ Vous pouvez uniquement spécifier une liste d’autorisations pour une source de données de la base de données. Vous ne pouvez pas spécifier de liste de refus.
+ Vous ne pouvez spécifier que des groupes. Vous ne pouvez pas spécifier d’utilisateurs individuels pour la liste d’autorisations.
+ La colonne de base de données doit être une chaîne contenant une liste de groupes délimitée par des points-virgules.
### Filtrage du contexte utilisateur pour les sources de données PostgreSQL
Lorsque vous utilisez une source de données PostgreSQL Amazon Kendra , les informations relatives aux utilisateurs et aux groupes sont extraites d'une colonne de la table source. Vous spécifiez cette colonne dans la console ou en utilisant l'[TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objet dans le cadre de l'[CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Une source de données de base de données PostgreSQL présente les limites suivantes :
+ Vous pouvez uniquement spécifier une liste d’autorisations pour une source de données de la base de données. Vous ne pouvez pas spécifier de liste de refus.
+ Vous ne pouvez spécifier que des groupes. Vous ne pouvez pas spécifier d’utilisateurs individuels pour la liste d’autorisations.
+ La colonne de base de données doit être une chaîne contenant une liste de groupes délimitée par des points-virgules.
### Filtrage du contexte utilisateur pour les sources de données Quip
Lorsque vous utilisez une source de données Quip, Amazon Kendra elle obtient les informations utilisateur de l'instance Quip.
Les utilisateurs de Quip IDs sont mappés comme suit :
+ `_user_id`—L'utilisateur IDs existe dans Quip sur les fichiers pour lesquels des autorisations d'accès sont définies. Ils sont mappés à partir des e-mails des utilisateurs, comme IDs dans Quip.
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources de données Salesforce
Une source de données Salesforce renvoie des informations sur les utilisateurs et les groupes à partir des entités de la liste de contrôle d'accès (ACL) Salesforce. Vous pouvez appliquer le filtrage du contexte utilisateur aux objets standard et aux flux de discussion Salesforce. Le filtrage du contexte utilisateur n'est pas disponible pour les articles de connaissances de Salesforce.
Si vous associez un champ Salesforce aux champs du titre et du corps du document Amazon Kendra, Amazon Kendra utilisera les données du titre et des champs du corps du document dans les réponses de recherche.
Pour les objets standard, les `_user_id` et `_group_ids` sont utilisés comme suit :
+ `_user_id`: le nom d'utilisateur de l'utilisateur Salesforce.
+ `_group_ids`—
+ Nom de la Salesforce `Profile`
+ Nom de la Salesforce `Group`
+ Nom de la Salesforce `UserRole`
+ Nom de la Salesforce `PermissionSet`
Pour les fils de discussion, les `_user_id` et `_group_ids` sont utilisés comme suit :
+ `_user_id`: le nom d'utilisateur de l'utilisateur Salesforce. Disponible uniquement si l’article est publié dans le fil de l’utilisateur.
+ `_group_ids` IDs —Les groupes sont utilisés comme suit. Disponible uniquement si l’élément du fil est publié dans un groupe de membres de la discussion ou de collaboration.
+ Nom du groupe de membres de la discussion ou de collaboration.
+ Si le groupe est public, `PUBLIC:ALL`.
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources ServiceNow de données
Le filtrage du contexte utilisateur pour n' ServiceNow est pris en charge que pour l' TemplateConfiguration API et le ServiceNow Connector v2.0. ServiceNowConfiguration L'API et le ServiceNow connecteur v1.0 ne prennent pas en charge le filtrage du contexte utilisateur.
Lorsque vous utilisez une source de ServiceNow données, Amazon Kendra elle obtient les informations relatives aux utilisateurs et aux groupes à partir de l' ServiceNow instance.
Le groupe et l'utilisateur IDs sont mappés comme suit :
+ `_group_ids`—Le groupe IDs existe dans ServiceNow les fichiers pour lesquels des autorisations d'accès sont définies. Ils sont mappés à partir des noms de rôles de `sys_ids` in ServiceNow.
+ `_user_id`—L'utilisateur IDs existe dans ServiceNow les fichiers pour lesquels des autorisations d'accès sont définies. Ils sont mappés à partir des e-mails des utilisateurs sous forme d'entrée IDs . ServiceNow
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources de données Slack
Lorsque vous utilisez une source de données Slack, Amazon Kendra elle obtient les informations utilisateur de l'instance Slack.
Les utilisateurs de Slack IDs sont mappés comme suit :
+ `_user_id`—L'utilisateur IDs existe dans Slack sur les messages et les chaînes pour lesquels des autorisations d'accès sont définies. Ils sont mappés à partir des e-mails des utilisateurs, comme IDs dans Slack.
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
### Filtrage du contexte utilisateur pour les sources de données Zendesk
Lorsque vous utilisez une source de données Zendesk, Amazon Kendra elle obtient les informations de l'utilisateur et du groupe à partir de l'instance Zendesk.
Le groupe et l'utilisateur IDs sont mappés comme suit :
+ `_group_ids`—Les groupes IDs existent dans les tickets et les articles Zendesk pour lesquels des autorisations d'accès sont définies. Ils sont mappés à partir des noms des groupes dans Zendesk.
+ `_user_id`—Les groupes IDs existent dans les tickets et les articles Zendesk pour lesquels des autorisations d'accès sont définies. Ils sont mappés à partir des e-mails des utilisateurs, comme IDs dans Zendesk.
Vous pouvez ajouter jusqu'à 200 entrées dans le `AccessControlList` champ.
# Réponses aux requêtes et types de réponses
**Note**
La prise en charge des fonctionnalités varie en fonction du type d'index et de l'API de recherche utilisés. Pour savoir si cette fonctionnalité est prise en charge pour le type d'index et l'API de recherche que vous utilisez, consultez la section [Types d'index](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Amazon Kendra prend en charge différentes réponses aux requêtes et types de réponses.
## Réponses aux requêtes
Un appel à l'API [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) renvoie des informations sur les résultats d'une recherche. Les résultats se trouvent dans un tableau d'[QueryResultItem](https://docs.aws.amazon.com/kendra/latest/APIReference/API_QueryResultItem.html)objets (`ResultItems`). Chacune `QueryResultItem` inclut un résumé du résultat. Les attributs de document associés au résultat de la requête sont inclus.
**Informations récapitulatives**
Les informations récapitulatives varient en fonction du type de résultat. Dans chaque cas, il inclut le texte du document qui correspond au terme de recherche. Il inclut également des informations de surlignage que vous pouvez utiliser pour surligner le texte de recherche dans le résultat de votre application. Par exemple, si le terme de recherche est *quelle est la hauteur de la Space Needle ?* , les informations récapitulatives incluent l'emplacement du texte pour les mots *hauteur* et *aiguille spatiale*. Pour plus d'informations sur les types de réponse, consultez[Réponses aux requêtes et types de réponses](#query-responses-types).
**Attributs de document**
Chaque résultat contient les attributs du document correspondant à une requête. Certains attributs sont prédéfinis, tels que `DocumentId``DocumentTitle`, et`DocumentUri`. Les autres sont des attributs personnalisés que vous définissez. Vous pouvez utiliser les attributs du document pour filtrer la réponse de l'`Query`API. Par exemple, il se peut que vous souhaitiez uniquement les documents rédigés par un auteur spécifique ou une version spécifique d'un document. Pour de plus amples informations, veuillez consulter [Filtrage et recherche par facettes](filtering.md). Vous spécifiez les attributs du document lorsque vous ajoutez des documents à un index. Pour plus d'informations, consultez la section [Champs ou attributs personnalisés](https://docs.aws.amazon.com/kendra/latest/dg/custom-attributes.html).
Voici un exemple de code JSON pour le résultat d'une requête. Notez les attributs du document dans `DocumentAttributes` et`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
}
```
## Types de réponses
Amazon Kendra renvoie trois types de réponses à une requête.
+ Réponse (inclut la réponse sous forme de tableau)
+ Document
+ Question/réponse
Le type de réponse est renvoyé dans le champ de `Type` réponse de l'[QueryResultItem](https://docs.aws.amazon.com/kendra/latest/APIReference/API_QueryResultItem.html)objet.
### Réponse
Amazon Kendra a détecté une ou plusieurs réponses à une question dans la réponse. Un factoïde est la réponse à une question qui, quoi, quand ou où, telle que *Où se trouve le centre de service le plus proche de chez moi ?* Amazon Kendra renvoie le texte dans l'index qui correspond le mieux à la requête. Le texte se trouve dans le `AnswerText` champ et contient des informations surlignées pour le terme de recherche dans le texte de réponse. `AnswerText`inclut l'extrait complet du document avec le texte surligné, tandis qu'`DocumentExcerpt`inclut l'extrait tronqué (290 caractères) avec le texte surligné.
Amazon Kendra ne renvoie qu'une seule réponse par document, et c'est la réponse la plus fiable. Pour renvoyer plusieurs réponses à partir d'un document, vous devez diviser le document en plusieurs documents.
```
{
'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'
}
```
### Document
Amazon Kendra renvoie les documents classés pour ceux qui correspondent au terme de recherche. Le classement est basé sur la confiance accordée Amazon Kendra à l'exactitude des résultats de recherche. Les informations relatives au document correspondant sont renvoyées dans le [QueryResultItem](https://docs.aws.amazon.com/kendra/latest/APIReference/API_QueryResultItem.html). Il inclut le titre du document. L'extrait inclut des informations de surlignage pour le texte de recherche et la section du texte correspondant dans le document. L'URI pour les documents correspondants se trouve dans l'attribut `SourceURI` document. L'exemple de code JSON suivant montre le résumé d'un document correspondant.
```
{
'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'
}
```
### Question/réponse
Une réponse aux questions et réponses est renvoyée lorsqu'une question Amazon Kendra correspond à l'une des questions fréquemment posées de votre index. La réponse inclut la question et la réponse correspondantes dans le [QueryResultItem](https://docs.aws.amazon.com/kendra/latest/APIReference/API_QueryResultItem.html)champ. Il inclut également des informations de surlignage pour les termes de requête détectés dans la chaîne de requête. Le JSON suivant montre une réponse à une question et à une réponse. Notez que la réponse inclut le texte de la question.
```
{
'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?'
}
}
```
Pour plus d'informations sur l'ajout de texte de question et de réponse à un index, consultez la section [Création d'une FAQ](https://docs.aws.amazon.com/kendra/latest/dg/in-creating-faq.html).
# Réglage et tri des réponses
**Note**
La prise en charge des fonctionnalités varie en fonction du type d'index et de l'API de recherche utilisés. Pour savoir si cette fonctionnalité est prise en charge pour le type d'index et l'API de recherche que vous utilisez, consultez la section [Types d'index](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Vous pouvez modifier l'effet d'un champ ou d'un attribut sur la pertinence de la recherche en ajustant la pertinence. Vous pouvez également trier les résultats de recherche en fonction d'un attribut ou d'un champ spécifique.
**Topics**
+ [Réglage des réponses](#tuning-responses)
+ [Tri des réponses](#sorting-responses)
## Réglage des réponses
Vous pouvez modifier l'effet d'un champ ou d'un attribut sur la pertinence de la recherche en ajustant la pertinence. Pour tester rapidement le réglage de la pertinence, utilisez l'API [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) pour transmettre les configurations de réglage dans la requête. Ensuite, vous pouvez voir les différents résultats de recherche que vous obtenez à partir de différentes configurations. Le réglage de la pertinence au niveau de la requête n'est pas pris en charge dans la console. Vous pouvez également régler des champs ou des attributs du type défini uniquement `StringList` au niveau de l'index. Pour plus d'informations, consultez la section [Optimisation de la pertinence de la recherche](https://docs.aws.amazon.com/kendra/latest/dg/tuning.html).
Par défaut, les réponses aux requêtes sont triées selon le score de pertinence qui Amazon Kendra détermine chaque résultat de la réponse.
Vous pouvez ajuster les résultats pour n'importe quel type intégré ou personnalisé attribute/field des types suivants :
+ Valeur de date
+ Valeur longue
+ Valeur de chaîne
Vous ne pouvez pas trier les attributs du type suivant :
+ Valeurs de la liste de chaînes
**Classement et optimisation des résultats des documents (AWS SDK)**
Définissez le `Searchable` paramètre sur true pour améliorer la configuration des métadonnées du document.
Pour régler un attribut dans une requête, définissez le `DocumentRelevanceOverrideConfigurations` paramètre de l'`Query`API et spécifiez le nom de l'attribut à régler.
L'exemple JSON suivant montre un `DocumentRelevanceOverrideConfigurations` objet qui remplace le réglage de l'attribut appelé « department » dans l'index.
```
"DocumentRelevanceOverrideConfigurations" : [
"Name": "department",
"Relevance": {
"Importance": 1,
"ValueImportanceMap": {
"IT": 3,
"HR": 7
}
}
]
```
## Tri des réponses
Amazon Kendra utilise l'attribut ou le champ de tri dans le cadre des critères pour les documents renvoyés par la requête. Par exemple, les résultats renvoyés par une requête triée par « \$1created\$1at » peuvent ne pas contenir les mêmes résultats qu'une requête triée par « \$1version ».
Par défaut, les réponses aux requêtes sont triées selon le score de pertinence qui Amazon Kendra détermine chaque résultat de la réponse. Pour modifier l'ordre de tri, rendez un attribut de document triable, puis configurez Amazon Kendra pour utiliser cet attribut pour trier les réponses.
Vous pouvez trier les résultats selon n'importe quel type intégré ou personnalisé attribute/field des types suivants :
+ Valeur de date
+ Valeur longue
+ Valeur de chaîne
Vous ne pouvez pas trier les attributs du type suivant :
+ Valeurs de la liste de chaînes
Vous pouvez trier selon un ou plusieurs attributs de document dans chaque requête. Les requêtes renvoient 100 résultats. Si l'attribut de tri est défini dans moins de 100 documents, les documents sans valeur pour l'attribut de tri sont renvoyés à la fin des résultats, triés en fonction de leur pertinence par rapport à la requête.
**Pour trier les résultats d'un document (AWS SDK)**
1. Pour utiliser l'[UpdateIndex](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateIndex.html)API afin de rendre un attribut triable, définissez le `Sortable` paramètre sur. `true` L'exemple JSON suivant permet `DocumentMetadataConfigurationUpdates` d'ajouter un attribut appelé « Department » à l'index et de le rendre triable.
```
"DocumentMetadataConfigurationUpdates": [
{
"Name": "Department",
"Type": "STRING_VALUE",
"Search": {
"Sortable": "true"
}
}
]
```
1. Pour utiliser un attribut triable dans une requête, définissez le `SortingConfiguration` paramètre de l'API [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html). Spécifiez le nom de l'attribut à trier et indiquez si vous souhaitez trier la réponse par ordre croissant ou décroissant.
L'exemple JSON suivant montre le `SortingConfiguration` paramètre que vous utilisez pour trier les résultats d'une requête par l'attribut « Department » dans l'ordre croissant.
```
"SortingConfiguration": {
"DocumentAttributeKey": "Department",
"SortOrder": "ASC"
}
```
1. Pour utiliser plusieurs attributs triables dans une requête, définissez le `SortingConfigurations` paramètre de l'API [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html). Vous pouvez définir jusqu'à 3 champs sur lesquels les résultats Amazon Kendra doivent être triés. Vous pouvez également spécifier si les résultats doivent être triés par ordre croissant ou décroissant. Le quota de champs de tri peut être augmenté.
Si vous ne fournissez pas de configuration de tri, les résultats sont triés selon la pertinence qui Amazon Kendra détermine le résultat. En cas d'égalité dans le tri des résultats, les résultats sont triés par pertinence.
L'exemple JSON suivant montre le `SortingConfigurations` paramètre que vous utilisez pour trier les résultats d'une requête par les attributs « Nom » et « Prix » par ordre croissant.
```
"CollapseConfiguration" : {
"DocumentAttributeKey": "Name",
"SortingConfigurations": [
{
"DocumentAttributeKey": "Price",
"SortOrder": "ASC"
}
],
"MissingAttributeKeyStrategy": "IGNORE"
}
```
**Pour trier les résultats d'un document (console)**
**Note**
Le tri multi-attributs n'est actuellement pas pris en charge par le AWS Management Console.
1. Pour qu'un attribut puisse être trié dans la console, choisissez **Sortable** dans la définition de l'attribut. Vous pouvez rendre un attribut triable lorsque vous le créez, ou vous pouvez le modifier ultérieurement.
1. Pour trier une réponse à une requête dans la console, choisissez l'attribut pour trier la réponse dans le menu **Trier**. Seuls les attributs marqués comme triables lors de la configuration de la source de données apparaissent dans la liste.
# Réduction/extension des résultats de requête
**Note**
La prise en charge des fonctionnalités varie en fonction du type d'index et de l'API de recherche utilisés. Pour savoir si cette fonctionnalité est prise en charge pour le type d'index et l'API de recherche que vous utilisez, consultez la section [Types d'index](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Lorsque vous vous connectez Amazon Kendra à vos données, il explore les [attributs des métadonnées des documents](https://docs.aws.amazon.com/kendra/latest/dg/hiw-document-attributes.html) (tels que `_document_title``_created_at`, et) et utilise `_document_id` ces attributs ou champs pour fournir des fonctionnalités de recherche avancées au moment des requêtes.
Amazon Kendra La fonctionnalité Réduire et développer les résultats de requête vous permet de regrouper les résultats de recherche à l'aide d'un attribut de document commun et de les afficher (réduits ou partiellement développés) sous un document principal désigné.
**Note**
La fonctionnalité de réduction et d'extension des résultats de requête n'est actuellement disponible que via l'[Amazon Kendra API](https://docs.aws.amazon.com/kendra/latest/APIReference/welcome.html).
Cela est utile dans les situations de recherche suivantes :
+ Plusieurs versions du contenu existent dans les documents de votre index. Lorsque votre utilisateur final interroge l'index, vous souhaitez qu'il voie la version la plus pertinente du document contenant des doublonshidden/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.
![\[Exemple 1\]](http://docs.aws.amazon.com/fr_fr/kendra/latest/dg/images/expand-collapse-1.png)
+ Votre index contient plusieurs documents contenant des informations uniques sur un type d'article ou d'objet, comme un inventaire de produits, par exemple. Pour saisir et trier facilement les informations sur les articles, vous souhaitez que les utilisateurs finaux accèdent à tous les documents liés par un élément ou un objet sous la forme d'un seul résultat de recherche. Dans l'exemple ci-dessous, une recherche effectuée par un client sur « chemises à imprimé animalier » renvoie des résultats groupés par nom et triés par ordre de prix croissant.
![\[Exemple 2\]](http://docs.aws.amazon.com/fr_fr/kendra/latest/dg/images/expand-collapse-2.png)
## Réduction des résultats
Pour regrouper des documents similaires ou connexes, vous devez spécifier l'attribut sur lequel vous souhaitez réduire (par exemple, vous pouvez créer collapse/group des documents par`_category`). Pour ce faire, appelez l'[API Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) et utilisez l'[CollapseConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CollapseConfiguration.html)objet pour spécifier l'objet `DocumentAttributeKey` à réduire. Les `DocumentAttributeKey` commandes sur lesquelles les résultats de recherche de champs seront réduits. Les champs clés d'attribut pris en charge incluent `String` et`Number`. `String list`et le `Date` type ne sont pas pris en charge.
## Choix d'un document principal par ordre de tri
Pour configurer le document principal à afficher pour un groupe réduit, utilisez le `SortingConfigurations` paramètre ci-dessous [CollapseConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CollapseConfiguration.html). Par exemple, pour obtenir la version la plus récente d'un document, vous devez trier chaque groupe réduit par`_version`. Vous pouvez spécifier jusqu' attributes/fields à 3 critères de tri et un ordre de tri pour chaque attribute/field utilisation`SortingConfigurations`. Vous pouvez demander une augmentation du quota pour le nombre d'attributs de tri.
Par défaut, Amazon Kendra trie les réponses aux requêtes en fonction du score de pertinence qu'il détermine pour chaque résultat de la réponse. Pour modifier l'ordre de tri par défaut, rendez les attributs du document triables, puis configurez Amazon Kendra pour utiliser ces attributs pour trier les réponses. Pour plus d'informations, consultez la section [Tri des réponses](https://docs.aws.amazon.com/kendra/latest/dg/tuning-sorting-responses.html#sorting-responses).
## Stratégie clé en matière de documents manquants
Si votre document ne possède pas de valeur d'attribut de réduction, il Amazon Kendra propose trois options de personnalisation :
+ Choisissez d'inclure `COLLAPSE` tous les documents contenant des valeurs nulles ou manquantes dans un seul groupe. Il s'agit de la configuration par défaut.
+ Choisissez les `IGNORE` documents dont les valeurs sont nulles ou manquantes. Les documents ignorés n'apparaîtront pas dans les résultats de la requête.
+ Choisissez de `EXPAND` placer chaque document contenant une valeur nulle ou manquante dans un groupe distinct.
## Élargir les résultats
Vous pouvez choisir d'étendre les groupes de résultats de recherche réduits en utilisant le `Expand` paramètre de l'[CollapseConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CollapseConfiguration.html)objet. Les résultats étendus conservent le même ordre de tri que celui utilisé pour sélectionner le document principal du groupe.
Pour configurer le nombre de groupes de résultats de recherche réduits à développer, vous utilisez le `MaxResultItemstoExpand` paramètre de l'[ExpandConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_ExpandConfiguration.html)objet. Si vous définissez cette valeur sur 10, par exemple, seuls les 10 premiers groupes de résultats sur 100 bénéficieront de fonctionnalités étendues.
Pour configurer le nombre de résultats étendus à afficher par document principal réduit, utilisez le `MaxExpandResultsPerItem` paramètre. Par exemple, si vous définissez cette valeur sur 3, au maximum 3 résultats par groupe réduit seront affichés.
## Interactions avec d'autres Amazon Kendra fonctionnalités
+ La réduction et l'extension des résultats ne modifient pas le nombre de facettes et n'ont aucune incidence sur le nombre total de résultats affichés.
+ Amazon Kendra les [résultats de recherche présentés](https://docs.aws.amazon.com/kendra/latest/dg/featured-results.html) ne seront pas réduits même s'ils ont la même valeur de champ que le champ de réduction que vous configurez.
+ La réduction et l'extension des résultats ne s'appliquent qu'aux résultats de type`DOCUMENT`.