Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Búsqueda en un índice
**nota**
La compatibilidad de características varía según el tipo de índice y la API de búsqueda que se use. Para comprobar si esta característica es compatible con el tipo de índice y la API de búsqueda que usa, consulte [Tipos de índices](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Para buscar un Amazon Kendra índice, se utiliza la API de [consultas](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html). La API `Query` devuelve información sobre los documentos indexados que utiliza en su aplicación. En esta sección se muestra cómo realizar una consulta, aplicar filtros e interpretar la respuesta que obtiene de la API `Query`.
Para buscar documentos con Amazon Kendra los que ha indexado Amazon Lex, utilice [AMAZON. KendraSearchIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_KendraConfiguration.html). Para ver un ejemplo de configuración Amazon Kendra con Amazon Lex, consulte [Creación de un bot de preguntas frecuentes para un Amazon Kendra índice](https://docs.aws.amazon.com/lexv2/latest/dg/faq-bot-kendra-search.html).
**Topics**
+ [Consulta de un índice](searching-example.md)
+ [Recuperación de pasajes](searching-retrieve.md)
+ [Navegar por un índice](browsing.md)
+ [Destacar resultados de búsqueda](featured-results.md)
+ [Búsqueda tabular de HTML](searching-tables.md)
+ [Sugerencias de consulta](query-suggestions.md)
+ [Corrector ortográfico de las consultas](query-spell-check.md)
+ [Filtrado y búsqueda por facetas](filtering.md)
+ [Filtrar por contexto de usuario](user-context-filter.md)
+ [Respuestas a las consultas y tipos de respuestas](query-responses-types.md)
+ [Ajustar y ordenar las respuestas](tuning-sorting-responses.md)
+ [Contraer o expandir los resultados de la consulta](expand-collapse-query-results.md)
# Consulta de un índice
**nota**
La compatibilidad de características varía según el tipo de índice y la API de búsqueda que se use. Para comprobar si esta característica es compatible con el tipo de índice y la API de búsqueda que usa, consulte [Tipos de índices](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Cuando busca en su índice, Amazon Kendra utiliza toda la información que ha proporcionado sobre sus documentos para determinar los documentos más relevantes para los términos de búsqueda introducidos. Algunos de los elementos que se tienen Amazon Kendra en cuenta son:
+ El texto o el cuerpo del documento.
+ El título del documento.
+ Campos de texto personalizados que ha marcado como que se pueden buscar.
+ El campo de fecha que ha indicado que debe usarse para determinar la “antigüedad” de un documento.
+ Cualquier otro campo que pueda proporcionar información relevante.
Amazon Kendra también puede filtrar la respuesta en función de cualquier field/attribute filtro que haya establecido para la búsqueda. Por ejemplo, si tiene un campo personalizado denominado “department”, puede filtrar la respuesta para que muestre únicamente los documentos de un departamento denominado “legal”. Para obtener más información, consulte [Campos o atributos personalizados](https://docs.aws.amazon.com/kendra/latest/dg/custom-attributes.html).
Los resultados de la búsqueda devueltos se ordenan según la relevancia que se Amazon Kendra determine para cada documento. Los resultados están paginados para que pueda mostrar una página a la vez al usuario.
Para buscar documentos con Amazon Kendra los que ha indexado Amazon Lex, utilice [AMAZON. KendraSearchIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_KendraConfiguration.html). Para ver un ejemplo de configuración Amazon Kendra con Amazon Lex, consulte [Creación de un bot de preguntas frecuentes para un Amazon Kendra índice](https://docs.aws.amazon.com/lexv2/latest/dg/faq-bot-kendra-search.html).
En el siguiente ejemplo, se muestra cómo buscar en un índice. Amazon Kendra determina el tipo de resultado de la búsqueda (respuesta, documento, pregunta-respuesta) que mejor se adapta a la consulta. No se puede configurar Amazon Kendra para que devuelva un tipo específico de respuesta de búsqueda (respuesta, documento, pregunta-respuesta) a una consulta.
Para obtener más información acerca de las respuestas a las consultas, vea [Respuestas a las consultas y tipos de respuestas](query-responses-types.md).
**Topics**
+ [Requisitos previos](#searching-prerequisites)
+ [Buscar en un índice (consola)](#searching-index-console)
+ [Buscar en un índice (SDK)](#searching-index-sdk)
+ [Buscar en un índice (Postman)](#searching-index-postman)
+ [Búsqueda con una sintaxis de consulta avanzada](#searching-index-query-syntax)
+ [Buscar en otros idiomas](#searching-index-languages)
## Requisitos previos
Antes de usar la API de [consulta](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) para consultar un índice:
+ Configure los permisos necesarios para un índice y conéctese a su origen de datos o cargue sus documentos por lotes. Para obtener más información, consulte [Roles de IAM](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html). Debe utilizar el nombre de recursos de Amazon del rol cuando llama a la API para crear un conector de índice y origen de datos o para cargar documentos por lotes.
+ Configura un SDK o ve a la Amazon Kendra consola. AWS Command Line Interface Para obtener más información, consulte [Configuración Amazon Kendra](https://docs.aws.amazon.com/kendra/latest/dg/setup.html).
+ Cree un índice y conéctese a un origen de datos de documentos o cargue documentos por lotes. Para obtener más información, consulte [Creación de un índice](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html) y [Creación de un conector de origen de datos](https://docs.aws.amazon.com/kendra/latest/dg/data-source.html).
## Buscar en un índice (consola)
Puedes usar la Amazon Kendra consola para buscar y probar tu índice. Puede realizar consultas y ver los resultados.
**Para buscar en un índice con la consola**
1. Inicie sesión en la Amazon Kendra consola Consola de administración de AWS y ábrala en [http://console.aws.amazon.com/kendra/](https://console.aws.amazon.com/kendra).
1. En el panel de navegación, elija **Índices**.
1. Elija su índice.
1. En el menú de navegación, elija la opción para buscar en el índice.
1. Escriba una consulta en el cuadro de texto y, a continuación, pulse Intro.
1. Amazon Kendra devuelve los resultados de la búsqueda.
También puede obtener el ID de consulta para la búsqueda seleccionando el icono de la bombilla en el panel lateral.
## Buscar en un índice (SDK)
**Para buscar en un índice con Python o Java**
+ En el siguiente ejemplo se busca en un índice. Cambie el valor de `query` a su consulta de búsqueda y `index_id` o `indexId` al identificador de índice del índice en el que desee buscar.
También puede obtener el ID de consulta de la búsqueda como parte de los elementos de respuesta cuando llama a la API de [consulta](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");
}
}
}
```
------
## Buscar en un índice (Postman)
Puede usar [Postman](https://www.postman.com/) para consultar y probar su Amazon Kendra índice.
**Para buscar en un índice mediante Postman**
1. Cree una nueva colección en Postman y establezca el tipo de solicitud en **POST**.
1. Introduzca la URL del punto de conexión. Por ejemplo, *https://kendra..amazonaws.com*.
1. Seleccione la pestaña **Autorización** e introduzca la siguiente información.
+ **Tipo**: seleccione la **firma de AWS **.
+ **AccessKey**—Introduzca la clave de acceso generada al crear un IAM usuario.
+ **SecretKey**—Introduzca la clave secreta generada al crear un IAM usuario.
+ **AWS Región**: introduzca la región de su índice. Por ejemplo, *us-west-2*.
+ **Nombre del servicio**: introduzca *kendra*. Se distingue entre mayúsculas y minúsculas, por lo que debe estar en minúsculas.
**aviso**
Si escribe un nombre de servicio incorrecto o no utiliza minúsculas, aparecerá un mensaje de error al seleccionar **Enviar** para enviar la solicitud: “Credential should be scoped to the correct service 'kendra'’”.
También debe comprobar que ha introducido la clave de acceso y la clave secreta.
1. Seleccione la pestaña **Encabezados** e introduzca la siguiente información de clave y valor.
+ Clave: *X-Amz-Target*
Valor: *com.amazonaws.kendra. AWSKendraFrontendService.Consulta*
+ Clave: *Content-Encoding*
Valor: *amz-1.0*
1. Seleccione la pestaña **Cuerpo** y haga lo siguiente.
+ Elija el tipo JSON **sin procesar** para el cuerpo de la solicitud.
+ Introduzca un JSON que incluya su ID de índice y el texto de la consulta.
```
{
"IndexId": "index-id",
"QueryText": "enter a query here"
}
```
**aviso**
Si tu JSON no usa la indentación correcta, aparece un error: "». SerializationException Compruebe la indentación en su JSON.
1. Seleccione **Enviar** (cerca de la esquina superior derecha).
## Búsqueda con una sintaxis de consulta avanzada
Puede crear consultas que sean más específicas que las consultas simples de palabras clave o lenguaje natural mediante operadores o sintaxis de consulta avanzados. Por ejemplo, puede utilizar rangos, operadores booleanos, caracteres comodín y mucho más. Al usar operadores, puede dar más contexto a la consulta y refinar aún más los resultados de búsqueda.
Amazon Kendra admite los siguientes operadores.
+ Operadores booleanos: lógica para limitar o ampliar la búsqueda. Por ejemplo, `amazon AND sports` limita la búsqueda para que solo busque documentos que contengan ambos términos.
+ Paréntesis: lee los términos de consulta anidados en orden de prioridad. Por ejemplo, `(amazon AND sports) NOT rainforest` lee `(amazon AND sports)` antes que `NOT rainforest`.
+ Rangos: valores de rango numérico o de fecha. Los rangos pueden ser inclusivos, exclusivos o ilimitados. Por ejemplo, puede buscar documentos que se actualizaron por última vez entre el 1 de enero de 2020 y el 31 de diciembre de 2020, con ambas fechas incluidas.
+ Campos: utiliza un campo específico para limitar la búsqueda. Por ejemplo, puede buscar documentos que tengan “Estados Unidos” en el campo “ubicación”.
+ Caracteres comodín: coinciden parcialmente con una cadena de texto. Por ejemplo, `Cloud*` podría coincidir CloudFormation. Amazon Kendra actualmente solo admite caracteres comodín al final.
+ Citas exactas: coinciden exactamente con una cadena de texto. Por ejemplo, los documentos que contienen `"Amazon Kendra" "pricing"`.
Puede utilizar combinaciones de cualquiera de los operadores anteriores.
Tenga en cuenta que el uso excesivo de operadores o de consultas muy complejas podría afectar a la latencia de las consultas. Los caracteres comodín son algunos de los operadores que más afectan en términos de latencia. Por regla general, cuantos más términos y operadores utilice, mayor será el impacto potencial en la latencia. Otros factores que afectan a la latencia son el tamaño medio de los documentos indexados, el tamaño del índice, cualquier filtrado de los resultados de búsqueda y la carga total del índice. Amazon Kendra
### Booleano
Puede combinar o excluir palabras mediante los operadores booleanos `AND`, `OR` y `NOT`.
Los siguientes ejemplos muestran el uso de los operadores booleanos.
**`amazon AND sports`**
Devuelve los resultados de búsqueda que contienen los términos “amazon” y “sports” en el texto, como vídeos de deporte de Amazon Prime u otro contenido similar.
**`sports OR recreation`**
Devuelve los resultados de búsqueda que contienen los términos “sports” o “recreation”, o ambos, en el texto.
**`amazon NOT rainforest`**
Devuelve los resultados de búsqueda que contienen el término “amazon” pero no el término “rainforest” en el texto. Se utiliza para buscar documentos sobre la empresa Amazon, no sobre la selva amazónica.
### Paréntesis
Puede consultar palabras anidadas en orden de prioridad utilizando paréntesis. Los paréntesis indican Amazon Kendra cómo debe leerse una consulta.
Los siguientes ejemplos muestran el uso de los paréntesis como operadores.
**`(amazon AND sports) NOT rainforest`**
Devuelve los documentos que contienen los términos “amazon” y “sports” en el texto, pero no el término “rainforest”. Se utiliza para buscar contenidos como vídeos de deporte de Amazon Prime u otro contenido similar, y no para buscar deportes de aventura en la selva amazónica. Los paréntesis indican que `amazon AND sports` debe leerse antes que `NOT rainforest`. La consulta no debe leerse como `amazon AND (sports NOT rainforest)`.
**`(amazon AND (sports OR recreation)) NOT rainforest`**
Devuelve documentos que contienen los términos “sports” o “recreation”, o ambos, y el término “amazon”. Sin embargo, no incluye el término “rainforest”. Se utiliza para buscar vídeos de deporte de Amazon Prime u otros contenidos de ocio, y no para buscar deportes de aventura en la selva amazónica. Los paréntesis indican que `sports OR recreation` debe leerse antes de combinarlo con “amazon”, que se lee antes que `NOT rainforest`. La consulta no debe leerse como `amazon AND (sports OR (recreation NOT rainforest))`.
### Rangos
Puede utilizar un rango de valores para filtrar los resultados de búsqueda. Debe especificar un atributo y el rango de valores. Puede ser de tipo numérico o de fecha.
Los rangos de fechas deben tener los siguientes formatos:
+ Epoch
+ AAAA
+ AAAA-mm
+ AAAA-mm-dd
+ AAAA-mm-dd'T'HH
También puede especificar si desea incluir o excluir los valores inferior y superior del rango.
Los siguientes ejemplos muestran el uso de los rangos como operadores.
**`_processed_date:>2019-12-31 AND _processed_date:<2021-01-01`**
Devuelve los documentos que se procesaron en 2020, es decir, más tarde que el 31 de diciembre de 2019 y antes que el 1 de enero de 2021.
**`_processed_date:>=2020-01-01 AND _processed_date:<=2020-12-31`**
Devuelve los documentos que se procesaron en 2020, es decir, entre el 1 de enero de 2020 o más tarde y hasta el 31 de diciembre de 2020 o antes.
**`_document_likes:<1`**
Devuelve los documentos sin likes o sin valoraciones de los usuarios (menos de 1 like).
Puede especificar si un rango debe considerarse inclusivo o exclusivo de los valores del rango dados.
**Inclusivo**
**`_last_updated_at:[2020-01-01 TO 2020-12-31]`**
Devuelve los documentos actualizados por última vez en 2020; incluye los días 1 de enero de 2020 y 31 de diciembre de 2020.
**Exclusivo**
**`_last_updated_at:{2019-12-31 TO 2021-01-01}`**
Devuelve los documentos actualizados por última vez en 2020; excluye los días 31 de diciembre de 2019 y 1 de enero de 2021.
Para usar rangos ilimitados que no sean inclusivos ni exclusivos, simplemente use los operadores < y >. Por ejemplo, `_last_updated_at:>2019-12-31 AND _last_updated_at:<2021-01-01`
#### Fields
Puede limitar la búsqueda para que solo se devuelvan los documentos que cumplan un valor en un campo específico. El campo puede ser de cualquier tipo.
A continuación se muestran ejemplos del uso de operadores de contexto en el campo.
**`status:"Incomplete" AND financial_year:2021`**
Devuelve los documentos del ejercicio fiscal de 2021 con el estado incompleto.
**`(sports OR recreation) AND country:"United States" AND level:"professional"`**
Devuelve documentos relacionados con el ocio o el deporte profesional en los Estados Unidos.
#### Caracteres comodín
Puede ampliar la búsqueda para incluir variantes de palabras y frases utilizando el operador de carácter comodín. Esto resulta útil cuando se buscan variantes de nombres. Amazon Kendra actualmente solo admite caracteres comodín al final. El número de caracteres del prefijo de un carácter comodín final debe ser superior a dos.
Los siguientes ejemplos muestran el uso de los caracteres comodín como operadores.
**`Cloud*`**
Devuelve documentos que contienen variantes como CloudFormation y. CloudWatch
**`kendra*aws`**
Devuelve documentos que contienen variantes como kendra.amazonaws.
**`kendra*aws*`**
Devuelve documentos que contienen variantes como kendra.amazonaws.com.
#### Citas exactas
Puede utilizar las comillas para buscar una coincidencia exacta de un fragmento de texto.
A continuación se muestran ejemplos del uso de las comillas.
**`"Amazon Kendra" "pricing"`**
Devuelve los documentos que contienen “Amazon Kendra” y el término “pricing”. Los documentos deben incluir tanto “Amazon Kendra” como “pricing” para poder mostrarlos en los resultados.
**`"Amazon Kendra" "pricing" cost`**
Devuelve los documentos que contienen “Amazon Kendra” y el término “pricing”, y opcionalmente el término “cost”. Los documentos deben incluir tanto “Amazon Kendra” como “pricing” para poder mostrarlos en los resultados, pero no deben incluir necesariamente “cost”.
#### Sintaxis de consulta no válida
Amazon Kendra emite una advertencia si hay problemas con la sintaxis de la consulta o si la consulta no es compatible actualmente con Amazon Kendra. Para obtener más información, consulte la [documentación de la API sobre las advertencias de las consultas](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Warning.html).
Las siguientes consultas muestran ejemplos de sintaxis de consulta no válida.
**`_last_updated_at:<2021-12-32`**
Fecha no válida. El día 32 no existe en el calendario gregoriano, que es el que utiliza Amazon Kendra.
**`_view_count:ten`**
Valor numérico no válido. Se deben usar dígitos para representar valores numéricos.
**`nonExistentField:123`**
Búsqueda de campo no válida. El campo debe existir para poder utilizar la búsqueda de campos.
**`Product:[A TO D]`**
Rango no válido. Se deben usar valores numéricos o fechas para los rangos.
**`OR Hello`**
Operador booleano no válido. Los operadores deben usarse con términos y colocarse entre términos.
## Buscar en otros idiomas
Puede buscar documentos en un idioma compatible. Debe introducir el código de idioma [AttributeFilter](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeFilter.html)para que se devuelvan los documentos filtrados en el idioma que elija. Puede escribir la consulta en un idioma compatible.
Si no especifica un idioma, Amazon Kendra consulta los documentos en inglés de forma predeterminada. Para obtener más información acerca de los idiomas admitidos, incluidos sus códigos, consulte [Adición de documentos en idiomas distintos del inglés](https://docs.aws.amazon.com/kendra/latest/dg/in-adding-languages.html).
Para buscar documentos en un idioma compatible en la consola, seleccione el índice y, a continuación, seleccione la opción de buscar en el índice en el menú de navegación. Elija el idioma en el que desea que se muestren los documentos. Para ello, seleccione la configuración de búsqueda y, a continuación, seleccione un idioma en el menú desplegable **Idioma**.
En los siguientes ejemplos se muestra cómo buscar documentos en español.
**Para buscar un índice en español en la consola**
1. Inicie sesión Consola de administración de AWS y abra la Amazon Kendra consola en [http://console.aws.amazon.com/kendra/](https://console.aws.amazon.com/kendra).
1. En el menú de navegación, elija **Índices** y, a continuación, elija su índice.
1. En el menú de navegación, elija la opción para buscar en el índice.
1. En la configuración de búsqueda, seleccione el menú desplegable **Idiomas** y elija español.
1. Escriba una consulta en el cuadro de texto y, a continuación, pulse Intro.
1. Amazon Kendra devuelve los resultados de la búsqueda en español.
**Para buscar un índice en español mediante la CLI, Python o Java**
+ En el siguiente ejemplo se busca en un índice en español. Cambie el valor de `searchString` a su consulta de búsqueda y el valor de `indexID` al identificador del índice en el que desee buscar. El código de idioma de español es `es`. Puede reemplazarlo por el código de su idioma.
------
#### [ 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");
}
}
}
```
------
# Recuperación de pasajes
Puede utilizar la API [https://docs.aws.amazon.com/kendra/latest/APIReference/API_Retrieve.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Retrieve.html) como recuperador para los sistemas de generación aumentada de recuperación (RAG).
Los sistemas RAG utilizan inteligencia artificial generativa para crear aplicaciones de preguntas y respuestas. Los sistemas RAG constan de un recuperador y modelos de lenguaje grandes (LLM). Al realizar una consulta, el recuperador identifica los fragmentos de texto más relevantes de un corpus de documentos y los envía al LLM para proporcionar la respuesta más útil. Luego, el LLM analiza los fragmentos de texto relevantes y genera una respuesta integral para la consulta.
La API `Retrieve` analiza los fragmentos de texto o los extractos, que se denominan *pasajes*, y devuelve los pasajes principales que son más relevantes para la consulta.
Al igual que la API [https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html), la API `Retrieve` también busca información relevante. La recuperación de información de la API Retrieve tiene en cuenta el contexto de la consulta y toda la información disponible en los documentos indexados. Sin embargo, de forma predeterminada, la API `Query` solo devuelve fragmentos o pasajes de hasta 100 palabras simbólicas. Con la API `Retrieve`, puede recuperar pasajes más largos de hasta 200 palabras simbólicas y hasta 100 pasajes semánticamente relevantes. Esto no incluye las respuestas de tipo pregunta-respuesta o preguntas frecuentes de su índice. Los pasajes, también denominados fragmentos, son extractos de texto que se pueden extraer semánticamente de varios documentos y de varias partes del mismo documento. El índice GenAI Enterprise Edition de Kendra ofrece resultados de alta precisión para su recuperación, ya que utiliza una búsqueda híbrida en índices de vectores y de palabras clave, además de una clasificación según modelos de aprendizaje profundo.
También puede utilizar la API `Retrieve` para hacer lo siguiente:
+ Anular la priorización en el índice
+ Filtrar en función de los campos o atributos del documento
+ Filtrar en función del acceso del usuario o su grupo a los documentos
+ Consultar el bucket de puntuación de confianza para el resultado de un pasaje recuperado. El bucket de confianza proporciona una clasificación relativa que indica el grado de confianza de Amazon Kendra en que la respuesta es relevante para la consulta.
**nota**
Por el momento, los buckets de puntuación de confianza solo están disponibles en inglés.
También puede incluir algunos campos en la respuesta que podrían proporcionar información adicional útil.
La API `Retrieve` no admite actualmente las siguientes características: consultas con [sintaxis de consulta avanzada](https://docs.aws.amazon.com/kendra/latest/dg/searching-example.html#searching-index-query-syntax), [sugerencias de correcciones ortográficas](https://docs.aws.amazon.com/kendra/latest/dg/query-spell-check.html) para las consultas, [creación de facetas](https://docs.aws.amazon.com/kendra/latest/dg/filtering.html#search-facets), [sugerencias de consultas](https://docs.aws.amazon.com/kendra/latest/dg/query-suggestions.html) para completar automáticamente consultas de búsqueda y [aprendizaje incremental](https://docs.aws.amazon.com/kendra/latest/dg/submitting-feedback.html). Las consultas de la API de recuperación no aparecerán en el panel de análisis.
La API `Retrieve` comparte el número de [unidades de capacidad de consulta](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CapacityUnitsConfiguration.html) que establezca para su índice. Para obtener información sobre lo que incluye una unidad de capacidad única y la capacidad base por defecto de un índice, consulte [Ajuste de la capacidad](https://docs.aws.amazon.com/kendra/latest/dg/adjusting-capacity.html).
**nota**
No puede añadir capacidad si utiliza la Amazon Kendra Developer Edition; solo puede añadir capacidad cuando utiliza Amazon Kendra la Enterprise Edition. Para obtener más información sobre lo que se incluye en las ediciones Developer y Enterprise, consulte [Ediciones de Amazon Kendra](https://docs.aws.amazon.com/kendra/latest/dg/what-is-kendra.html#kendra-editions).
A continuación se muestra un ejemplo del uso de la API `Retrieve` para recuperar los 100 pasajes más relevantes de los documentos de un índice para la consulta "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");
}
}
}
```
------
# Navegar por un índice
**nota**
La compatibilidad de características varía según el tipo de índice y la API de búsqueda que se use. Para comprobar si esta característica es compatible con el tipo de índice y la API de búsqueda que usa, consulte [Tipos de índices](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Puede examinar los documentos por sus atributos o facetas sin tener que escribir una consulta de búsqueda. Amazon Kendra *Navegar por el índice* puede ayudar a sus usuarios a descubrir documentos al navegar libremente por un índice sin tener en mente una consulta específica. Esto también ayuda a los usuarios a navegar ampliamente por un índice como punto de partida en su búsqueda.
La navegación por un índice solo se puede utilizar para buscar por atributo o faceta del documento con un tipo de ordenación. No puede buscar en un índice completo mediante la navegación por el índice. Si falta el texto de la consulta, Amazon Kendra solicita un filtro de atributos del documento o una faceta y un tipo de ordenación.
Para permitir la navegación por índices mediante la API de [consultas](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html), debe incluir [AttributeFilter](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeFilter.html)o [Facet y](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Facet.html). [SortingConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_SortingConfiguration.html) Para permitir la navegación por el índice en la consola, seleccione su índice en **Índices** en el menú de navegación y, a continuación, seleccione la opción de buscar en su índice. En el cuadro de búsqueda, presione la tecla *Intro* dos veces. Seleccione el menú desplegable **Filtrar los resultados de búsqueda** para elegir un filtro y seleccione el menú desplegable **Ordenar** para elegir un tipo de ordenación.
El siguiente ejemplo muestra cómo navegar por un índice para buscar documentos en español en orden descendente según la fecha de creación del documento.
------
#### [ 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");
}
}
}
```
------
# Destacar resultados de búsqueda
**nota**
La compatibilidad de características varía según el tipo de índice y la API de búsqueda que se use. Para comprobar si esta característica es compatible con el tipo de índice y la API de búsqueda que usa, consulte [Tipos de índices](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Puede destacar determinados documentos en los resultados de búsqueda cuando sus usuarios realicen determinadas consultas. Esto ayuda a que los resultados sean más visibles y destacados para los usuarios. Los resultados destacados se separan de la lista habitual de resultados y se muestran en la parte superior de la página de búsqueda. Puede probar destacando diferentes documentos para distintas consultas o asegurarse de que determinados documentos tengan la visibilidad que se merecen.
Debe asignar consultas específicas a documentos específicos para destacarlos en los resultados. Si una consulta contiene una coincidencia exacta, en los resultados de la búsqueda se destacan uno o más documentos específicos.
Por ejemplo, si los usuarios escriben la consulta “nuevos productos de 2023”, puede seleccionar los documentos titulados “Novedades” y “Próximamente” para que se destaquen en la parte superior de la página de resultados de búsqueda. Esto ayuda a garantizar que estos documentos sobre los nuevos productos tengan la visibilidad que se merecen.
Amazon Kendra no duplica los resultados de la búsqueda si un resultado ya está seleccionado para que aparezca en la parte superior de la página de resultados de la búsqueda. Un resultado destacado no vuelve a clasificarse como primer resultado si ya aparece destacado por encima de todos los demás resultados.
Para destacar determinados resultados, debe especificar una coincidencia exacta de una consulta de texto completo, no una coincidencia parcial de una consulta que utilice una palabra clave o frase incluida en una consulta. Por ejemplo, si solo especifica la consulta “Kendra” en un conjunto de resultados destacados, consultas como “¿Cómo clasifica Kendra semánticamente los resultados?” no mostrará los resultados destacados. Los resultados destacados están diseñados para consultas específicas, en lugar de consultas con un alcance demasiado amplio. Amazon Kendra gestiona de forma natural las consultas de tipos de palabras clave para clasificar los documentos más útiles en los resultados de búsqueda, evitando que los resultados aparezcan excesivamente basados en palabras clave simples.
Si hay determinadas consultas que sus usuarios utilizan con frecuencia, puede especificarlas para los resultados destacados. Por ejemplo, si analiza sus consultas principales con [Amazon Kendra Analytics](https://docs.aws.amazon.com/kendra/latest/dg/search-analytics.html) y encuentra consultas específicas, como “¿Cómo clasifica Kendra los resultados semánticamente?” y la «búsqueda semántica de kendra» se utilizan con frecuencia, por lo que puede ser útil especificar estas consultas para incluir el documento titulado «búsqueda 101».Amazon Kendra
Amazon Kendra trata las consultas de resultados destacados sin distinguir entre mayúsculas y minúsculas. Amazon Kendra convierte una consulta a minúsculas y reemplaza los espacios en blanco finales por un solo espacio. Amazon Kendra coincide con todos los demás caracteres tal y como aparecen al especificar las consultas para los resultados destacados.
Se crea un conjunto de resultados destacados que se asignan a determinadas consultas mediante la [CreateFeaturedResultsSet](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateFeaturedResultsSet.html)API. Si utiliza la consola, seleccione su índice y, a continuación, seleccione **Resultados destacados** en el menú de navegación para crear un conjunto de resultados destacados. Puede crear hasta 50 conjuntos de resultados destacados por índice, destacar hasta cuatro documentos por conjunto y hasta 49 textos de consulta por conjunto de resultados destacados. Puede solicitar un aumento de estos límites poniéndose en contacto con [Soporte](https://aws.amazon.com/contact-us/).
Puede seleccionar el mismo documento en varios conjuntos de resultados destacados. Sin embargo, no debe utilizar el mismo texto de consulta de coincidencia exacta en varios conjuntos. Las consultas que especifique para los resultados destacados deben ser únicas para cada conjunto de resultados destacados de cada índice.
Puede organizar el orden de los documentos al seleccionar hasta cuatro documentos destacados. Si utiliza la API, el orden en el que publica los documentos destacados es el mismo que se muestra en los resultados destacados. Si utiliza la consola, solo tiene que arrastrar y soltar el orden de los documentos al seleccionar los documentos para destacarlos en los resultados.
El control de acceso, según el cual algunos usuarios y grupos tienen acceso a determinados documentos y otros no, se sigue respetando a la hora de configurar los resultados destacados. Esto también es válido para el filtrado por contexto de usuario. Por ejemplo, el usuario A pertenece al grupo de la empresa “Becarios”, que no debería acceder a los documentos que contienen secretos de empresa. Si el usuario A introduce una consulta que hace destacar un documento secreto de la empresa, el usuario A no verá este documento destacado en sus resultados. Esto también se aplica a cualquier otro resultado de la página de resultados de búsqueda. También puede usar etiquetas para controlar el acceso a un conjunto de resultados destacados, que es un recurso de Amazon Kendra para el cual tiene el control del acceso.
A continuación se muestra un ejemplo de cómo crear un conjunto de resultados destacados con las consultas “new products 2023” y “new products available” asignadas a los documentos titulados “What's new” (doc-id-1) and “Coming soon” (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.")
```
------
# Búsqueda tabular de HTML
**nota**
La compatibilidad de características varía según el tipo de índice y la API de búsqueda que se use. Para comprobar si esta característica es compatible con el tipo de índice y la API de búsqueda que usa, consulte [Tipos de índices](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
La característica de búsqueda tabular de Amazon Kendra permite buscar y extraer respuestas de tablas incrustadas en documentos HTML. Cuando busques en tu índice, Amazon Kendra incluye un extracto de una tabla si es relevante para la consulta y proporciona información útil.
Amazon Kendra examina toda la información del cuerpo del texto de un documento, incluida la información útil de las tablas. Por ejemplo, un índice contiene informes empresariales con tablas sobre los costes de operación, los ingresos y otra información financiera. Para la consulta, «¿cuál es el costo operativo anual de 2020 a 2022?» , Amazon Kendra puede devolver un extracto de una tabla que contenga las columnas pertinentes de la tabla «Operaciones (millones de USD)» y «Ejercicio financiero», y filas de la tabla que contengan los valores de ingresos de 2020, 2021 y 2022. El extracto de la tabla se incluye en el resultado, junto con el título del documento, un enlace al documento completo y cualquier otro campo del documento que desee incluir.
Los extractos de tablas se pueden mostrar en los resultados de búsqueda tanto si la información se encuentra en una celda de la tabla como en varias celdas. Por ejemplo, Amazon Kendra puede mostrar un extracto de una tabla adaptado a cada uno de estos tipos de consultas:
+ “tarjeta de crédito con la tasa de interés más alta de 2020”
+ “tarjeta de crédito con la tasa de interés más alta de 2020 a 2022”
+ “las 3 tarjetas de crédito con la tasa de interés más alta de 2020 a 2022”
+ “tarjetas de crédito con tasas de interés inferiores al 10 %”
+ “todas las tarjetas de crédito con intereses bajos disponibles”
Amazon Kendra resalta la celda o celdas de la tabla que son más relevantes para la consulta. En el resultado de búsqueda se muestran las celdas más relevantes con sus filas, columnas y nombres de columnas correspondientes. El extracto de la tabla muestra hasta cinco columnas y tres filas, en función del número de celdas de la tabla que sean relevantes para la consulta y del número de columnas disponibles en la tabla original. La celda más relevante se muestra en el extracto de la tabla, junto con las siguientes celdas más relevantes.
La respuesta incluye el bucket de confianza (`MEDIUM`, `HIGH` y `VERY_HIGH`) para mostrar la relevancia de la respuesta de la tabla para la consulta. Si el valor de una celda de la tabla tiene una confianza `VERY_HIGH`, se convierte en la “respuesta principal” y se resalta. En el caso de los valores de las celdas de la tabla con una confianza `HIGH`, aparecen resaltados. En el caso de los valores de las celdas de la tabla con una confianza `MEDIUM`, no aparecen resaltados. La confianza general para la respuesta de la tabla se devuelve en la respuesta. Por ejemplo, si una tabla contiene principalmente celdas de la tabla con confianza `HIGH`, la confianza general que se devuelve en la respuesta de la tabla es de confianza `HIGH`.
De forma predeterminada, a las tablas no se les asigna un mayor nivel de importancia ni más peso que a otros componentes de un documento. Dentro de un documento, si una tabla es solo ligeramente relevante para una consulta, pero hay un párrafo muy relevante, Amazon Kendra devuelve un extracto del párrafo. Los resultados de búsqueda muestran el contenido que proporciona la mejor respuesta posible y la información más útil, en el mismo documento o en otros documentos. Si la confianza de una tabla es inferior a `MEDIUM`, el extracto de la tabla no se devuelve en la respuesta.
Para utilizar la búsqueda tabular en un índice existente, debe volver a indexar el contenido.
Amazon Kendra La búsqueda tabular admite [sinónimos](https://docs.aws.amazon.com/kendra/latest/dg/index-synonyms.html) (incluidos los personalizados). Amazon Kendra solo admite documentos en inglés con tablas HTML que estén dentro de la etiqueta de tabla.
El siguiente ejemplo muestra un extracto de tabla incluido en el resultado de una consulta. Para ver un ejemplo de JSON con respuestas a consultas, incluidos extractos de tablas, consulte [Respuestas a las consultas y tipos de respuestas](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");
}
}
}
```
------
# Sugerencias de consulta
**nota**
La compatibilidad de características varía según el tipo de índice y la API de búsqueda que se use. Para comprobar si esta característica es compatible con el tipo de índice y la API de búsqueda que usa, consulte [Tipos de índices](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
*Las sugerencias de consulta* de Amazon Kendra pueden ayudar a los usuarios a escribir sus consultas de búsqueda más rápido y a guiar su búsqueda.
Amazon Kendra sugiere consultas relevantes para los usuarios en función de una de las siguientes opciones:
+ Consultas populares en el historial de consultas o en el registro de consultas
+ El contenido de los campos o atributos del documento
Puede configurar su preferencia de uso del historial de consultas o los campos del documento configurando `SuggestionTypes` como `QUERY` o `DOCUMENT_ATTRIBUTES` y llamando a [https://docs.aws.amazon.com/kendra/latest/APIReference/API_GetQuerySuggestions.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_GetQuerySuggestions.html). De forma predeterminada, Amazon Kendra utiliza el historial de consultas para basar las sugerencias. Si tanto el historial de consultas como los campos del documento están activados cuando llamas [https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsConfig.html)y no has establecido tu `SuggestionTypes` preferencia para usar los campos del documento, Amazon Kendra utiliza el historial de consultas.
Si utiliza la consola, puede basar las sugerencias de consulta en el historial de consultas o en los campos del documento. Primero debe seleccionar su índice y, a continuación, seleccionar **Sugerencias de consulta** en la sección **Enriquecimientos** del menú de navegación. A continuación, seleccione **Configurar sugerencias de consulta**. Tras configurar las sugerencias de consulta, accederá a una consola de búsqueda en la que podrá seleccionar el **Historial de consultas** o los **Campos del documento** en el panel derecho e introducir una consulta de búsqueda en la barra de búsqueda.
De forma predeterminada, las sugerencias de consulta que utilizan el historial de consultas y los campos del documento se activan sin coste adicional. Puede desactivar este tipo de sugerencias de consulta en cualquier momento mediante la API `UpdateQuerySuggestionsConfig`. Para desactivar las sugerencias de consulta basadas en el historial de consultas, configure `Mode` en `DISABLED` al llamar a `UpdateQuerySuggestionsConfig`. Para desactivar las sugerencias de consulta basadas en los campos del documento, configure `AttributeSuggestionsMode` en `INACTIVE` en la configuración de los campos del documento y, a continuación, llame a `UpdateQuerySuggestionsConfig>`. Si usa la consola, puede desactivar las sugerencias de consulta en la **Configuración de las sugerencias de consulta**.
Las sugerencias de consulta no distinguen mayúsculas de minúsculas. Amazon Kendra convierte el prefijo de la consulta y la consulta sugerida a minúsculas, omite todas las comillas simples y dobles y reemplaza varios espacios en blanco por un solo espacio. Amazon Kendra coincide con todos los demás caracteres especiales tal como están. Amazon Kendra no muestra ninguna sugerencia si un usuario escribe menos de dos caracteres o más de 60 caracteres.
**Topics**
+ [Sugerencias de consulta mediante el historial de consultas](#query-suggestions-history)
+ [Sugerencias de consulta mediante los campos del documento](#query-suggestions-doc-fields)
+ [Bloquear determinadas consultas o contenidos de los campos del documento para que no usen en las sugerencias](#query-suggestions-blocklist)
## Sugerencias de consulta mediante el historial de consultas
**nota**
La compatibilidad de características varía según el tipo de índice y la API de búsqueda que se use. Para comprobar si esta característica es compatible con el tipo de índice y la API de búsqueda que usa, consulte [Tipos de índices](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
**Topics**
+ [Configuración para seleccionar consultas para sugerencias](#query-suggestions-history-settings)
+ [Borrar las sugerencias pero conservar el historial de consultas](#query-suggestions-history-clear)
+ [No hay sugerencias disponibles](#query-suggestions-history-none)
Puede optar por sugerir consultas relevantes para sus usuarios en función de las consultas más frecuentes del historial de consultas o del registro de consultas. Amazon Kendra utiliza todas las consultas que buscan los usuarios y aprende de ellas para hacer sugerencias a los usuarios. Amazon Kendra sugiere consultas populares a los usuarios cuando empiezan a escribirlas. Amazon Kendra sugiere una consulta si el prefijo o los primeros caracteres de la consulta coinciden con lo que el usuario empieza a escribir en su consulta.
Por ejemplo, un usuario empieza a escribir la consulta “próximos eventos”. Amazon Kendra ha aprendido del historial de consultas que muchos usuarios han buscado “próximos eventos de 2050” muchas veces. El usuario ve aparecer “próximos eventos de 2050” directamente debajo de la barra de búsqueda, y completa automáticamente su consulta de búsqueda. El usuario selecciona esta sugerencia de consulta y en los resultados de búsqueda aparece el documento “Nuevos eventos: qué pasará en 2050”.
Puede especificar cómo Amazon Kendra selecciona las consultas aptas para sugerirlas a sus usuarios. Por ejemplo, puede especificar que una sugerencia de consulta debe haber sido buscada por al menos 10 usuarios únicos (el valor predeterminado es tres), debe haber sido buscada en los últimos 30 días y no debe contener palabras o frases de su [lista de bloqueados](https://docs.aws.amazon.com/kendra/latest/dg/query-suggestions.html#query-suggestions-blocklist). Amazon Kendra requiere que la consulta tenga al menos un resultado de búsqueda y que contenga al menos una palabra de más de cuatro caracteres.
### Configuración para seleccionar consultas para sugerencias
Puede configurar los siguientes ajustes para seleccionar consultas para sugerencias mediante la API [https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsConfig.html):
+ **Modo**: las sugerencias de consulta que utilizan el historial de consultas están `ENABLED` o son `LEARN_ONLY`. Amazon Kendra activa las sugerencias de consulta de forma predeterminada. `LEARN_ONLY` desactiva las sugerencias de consulta. Si está desactivada, Amazon Kendra sigue aprendiendo las sugerencias, pero no hace sugerencias de consulta a los usuarios.
+ **Periodo de tiempo del registro de consultas**: la antigüedad de las consultas en el periodo de tiempo del registro de consultas. El periodo de tiempo es un valor entero para el número de días desde el día actual hasta los días anteriores.
+ **Consultas sin información del usuario**: debe configurarlo como `TRUE` para incluir todas las consultas, o como `FALSE` para incluir solo las consultas con información del usuario. Puede usar esta configuración si la aplicación de búsqueda incluye información del usuario, como el ID de usuario, cuando un usuario realiza una consulta. De forma predeterminada, esta configuración no filtra las consultas si no hay información del usuario específica asociada a las consultas. Sin embargo, puede usar esta configuración para hacer sugerencias basadas únicamente en las consultas que incluyan información del usuario.
+ **Usuarios únicos**: el número mínimo de usuarios únicos que deben haber buscado una consulta para que sea apta para sugerirla a sus usuarios. Este número es un valor entero.
+ **Recuento de consultas**: el número mínimo de veces que se debe haber buscado una consulta para que sea apta para sugerirla a sus usuarios. Este número es un valor entero.
Estos ajustes afectan a la forma en que se seleccionan las consultas como consultas populares para sugerirlas a sus usuarios. La forma en que debe ajustar la configuración depende de sus necesidades específicas, por ejemplo:
+ Si sus usuarios suelen buscar una vez al mes de media, puede establecer el número de días en el periodo de tiempo del registro de consultas en 30 días. Al usar esa configuración, capturará la mayoría de las consultas recientes de sus usuarios antes de que queden desactualizadas en el periodo de tiempo.
+ Si solo un número reducido de consultas incluye información del usuario y no desea sugerir consultas basadas en un tamaño de muestra pequeño, puede configurar las consultas para que incluyan a todos los usuarios.
+ Si define las consultas populares como las que han buscado al menos 10 usuarios únicos y las que se han buscado al menos 100 veces, debe establecer los usuarios únicos en 10 y el recuento de consultas en 100.
**aviso**
Es posible que los cambios en la configuración no se apliquen de forma inmediata. Puede realizar un seguimiento de los cambios en la configuración mediante la API [https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html). El tiempo que tarda en surtir efecto la configuración actualizada depende de las actualizaciones que realice y del número de consultas de búsqueda de su índice. Amazon Kendra actualiza automáticamente las sugerencias cada 24 horas, después de cambiar una configuración o después de aplicar una [lista de bloqueo](https://docs.aws.amazon.com/kendra/latest/dg/query-suggestions.html#query-suggestions-blocklist).
------
#### [ CLI ]
**Para recuperar las sugerencias de consulta**
```
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
```
**Para actualizar las sugerencias de consulta**
Por ejemplo, para cambiar el periodo de tiempo del registro de consultas y el número mínimo de veces que se debe haber buscado una consulta:
```
aws kendra update-query-suggestions-config \
--index-id index-id \
--query-log-look-back-window-in-days 30 \
--minimum-query-count 100
```
------
#### [ Python ]
**Para recuperar las sugerencias de consulta**
```
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.")
```
**Para actualizar las sugerencias de consulta**
Por ejemplo, para cambiar el periodo de tiempo del registro de consultas y el número mínimo de veces que se debe haber buscado una consulta:
```
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.")
```
------
### Borrar las sugerencias pero conservar el historial de consultas
**nota**
La compatibilidad de características varía según el tipo de índice y la API de búsqueda que se use. Para comprobar si esta característica es compatible con el tipo de índice y la API de búsqueda que usa, consulte [Tipos de índices](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Puede borrar las sugerencias de consultas mediante la API [https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html). Al borrar las sugerencias, solo se eliminan las sugerencias de consulta existentes, no las consultas del historial de consultas. Al borrar las sugerencias, Amazon Kendra aprende las nuevas en función de las consultas nuevas que se hayan agregado al registro de consultas desde el momento en que las eliminaste.
------
#### [ CLI ]
**Para borrar las sugerencias de consulta**
```
aws kendra clear-query-suggestions \
--index-id index-id
```
------
#### [ Python ]
**Para borrar las sugerencias de consulta**
```
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.")
```
------
### No hay sugerencias disponibles
Si no ve sugerencias para una consulta, puede deberse a uno de los siguientes motivos:
+ No hay suficientes consultas en el índice de las Amazon Kendra que pueda aprender.
+ La configuración de las sugerencias de consulta es demasiado estricta, por lo que la mayoría de las consultas se excluyen de las sugerencias.
+ Ha aprobado las sugerencias recientemente y Amazon Kendra todavía necesita tiempo para acumular nuevas consultas y obtener nuevas sugerencias.
Puede comprobar la configuración actual mediante la API [https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html).
## Sugerencias de consulta mediante los campos del documento
**Topics**
+ [Configuración para seleccionar campos para sugerencias](#query-suggestions-doc-fields-settings)
+ [Control de usuarios en los campos del documento](#query-suggestions-doc-fields-user-control)
Puede optar por sugerir consultas relevantes para sus usuarios basadas en el contenido de los campos del documento. En lugar de utilizar el historial de consultas para sugerir otras consultas relevantes y populares, puede utilizar la información contenida en un campo de documento que sea útil para completar automáticamente la consulta. Amazon Kendra busca contenido relevante en los campos configurados como la consulta del usuario `Suggestable` y que se alinee estrechamente con ella. A continuación, Amazon Kendra sugiere este contenido al usuario cuando empiece a escribir la consulta.
Por ejemplo, si especificas el campo de título en el que basar las sugerencias y un usuario empieza a escribir la consulta «Cómo Amazon Ken... ', se podría sugerir el título más relevante, «Cómo Amazon Kendra funciona», para completar automáticamente la búsqueda. El usuario ve que aparece «Cómo Amazon Kendra funciona» directamente debajo de la barra de búsqueda, lo que completa automáticamente su consulta de búsqueda. El usuario selecciona esta sugerencia de consulta y aparece el documento «Cómo Amazon Kendra funciona» en los resultados de la búsqueda.
Puede utilizar el contenido de cualquier campo del documento de tipo `String` y `StringList` para sugerir una consulta configurando el campo como `Suggestable` como parte de la configuración de campos para las sugerencias de consulta. También puede utilizar una [lista de bloqueo](https://docs.aws.amazon.com/kendra/latest/dg/query-suggestions.html#query-suggestions-blocklist) para que los usuarios no vean los campos de documentos sugeridos que contienen determinadas palabras o frases. Puede usar una única lista de bloqueo. La lista de bloqueo se aplica si configura las sugerencias de consulta para que utilicen tanto el historial de consultas como los campos del documento.
### Configuración para seleccionar campos para sugerencias
Puede configurar los siguientes ajustes para seleccionar los campos del documento para las sugerencias, utilizando [https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeSuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeSuggestionsConfig.html) y llamando a la API [https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsConfig.html) para actualizar los ajustes en el índice:
+ **Modo de sugerencias de campos o atributos**: las sugerencias de consulta que utilizan los campos del documento pueden estar `ACTIVE` o `INACTIVE`. Amazon Kendra activa las sugerencias de consulta de forma predeterminada.
+ **Campos o atributos que se pueden sugerir**: los nombres de los campos o las claves de campo en los que basar las sugerencias. Estos campos deben estar configurados como `TRUE` para `Suggestable`, como parte de la configuración de los campos. Puede anular la configuración de los campos en la consulta y, al mismo tiempo, mantener la configuración en el índice. Utilice la [GetQuerySuggestions](https://docs.aws.amazon.com/kendra/latest/APIReference/API_GetQuerySuggestions.html)API para realizar cambios `AttributeSuggestionConfig` en el nivel de consulta. Esta configuración de la consulta puede resultar útil para probar rápidamente el uso de diferentes campos del documento sin tener que actualizar la configuración a nivel de índice.
+ **Campos o atributos adicionales**: los campos adicionales que desea incluir en la respuesta para una sugerencia de consulta. Estos campos se utilizan para proporcionar información adicional en la respuesta; sin embargo, no se utilizan como base para las sugerencias.
**aviso**
Es posible que los cambios en la configuración no se apliquen de forma inmediata. Puede realizar un seguimiento de los cambios en la configuración mediante la API [https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsConfig.html). El tiempo que tarda en surtir efecto la configuración actualizada depende de las actualizaciones que realices. Amazon Kendra actualiza automáticamente las sugerencias cada 24 horas, después de cambiar una configuración o después de aplicar una [lista de bloqueados](https://docs.aws.amazon.com/kendra/latest/dg/query-suggestions.html#query-suggestions-blocklist).
------
#### [ CLI ]
Para recuperar las sugerencias de consulta y anular la configuración de los campos del documento en la consulta en lugar de tener que cambiar la configuración en el índice.
```
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
```
**Para actualizar las sugerencias de consulta**
Por ejemplo, para cambiar la configuración de los campos del documento en el índice:
```
aws kendra update-query-suggestions-config \
--index-id index-id \
--attribute-suggestions-config '{"SuggestableConfigList": '[{"SuggestableConfig": "_document_title", "Suggestable": true}]', "AttributeSuggestionsMode": "ACTIVE"}'
```
------
#### [ Python ]
Para recuperar las sugerencias de consulta y anular la configuración de los campos del documento en la consulta en lugar de tener que cambiar la configuración en el índice.
```
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.")
```
**Para actualizar las sugerencias de consulta**
Por ejemplo, para cambiar la configuración de los campos del documento en el índice:
```
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.")
```
------
### Control de usuarios en los campos del documento
Puede aplicar un filtrado por contexto de usuario a los campos del documento en los que desee basar las sugerencias de consulta. De este modo se filtra la información de los campos del documento en función del acceso del usuario o de su grupo a los documentos. Por ejemplo, un becario busca en el portal de la empresa y no tiene acceso a un documento empresarial de alto secreto. Por lo tanto, las consultas sugeridas basadas en el título del documento de alto secreto o en cualquier otro campo que pueda sugerirse no se muestran al becario.
Puede indexar sus documentos con una lista de control de acceso (ACL), que defina qué usuarios y grupos tienen asignado acceso a qué documentos. A continuación, puede aplicar un filtrado por contexto de usuario a los campos de sus documentos para las sugerencias de consulta. El filtrado por contexto de usuario que está configurado actualmente para su índice es el mismo filtrado por contexto de usuario que se aplica a la configuración de los campos del documento para las sugerencias de consultas. El filtrado por contexto de usuario forma parte de la configuración de los campos del documento. Debe usar [https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeSuggestionsConfig.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeSuggestionsConfig.html) y llamar a [https://docs.aws.amazon.com/kendra/latest/APIReference/API_GetQuerySuggestions.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_GetQuerySuggestions.html).
## Bloquear determinadas consultas o contenidos de los campos del documento para que no usen en las sugerencias
Una *lista de bloqueo* Amazon Kendra impide sugerir determinadas consultas a los usuarios. Una lista de bloqueo es una lista de palabras o frases que quieres excluir de las sugerencias de consultas. Amazon Kendra excluye las consultas que contienen una coincidencia exacta de las palabras o frases de la lista de bloqueados.
Puede usar una lista de bloqueo para protegerse de las palabras o frases ofensivas que suelen aparecer en su historial de consultas o en los campos de los documentos y que Amazon Kendra podría seleccionar como sugerencias. Una lista de bloqueo también puede Amazon Kendra impedir que se sugieran consultas que contengan información que no esté lista para publicarse o anunciarse públicamente. Por ejemplo, pongamos el caso de que sus usuarios consultan con frecuencia sobre el próximo lanzamiento de un posible producto nuevo. Sin embargo, no quiere sugerir el producto porque no está preparado para lanzarlo. Puede bloquear las consultas que contengan el nombre y la información del producto para que no aparezcan en las sugerencias.
Puede crear una lista de bloqueo para las consultas mediante la API [https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateQuerySuggestionsBlockList.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateQuerySuggestionsBlockList.html). Para ello debe colocar cada palabra o frase bloqueadas en una línea diferente de un archivo de texto. A continuación, carga el archivo de texto en su bucket de Amazon S3 y proporciona la ruta o ubicación del archivo Amazon S3. Amazon Kendra actualmente solo admite la creación de una lista de bloqueos.
Puedes reemplazar el archivo de texto de las palabras y frases bloqueadas en tu Amazon S3 lista. Para actualizar la lista de bloqueados Amazon Kendra, usa la [https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsBlockList.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateQuerySuggestionsBlockList.html)API.
Use la API [https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsBlockList.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DescribeQuerySuggestionsBlockList.html) para obtener el estado de su lista de bloqueo. `DescribeQuerySuggestionsBlockList` también puede proporcionarle otra información útil, como la siguiente:
+ Cuándo se actualizó su lista de bloqueo por última vez
+ Cuántas palabras o frases hay en su lista de bloqueo actual
+ Mensajes de error útiles al crear una lista de bloqueo
También puede usar la API [https://docs.aws.amazon.com/kendra/latest/APIReference/API_ListQuerySuggestionsBlockLists.html](https://docs.aws.amazon.com/kendra/latest/APIReference/API_ListQuerySuggestionsBlockLists.html) para obtener una lista de resúmenes de listas de bloqueo para un índice.
Para eliminar tu lista de bloqueados, usa la [DeleteQuerySuggestionsBlockList](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DeleteQuerySuggestionsBlockList.html)API.
Es posible que las actualizaciones de la lista de bloqueo no surtan efecto de inmediato. Puede realizar un seguimiento de las actualizaciones mediante la API `DescribeQuerySuggestionsBlockList`.
------
#### [ CLI ]
**Para crear una lista de bloqueo**
```
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
```
**Para actualizar una lista de bloqueo**
```
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
```
**Para eliminar una lista de bloqueo**
```
aws kendra delete-query-suggestions-block-list \
--index-id index-id \
--id block-list-id
```
------
#### [ Python ]
**Para crear una lista de bloqueo**
```
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.")
```
**Para actualizar una lista de bloqueo**
```
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.")
```
**Para eliminar una lista de bloqueo**
```
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.")
```
------
# Corrector ortográfico de las consultas
**nota**
La compatibilidad de características varía según el tipo de índice y la API de búsqueda que se use. Para comprobar si esta característica es compatible con el tipo de índice y la API de búsqueda que usa, consulte [Tipos de índices](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
El *corrector ortográfico* de Amazon Kendra sugiere correcciones ortográficas para las consultas. De este modo, puede ayudarle a reducir al mínimo el número de casos de resultados de búsqueda nulos y a devolver resultados relevantes. Es posible que sus usuarios no reciban [ningún resultado de búsqueda](https://docs.aws.amazon.com/kendra/latest/dg/search-analytics.html#search-analytics-metrics) debido a consultas mal escritas sin resultados coincidentes o que no devuelvan documentos. También es posible que sus usuarios reciban [resultados de búsqueda irrelevantes](https://docs.aws.amazon.com/kendra/latest/dg/search-analytics.html#search-analytics-metrics) debido a consultas mal escritas.
El corrector ortográfico está diseñado para sugerir correcciones a las palabras mal escritas en función de las palabras que aparecen en sus documentos indexados y del grado de coincidencia entre una palabra corregida y una palabra mal escrita. Por ejemplo, si la palabra “estados” aparece en sus documentos indexados, podría coincidir estrechamente con la palabra “estatos” mal escrita en la consulta “estatos financieros de fin de año”.
El corrector ortográfico devuelve las palabras deseadas o corregidas que sustituyen a las palabras mal escritas en el texto original de la consulta. Por ejemplo, “impementar la búsqueda de Kendre” podría devolver “implementar la búsqueda de Kendra”. También puede usar las ubicaciones de desplazamiento proporcionadas en la API para resaltar o poner en cursiva las palabras corregidas devueltas en una consulta de su aplicación frontend. En la consola, las palabras corregidas aparecen resaltadas o en cursiva de forma predeterminada. Por ejemplo, “*implementar* la búsqueda de *Kendra*”.
En el caso de los términos especializados o específicos de la empresa que aparecen en los documentos indexados, el corrector ortográfico no los malinterpreta como errores ortográficos en la consulta. Por ejemplo, “amazon macie” no se corrige por “amazon nadie”.
En el caso de las palabras separadas con guiones, como “lectura-escritura”, el corrector ortográfico las trata como palabras individuales para sugerir correcciones. Por ejemplo, la corrección sugerida para “letcura-escritura” podría ser “lectura-escritura”.
Para los tipos de respuestas a consultas `DOCUMENT` y `QUESTION_ANSWER`, el corrector ortográfico sugiere correcciones para las palabras mal escritas en función de las palabras del cuerpo del documento. El cuerpo del documento es más fiable que el título a la hora de sugerir correcciones que coincidan estrechamente con las palabras mal escritas. Para los tipos de respuestas a consultas `ANSWER`, el corrector ortográfico sugiere correcciones en función de las palabras del documento de preguntas y respuestas predeterminado del índice.
Puedes activar el corrector ortográfico utilizando el [SpellCorrectionConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_SpellCorrectionConfiguration.html)objeto. Debe configurar `IncludeQuerySpellCheckSuggestions` como `TRUE`. El corrector ortográfico está activado de forma predeterminada en la consola. Está integrado en la consola de forma predeterminada.
El corrector ortográfico también puede sugerir correcciones ortográficas para consultas en varios idiomas, no solo en inglés. Para ver una lista de los idiomas compatibles con el corrector ortográfico, consulte [Idiomas admitidos por Amazon Kendra](https://docs.aws.amazon.com/kendra/latest/dg/in-adding-languages.html).
## Uso del corrector ortográfico de las consultas con los límites predeterminados
El corrector ortográfico está diseñado con ciertos límites o valores predeterminados. La siguiente lista presenta los límites actuales que se aplican al activar las sugerencias de corrección ortográfica.
+ No se pueden devolver las correcciones ortográficas sugeridas para las palabras que tengan menos de tres caracteres o más de 30 caracteres. Para permitir más de 30 caracteres o menos de tres caracteres, póngase en contacto con [Soporte](https://aws.amazon.com/contact-us/).
+ Las correcciones ortográficas sugeridas no pueden restringir las sugerencias basadas en el control de acceso de los usuarios o de su lista de control de acceso para el [filtrado por contexto de usuario](https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html). Las correcciones ortográficas se basan en todas las palabras de los documentos indexados, estén restringidas a determinados usuarios o no. Si quiere evitar que determinadas palabras aparezcan en las correcciones ortográficas sugeridas para las consultas, no active `SpellCorrectionConfiguration`.
+ No se pueden devolver correcciones ortográficas sugeridas para palabras que contienen números. Por ejemplo, “Cómo consultar documentos indexa2”.
+ Las correcciones ortográficas sugeridas no pueden utilizar palabras que no aparezcan en los documentos indexados.
+ Las correcciones ortográficas sugeridas no pueden utilizar palabras con una aparición menor al 0,01 % en los documentos indexados. Para cambiar el umbral del 0,01 %, póngase en contacto con [Soporte](https://aws.amazon.com/contact-us/).
# Filtrado y búsqueda por facetas
**nota**
La compatibilidad de características varía según el tipo de índice y la API de búsqueda que se use. Para comprobar si esta característica es compatible con el tipo de índice y la API de búsqueda que usa, consulte [Tipos de índices](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Puede mejorar los resultados de búsqueda o la respuesta desde la API de [consulta](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) mediante filtros. Los filtros restringen los documentos de la respuesta a aquellos que se corresponden directamente con la consulta. Para crear sugerencias de búsqueda por facetas, use los operadores booleanos para excluir los atributos específicos del documento de la respuesta o los documentos que no cumplan criterios específicos. Puede especificar facetas mediante el parámetro `Facets` de la API `Query`.
[Para buscar documentos con Amazon Kendra los que ha indexado Amazon Lex, utilice AMAZON. KendraSearchIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_KendraConfiguration.html). Para ver un ejemplo de configuración Amazon Kendra con Amazon Lex, consulte [Creación de un bot de preguntas frecuentes para un Amazon Kendra índice](https://docs.aws.amazon.com/lexv2/latest/dg/faq-bot-kendra-search.html). También puede proporcionar un filtro para la respuesta utilizando [AttributeFilter](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeFilter.html). Este es el filtro de consulta en JSON cuando se configura `AMAZON.KendraSearchIntent`. Para proporcionar un filtro de atributos al configurar una intención de búsqueda en la consola, vaya al editor de intenciones y elija la consulta de Amazon Kendra para proporcionar un filtro de consulta en JSON. Para obtener más información acerca de `AMAZON.KendraSearchIntent`, consulte la [Guía de documentación de Amazon Lex](https://docs.aws.amazon.com/lexv2/latest/dg/built-in-intent-kendra-search.html).
## Facetas
Las facetas son vistas limitadas de un conjunto de resultados de búsqueda. Por ejemplo, puede proporcionar resultados de búsqueda para ciudades de todo el mundo, donde los documentos se filtran por una ciudad específica a la que están asociados. O bien, puede crear facetas para mostrar los resultados de un autor específico.
Puede utilizar un atributo del documento o un campo de metadatos asociado a un documento como faceta para que los usuarios puedan buscar por categorías o valores dentro de esa faceta. También puede mostrar facetas anidadas en los resultados de búsqueda para que los usuarios puedan buscar no solo por categoría o campo, sino también por subcategoría o subcampo.
En el siguiente ejemplo se muestra cómo obtener información de facetas para el atributo personalizado “City”.
```
response=kendra.query(
QueryText = query,
IndexId = index,
Facets = [
{
"DocumentAttributeKey" : "City"
}
]
)
```
Puede utilizar facetas anidadas para restringir aún más la búsqueda. Por ejemplo, el atributo o faceta del documento “City” incluye un valor denominado “Seattle”. Además, el atributo o faceta "CityRegion" del documento incluye los valores «Norte» y «Sur» para los documentos asignados a «Seattle». Puede mostrar las facetas anidadas con sus recuentos en los resultados de búsqueda, de modo que los documentos se puedan buscar no solo por ciudad sino también por región dentro de una ciudad.
Tenga en cuenta que las facetas anidadas pueden afectar a la latencia de las consultas. Por regla general, cuantas más facetas anidadas utilice, mayor será el impacto potencial en la latencia. Otros factores que afectan a la latencia son el tamaño medio de los documentos indexados, el tamaño del índice, las consultas muy complejas y la carga general del índice de Amazon Kendra .
El siguiente ejemplo muestra cómo obtener información sobre las facetas del atributo personalizado «CityRegion», como una faceta anidada dentro de «Ciudad».
```
response=kendra.query(
QueryText = query,
IndexId = index,
Facets = [
{
"DocumentAttributeKey" : "City",
"Facets": [
{
"DocumentAttributeKey" : "CityRegion"
}
]
}
]
)
```
La información de las facetas, como el recuento de documentos, se devuelve en la matriz de respuestas de `FacetResults`. El contenido se utiliza para mostrar sugerencias de búsqueda por facetas en la aplicación. Por ejemplo, si el atributo del documento “City” contiene la ciudad a la que se podría aplicar la búsqueda, utilice esa información para mostrar una lista de las búsquedas de ciudades. Los usuarios pueden elegir una ciudad para filtrar los resultados de búsqueda. Para realizar la búsqueda por facetas, llame a la API de [consulta](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) y utilice el atributo de documento elegido para filtrar los resultados.
Puede mostrar hasta 10 valores de faceta por faceta de una consulta y solo una faceta anidada dentro de una faceta. Si desea aumentar estos límites, póngase en contacto con [Soporte](https://aws.amazon.com/contact-us/). Si desea limitar el número de valores de facetas por faceta a menos de 10, puede especificarlo en el objeto `Facet`.
En el siguiente ejemplo de respuesta de JSON, se muestran las facetas limitadas al atributo del documento “City”. La respuesta incluye el recuento de documentos para el valor de la faceta.
```
{
'FacetResults': [
{
'DocumentAttributeKey': 'City',
'DocumentAttributeValueCountPairs': [
{
'Count': 3,
'DocumentAttributeValue': {
'StringValue': 'Dubai'
}
},
{
'Count': 3,
'DocumentAttributeValue': {
'StringValue': 'Seattle'
}
},
{
'Count': 1,
'DocumentAttributeValue': {
'StringValue': 'Paris'
}
}
]
}
]
```
También puede mostrar la información de facetas de una faceta anidada, como una región dentro de una ciudad, para filtrar aún más los resultados de búsqueda.
En el siguiente ejemplo de respuesta de JSON, se muestran las facetas relacionadas con el atributo del documento «CityRegion», como una faceta anidada dentro de «Ciudad». La respuesta incluye el recuento de documentos para los valores de la faceta anidada.
```
{
'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'
}
}
]
}
]
}
}
]
}
```
Cuando utiliza un campo de lista de cadenas para crear facetas, los resultados por facetas devueltos se basan en el contenido de la lista de cadenas. Por ejemplo, si tiene un campo de lista de cadenas que contiene dos elementos, uno con la lista “teckel” y “perro salchicha” y otro con el valor “husky”, obtendrá `FacetResults` con tres facetas.
Para obtener más información, consulte [Respuestas a las consultas y tipos de respuestas](query-responses-types.md).
## Utilizar atributos del documento para filtrar los resultados de búsqueda
De forma predeterminada, `Query` devuelve todos los resultados de búsqueda. Para filtrar las respuestas, puede realizar operaciones lógicas en los atributos del documento. Por ejemplo, si solo desea documentos para una ciudad específica, puede filtrar por los atributos de documento personalizados “City” y “State”. Se utiliza [AttributeFilter](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeFilter.html)para crear una operación booleana en los filtros que se proporcionan.
Se puede usar la mayoría de los atributos para filtrar las respuestas de todos los [tipos de respuestas](https://docs.aws.amazon.com/kendra/latest/dg/query-responses-types.html). Sin embargo, el atributo `_excerpt_page_number` solo se aplica a los tipos de respuestas `ANSWER` cuando se filtran las respuestas.
El siguiente ejemplo muestra cómo realizar una operación lógica AND filtrando por una ciudad específica, *Seattle*, y un estado, *Washington*.
```
response=kendra.query(
QueryText = query,
IndexId = index,
AttributeFilter = {'AndAllFilters':
[
{"EqualsTo": {"Key": "City","Value": {"StringValue": "Seattle"}}},
{"EqualsTo": {"Key": "State","Value": {"StringValue": "Washington"}}}
]
}
)
```
El siguiente ejemplo muestra cómo realizar una operación lógica OR cuando alguna de las claves `Fileformat`, `Author` o `SourceURI` coincide con los valores especificados.
```
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"}}}
]
}
)
```
En el caso de los campos `StringList`, debe utilizar los filtros de atributos `ContainsAny` o `ContainsAll` para devolver los documentos con la cadena especificada. El siguiente ejemplo muestra cómo devolver todos los documentos que tienen los valores “Seattle” o “Portland” en su atributo personalizado `Locations`.
```
response=kendra.query(
QueryText = query,
IndexId = index,
AttributeFilter = {
"ContainsAny": { "Key": "Locations", "Value": { "StringListValue": [ "Seattle", "Portland"] }}
}
)
```
## Filtrar los atributos de cada documento en los resultados de búsqueda
Amazon Kendra devuelve los atributos de cada documento de los resultados de la búsqueda. Puede filtrar determinados atributos del documento que desee incluir en la respuesta como parte de los resultados de búsqueda. De forma predeterminada, todos los atributos del documento asignados a un documento se devuelven en la respuesta.
En el siguiente ejemplo, solo los atributos del documento `_source_uri` y `_author` se incluyen en la respuesta para un documento.
```
response=kendra.query(
QueryText = query,
IndexId = index,
RequestedDocumentAttributes = ["_source_uri", "_author"]
)
```
# Filtrar por contexto de usuario
**nota**
La compatibilidad de características varía según el tipo de índice y la API de búsqueda que se use. Para comprobar si esta característica es compatible con el tipo de índice y la API de búsqueda que usa, consulte [Tipos de índices](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Puede filtrar los resultados de búsqueda de un usuario según el acceso del usuario o de su grupo a los documentos. Puede usar un token de usuario, un ID de usuario o un atributo de usuario para filtrar documentos.
El filtrado por contexto de usuario es un tipo de búsqueda personalizada con la ventaja de controlar el acceso a los documentos. Por ejemplo, no todos los equipos que buscan información en el portal corporativo deben acceder a los documentos de alto secreto de la empresa, ni estos documentos son relevantes para todos los usuarios. Solo los usuarios o grupos de equipos específicos que tengan acceso a documentos de alto secreto deberían ver estos documentos en sus resultados de búsqueda.
Cuando se indexa un documento Amazon Kendra, se incorpora la lista de control de acceso (ACL) correspondiente para la mayoría de los documentos. La ACL especifica a qué nombres de usuario y de grupo se les permite o deniega el acceso al documento. Los documentos sin una ACL son documentos públicos.
Amazon Kendra puede extraer la información de usuario o grupo asociada a cada documento para la mayoría de las fuentes de datos. Por ejemplo, un documento de Quip puede incluir una lista “compartida” de usuarios seleccionados que tienen acceso al documento. Si utiliza un bucket de S3 como origen de datos, debe proporcionar un [archivo JSON](https://docs.aws.amazon.com/kendra/latest/dg/s3-acl.html) para su ACL e incluir la ruta de S3 a este archivo como parte de la configuración del origen de datos. Si agrega documentos directamente a un índice, especifica la ACL en el objeto [principal](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Principal.html) como parte del objeto de documento de la [BatchPutDocument](https://docs.aws.amazon.com/kendra/latest/APIReference/API_BatchPutDocument.html)API.
Si utiliza un índice de Amazon Kendra Enterprise o Developer Edition, puede utilizar la [CreateAccessControlConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateAccessControlConfiguration.html)API para volver a configurar el control de acceso a nivel de documento existente sin tener que volver a indexar todos los documentos. Por ejemplo, su índice contiene documentos empresariales de alto secreto a los que solo deben acceder determinados empleados o usuarios. Uno de estos usuarios deja la empresa o pasa a un equipo al que se le debería impedir el acceso a los documentos de alto secreto. El usuario sigue teniendo acceso a los documentos de alto secreto porque tenía acceso a ellos cuando los documentos estaban indexados anteriormente. Puede crear una configuración de control de acceso específica para el usuario con acceso denegado. Más adelante, puede actualizar la configuración de control de acceso para permitirle el acceso en caso de que el usuario regrese a la empresa y vuelva a unirse al equipo “de alto secreto”. Puede volver a configurar el control de acceso a sus documentos a medida que cambian las circunstancias.
[Para aplicar la configuración de control de acceso a determinados documentos, debe llamar a la [BatchPutDocument](https://docs.aws.amazon.com/kendra/latest/APIReference/API_BatchPutDocument.html)API con el objeto `AccessControlConfigurationId` incluido en el documento.](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Document.html) Si utiliza un bucket de S3 como fuente de datos, lo actualiza `.metadata.json` con la fuente de datos `AccessControlConfigurationId` y la sincroniza. Amazon Kendra Actualmente, solo admite la configuración de control de acceso para las fuentes de datos y los documentos de S3 indexados mediante la `BatchPutDocument` API.
## Filtrado por token de usuario
**importante**
Los índices GenAI Enterprise Edition de Amazon Kendra no son compatibles con el control de acceso de usuarios basado en tokens.
Al consultar un índice, puede usar un token de usuario para filtrar los resultados de búsqueda según el acceso del usuario o de su grupo a los documentos. Al realizar una consulta, Amazon Kendra extrae y valida el token, extrae y comprueba la información del usuario y del grupo y ejecuta la consulta. Se devuelven todos los documentos a los que el usuario tiene acceso, incluidos los documentos públicos. Para obtener más información, consulte [Control de acceso de usuarios basado en tokens](https://docs.aws.amazon.com/kendra/latest/dg/create-index-access-control.html).
Debe proporcionar el token de usuario en el [UserContext](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UserContext.html)objeto y pasarlo a la API de [consultas](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html).
El siguiente ejemplo muestra cómo incluir un token de usuario.
```
response = kendra.query(
QueryText = query,
IndexId = index,
UserToken = {
Token = "token"
})
```
Puede asignar usuarios a grupos. Al utilizar el filtrado por contexto de usuario, no es necesario incluir todos los grupos a los que pertenece un usuario al realizar la consulta. Con la [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API, puedes asignar usuarios a sus grupos. Si no desea utilizar la API `PutPrincipalMapping`, debe proporcionar el nombre de usuario y todos los grupos a los que pertenece el usuario cuando realice una consulta. También puede obtener los niveles de acceso de los grupos y usuarios de la fuente de identidad de su centro de identidad de IAM mediante el [UserGroupResolutionConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UserGroupResolutionConfiguration.html)objeto.
## Filtrado por ID de usuario y grupo
Al consultar un índice, puede usar el ID de usuario y el grupo para filtrar los resultados de búsqueda según el acceso del usuario o de su grupo a los documentos. Al realizar una consulta, Amazon Kendra comprueba la información del usuario y del grupo y ejecuta la consulta. Se devuelven todos los documentos relevantes para la consulta a los que el usuario tiene acceso, incluidos los documentos públicos.
También puede filtrar los resultados de búsqueda por los orígenes de datos a las que tienen acceso los usuarios y los grupos. Especificar un origen de datos resulta útil si un grupo está vinculado a varios orígenes de datos, pero solo desea que el grupo acceda a los documentos de un origen de datos determinado. Por ejemplo, pongamos que los grupos “Investigación”, “Ingeniería” y “Ventas y marketing” están todos vinculados a los documentos de la empresa almacenados en los orígenes de datos Confluence y Salesforce. Sin embargo, solo el equipo de “Ventas y marketing” necesita acceder a los documentos relacionados con los clientes almacenados en Salesforce. De este modo, cuando los usuarios de ventas y marketing busquen documentos relacionados con los clientes, podrán ver los documentos de Salesforce en sus resultados. Los usuarios que no trabajan en ventas y marketing no ven los documentos de Salesforce en sus resultados de búsqueda.
Debe proporcionar la información sobre el usuario, los grupos y las fuentes de datos en el [UserContext](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UserContext.html)objeto y transferirla a la API de [consultas](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html). El ID de usuario y la lista de grupos y orígenes de datos deben coincidir con el nombre que especifique en el objeto [Principal](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Principal.html) para identificar al usuario, los grupos y los orígenes de datos. Con el objeto `Principal`, puede añadir un usuario, un grupo o un origen de datos a una lista de permisos o de denegaciones para acceder a un documento.
Debe proporcionar uno de los siguientes datos:
+ Información de usuarios y grupos, e información (opcional) sobre los orígenes de datos.
+ Solo la información del usuario si asigna sus usuarios a grupos y fuentes de datos mediante la [PutPrincipalMapping](https://docs.aws.amazon.com/kendra/latest/APIReference/API_PutPrincipalMapping.html)API. También puede obtener los niveles de acceso de los grupos y usuarios de la fuente de identidad de su centro de identidad de IAM mediante el [UserGroupResolutionConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UserGroupResolutionConfiguration.html)objeto.
Si esta información no está incluida en la consulta, Amazon Kendra devuelve todos los documentos. Si proporciona esta información, solo se devolverán los documentos con usuarios IDs, grupos y fuentes de datos coincidentes.
El siguiente ejemplo muestra cómo incluir los ID de usuario, los grupos y los orígenes de datos.
```
response = kendra.query(
QueryText = query,
IndexId = index,
UserContext={'Token': 'string', 'UserId': 'string', 'Groups': [ 'string', ], 'DataSourceGroups': [ { 'GroupId': 'string', 'DataSourceId': 'string' }, ] },)
```
## Filtrado por atributo de usuario
Al consultar un índice, puede usar los atributos integrados `_user_id` y `_group_id` para filtrar los resultados de búsqueda según el acceso del usuario y de su grupo a los documentos. Puede configurar hasta 100 identificadores de grupo. Al realizar una consulta, Amazon Kendra comprueba la información del usuario y del grupo y ejecuta la consulta. Se devuelven todos los documentos relevantes para la consulta a los que el usuario tiene acceso, incluidos los documentos públicos.
Debe proporcionar los atributos de usuario y grupo en el [AttributeFilter](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeFilter.html)objeto y pasarlos a la API de [consultas](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html).
El siguiente ejemplo muestra una solicitud que filtra la respuesta a la consulta en función del ID de usuario y de los grupos “HR” e “IT” a los que pertenece el usuario. La consulta devolverá cualquier documento que contenga el usuario o los grupos “HR” o “IT” en su la lista de permitidos. Si el usuario o alguno de los grupos figuran en la lista de denegados de un documento, ese documento no se devolverá.
```
response = kendra.query(
QueryText = query,
IndexId = index,
AttributeFilter = {
"OrAllFilters": [
{
"EqualsTo": {
"Key": "_user_id",
"Value": {
"StringValue": "user1"
}
}
},
{
"EqualsTo": {
"Key": "_group_ids",
"Value": {
"StringListValue": ["HR", "IT"]
}
}
}
]
}
)
```
También puede especificar a qué origen de datos puede acceder un grupo en el objeto `Principal`.
**nota**
El filtrado por contexto de usuario no es un control de autenticación o autorización del contenido. No autentica a los usuarios ni a los grupos enviados a la API `Query`. Es responsabilidad de su aplicación garantizar que la información de usuarios y grupos enviada a la API `Query` esté autenticada y autorizada.
Existe una implementación del filtrado por contexto de usuario para cada origen de datos. En la siguiente sección se describe cada implementación.
**Topics**
+ [Filtrado por token de usuario](#context-filter-token)
+ [Filtrado por ID de usuario y grupo](#context-filter-user-incl-datasources)
+ [Filtrado por atributo de usuario](#context-filter-attribute)
+ [Filtrado por contexto de usuario para los documentos añadidos directamente a un índice](#context-filter-batch)
+ [Filtrado por contexto de usuario para las preguntas más frecuentes](#context-filter-faq)
+ [Filtrado por contexto de usuario para los orígenes de datos](#datasource-context-filter)
## Filtrado por contexto de usuario para los documentos añadidos directamente a un índice
Al añadir documentos directamente a un índice mediante la [BatchPutDocument](https://docs.aws.amazon.com/kendra/latest/APIReference/API_BatchPutDocument.html)API, Amazon Kendra obtiene información de usuarios y grupos del `AccessControlList` campo del documento. Debe proporcionar una lista de control de acceso (ACL) para los documentos y la ACL se incorpora con los documentos.
Debe especificar la ACL en el objeto [Principal](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Principal.html) como parte del objeto [Documento](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Document.html) de la API `BatchPutDocument`. Debe proporcionar la siguiente información:
+ El acceso que debe tener el usuario o el grupo. Puede decir `ALLOW` o `DENY`.
+ El tipo de entidad. Puede decir `USER` o `GROUP`.
+ Nombre del usuario o grupo.
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
## Filtrado por contexto de usuario para las preguntas más frecuentes
Al [añadir una pregunta frecuente](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateFaq.html) a un índice, Amazon Kendra obtiene la información de los usuarios y grupos del archivo JSON `AccessControlList` object/field de las preguntas frecuentes. También puede usar un archivo CSV de preguntas frecuentes con campos o atributos personalizados para el control de acceso.
Debe proporcionar la siguiente información:
+ El acceso que debe tener el usuario o el grupo. Puede decir `ALLOW` o `DENY`.
+ El tipo de entidad. Puede decir `USER` o `GROUP`.
+ Nombre del usuario o grupo.
Para obtener más información, consulte [Archivos de preguntas frecuentes](https://docs.aws.amazon.com/kendra/latest/dg/in-creating-faq.html).
## Filtrado por contexto de usuario para los orígenes de datos
Amazon Kendra también rastrea la información de la lista de control de acceso (ACL) de usuarios y grupos desde los conectores de fuentes de datos compatibles. Esto resulta útil para el filtrado por contexto de usuario, en el que se filtran los resultados de búsqueda en función del acceso del usuario o de su grupo a los documentos.
**importante**
Los índices GenAI Enterprise Edition de Amazon Kendra solo son compatibles con los conectores de orígenes de datos de Amazon Kendra v2.0.
**Topics**
+ [Filtrado por contexto de usuario para los orígenes de datos de Adobe Experience Manager](#context-filter-aem)
+ [Filtrado por contexto de usuario para los orígenes de datos de Alfresco](#context-filter-alfresco)
+ [Filtrado de contexto de usuario para fuentes de datos Aurora (MySQL)](#context-filter-aurora-mysql)
+ [Filtrado de contexto de usuario para Aurora fuentes de datos (PostgreSQL)](#context-filter-aurora-postgresql)
+ [Filtrado del contexto de usuario para Amazon FSx las fuentes de datos](#context-filter-fsx)
+ [Filtrado por contexto de usuario para los orígenes de datos de bases de datos](#context-filter-jdbc)
+ [Filtrado de contexto de usuario para fuentes de datos Amazon RDS (Microsoft SQL Server)](#context-filter-rds-ms-sql-server)
+ [Filtrado de contexto de usuario para fuentes de datos Amazon RDS (MySQL)](#context-filter-rds-mysql)
+ [Filtrado de contexto de usuario para fuentes de datos Amazon RDS (Oracle)](#context-filter-rds-oracle)
+ [Filtrado de contexto de usuario para Amazon RDS fuentes de datos (PostgreSQL)](#context-filter-rds-postgresql)
+ [Filtrado del contexto de usuario para Amazon S3 las fuentes de datos](#context-filter-s3)
+ [Filtrado por contexto de usuario para los orígenes de datos de Box](#context-filter-box)
+ [Filtrado por contexto de usuario para los orígenes de datos de Confluence](#context-filter-confluence)
+ [Filtrado por contexto de usuario para los orígenes de datos de Dropbox](#context-filter-dropbox)
+ [Filtrado por contexto de usuario para los orígenes de datos de Drupal](#context-filter-drupal)
+ [Filtrado del contexto de usuario para GitHub las fuentes de datos](#context-filter-github)
+ [Filtrado por contexto de usuario para los orígenes de datos de Gmail](#context-filter-gmail)
+ [Filtrado por contexto de usuario para los orígenes de datos de Google Drive](#context-filter-google)
+ [Filtrado del contexto de usuario para las fuentes de DB2 datos de IBM](#context-filter-ibm-db2)
+ [Filtrado por contexto de usuario para los orígenes de datos de Jira](#context-filter-jira)
+ [Filtrado por contexto de usuario para orígenes de datos de Microsoft Exchange](#context-filter-exchange)
+ [Filtrado de contexto de usuario para fuentes OneDrive de datos de Microsoft](#context-filter-onedrive)
+ [Filtrado de contexto de usuario para fuentes de datos de Microsoft OneDrive v2.0](#context-filter-onedrivev2)
+ [Filtrado de contexto de usuario para fuentes SharePoint de datos de Microsoft](#context-filter-sharepoint-online)
+ [Filtrado por contexto de usuario para orígenes de datos de Microsoft SQL Server.](#context-filter-ms-sql-server)
+ [Filtrado por contexto de usuario para orígenes de datos de Microsoft Teams](#context-filter-teams)
+ [Filtrado por contexto de usuario para orígenes de datos de Microsoft Yammer](#context-filter-yammer)
+ [Filtrado por contexto de usuario para los orígenes de datos de MySQL](#context-filter-mysql)
+ [Filtrado por contexto de usuario para los orígenes de datos de Oracle Database](#context-filter-oracle-database)
+ [Filtrado por contexto de usuario para los orígenes de datos de PostgreSQL](#context-filter-postgresql)
+ [Filtrado por contexto de usuario para los orígenes de datos de Quip](#context-filter-quip)
+ [Filtrado por contexto de usuario para los orígenes de datos de Salesforce](#context-filter-salesforce)
+ [Filtrado del contexto de usuario para las fuentes ServiceNow de datos](#context-filter-servicenow)
+ [Filtrado por contexto de usuario para los orígenes de datos de Slack](#context-filter-slack)
+ [Filtrado por contexto de usuario para los orígenes de datos de Zendesk](#context-filter-zendesk)
### Filtrado por contexto de usuario para los orígenes de datos de Adobe Experience Manager
Cuando utiliza una fuente de datos de Adobe Experience Manager, Amazon Kendra obtiene la información de usuario y grupo de la instancia de Adobe Experience Manager.
El grupo y el usuario IDs se mapean de la siguiente manera:
+ `_group_ids` IDs —Existe un grupo en el contenido de Adobe Experience Manager donde hay permisos de acceso establecidos. Se asignan a partir de los nombres de los grupos en Adobe Experience Manager.
+ `_user_id`—El usuario IDs existe en el contenido de Adobe Experience Manager donde hay permisos de acceso establecidos. Se mapean a partir de los correos electrónicos de los usuarios como IDs en Adobe Experience Manager.
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado por contexto de usuario para los orígenes de datos de Alfresco
Cuando utiliza una fuente de datos de Alfresco, Amazon Kendra obtiene la información de usuario y grupo de la instancia de Alfresco.
El grupo y el usuario IDs se mapean de la siguiente manera:
+ `_group_ids`—El grupo IDs existe en Alfresco en archivos en los que hay permisos de acceso establecidos. Se asignan a partir de los nombres de sistema de los grupos (no de los nombres de visualización) de Alfresco.
+ `_user_id`—El usuario IDs existe en Alfresco en los archivos en los que hay permisos de acceso establecidos. Se mapean a partir de los correos electrónicos de los usuarios, como en Alfresco. IDs
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado de contexto de usuario para fuentes de datos Aurora (MySQL)
Cuando utiliza una fuente de datos Aurora (MySQL), Amazon Kendra obtiene información de usuarios y grupos de una columna de la tabla de fuentes. Esta columna se especifica en la consola o se utiliza el [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objeto como parte de la [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Una fuente de datos de base de datos Aurora (MySQL) tiene las siguientes limitaciones:
+ Solo puede especificar una lista de permisos para un origen de datos de la base de datos. No puede especificar una lista de denegaciones.
+ Solo puede especificar grupos. No puede especificar usuarios individuales para la lista de permisos.
+ La columna de la base de datos debe ser una cadena que contenga una lista de grupos delimitada por punto y coma.
### Filtrado de contexto de usuario para Aurora fuentes de datos (PostgreSQL)
Cuando utiliza una fuente de datos Aurora (PostgreSQL) Amazon Kendra , obtiene información de usuarios y grupos de una columna de la tabla de fuentes. Esta columna se especifica en la consola o se utiliza el [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objeto como parte de la [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Una fuente de datos de base de datos Aurora (PostgreSQL) tiene las siguientes limitaciones:
+ Solo puede especificar una lista de permisos para un origen de datos de la base de datos. No puede especificar una lista de denegaciones.
+ Solo puede especificar grupos. No puede especificar usuarios individuales para la lista de permisos.
+ La columna de la base de datos debe ser una cadena que contenga una lista de grupos delimitada por punto y coma.
### Filtrado del contexto de usuario para Amazon FSx las fuentes de datos
Cuando utiliza una fuente de Amazon FSx datos, Amazon Kendra obtiene información de usuarios y grupos del servicio de directorio de la Amazon FSx instancia.
El Amazon FSx grupo y el usuario IDs se mapean de la siguiente manera:
+ `_group_ids`—El grupo IDs existe en los archivos Amazon FSx en los que hay permisos de acceso establecidos. Se asignan a partir de los nombres de los grupos del sistema en el servicio de directorios de. Amazon FSx
+ `_user_id`—El usuario IDs existe en los archivos Amazon FSx en los que hay permisos de acceso establecidos. Se asignan a partir de los nombres de usuario del sistema en el servicio de directorio de. Amazon FSx
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado por contexto de usuario para los orígenes de datos de bases de datos
Cuando utiliza una fuente de datos de base de datos, por ejemplo Amazon Aurora PostgreSQL, Amazon Kendra obtiene información de usuarios y grupos de una columna de la tabla de fuentes. Esta columna se especifica en el [AclConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AclConfiguration.html)objeto como parte del [DatabaseConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_DatabaseConfiguration.html)objeto de la [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Un origen de datos de bases de datos tiene las siguientes limitaciones:
+ Solo puede especificar una lista de permisos para un origen de datos de la base de datos. No puede especificar una lista de denegaciones.
+ Solo puede especificar grupos. No puede especificar usuarios individuales para la lista de permisos.
+ La columna de la base de datos debe ser una cadena que contenga una lista de grupos delimitada por punto y coma.
### Filtrado de contexto de usuario para fuentes de datos Amazon RDS (Microsoft SQL Server)
Cuando utiliza una fuente de datos Amazon RDS (Microsoft SQL Server), Amazon Kendra obtiene información de usuarios y grupos de una columna de la tabla de fuentes. Esta columna se especifica en la consola o se utiliza el [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objeto como parte de la [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Una fuente de datos de base de datos Amazon RDS (Microsoft SQL Server) tiene las siguientes limitaciones:
+ Solo puede especificar una lista de permisos para un origen de datos de la base de datos. No puede especificar una lista de denegaciones.
+ Solo puede especificar grupos. No puede especificar usuarios individuales para la lista de permisos.
+ La columna de la base de datos debe ser una cadena que contenga una lista de grupos delimitada por punto y coma.
### Filtrado de contexto de usuario para fuentes de datos Amazon RDS (MySQL)
Cuando utiliza una fuente de datos Amazon RDS (MySQL), Amazon Kendra obtiene información de usuarios y grupos de una columna de la tabla de fuentes. Esta columna se especifica en la consola o se utiliza el [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objeto como parte de la [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Una fuente de datos de base de datos Amazon RDS (MySQL) tiene las siguientes limitaciones:
+ Solo puede especificar una lista de permisos para un origen de datos de la base de datos. No puede especificar una lista de denegaciones.
+ Solo puede especificar grupos. No puede especificar usuarios individuales para la lista de permisos.
+ La columna de la base de datos debe ser una cadena que contenga una lista de grupos delimitada por punto y coma.
### Filtrado de contexto de usuario para fuentes de datos Amazon RDS (Oracle)
Cuando utiliza una fuente de datos Amazon RDS (Oracle), Amazon Kendra obtiene información de usuarios y grupos de una columna de la tabla de fuentes. Esta columna se especifica en la consola o se utiliza el [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objeto como parte de la [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Una fuente de datos de base de datos Amazon RDS (Oracle) tiene las siguientes limitaciones:
+ Solo puede especificar una lista de permisos para un origen de datos de la base de datos. No puede especificar una lista de denegaciones.
+ Solo puede especificar grupos. No puede especificar usuarios individuales para la lista de permisos.
+ La columna de la base de datos debe ser una cadena que contenga una lista de grupos delimitada por punto y coma.
### Filtrado de contexto de usuario para Amazon RDS fuentes de datos (PostgreSQL)
Cuando utiliza una fuente de datos Amazon RDS (PostgreSQL) Amazon Kendra , obtiene información de usuarios y grupos de una columna de la tabla de fuentes. Esta columna se especifica en la consola o se utiliza el [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objeto como parte de la [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Una fuente de datos de base de datos Amazon RDS (PostgreSQL) tiene las siguientes limitaciones:
+ Solo puede especificar una lista de permisos para un origen de datos de la base de datos. No puede especificar una lista de denegaciones.
+ Solo puede especificar grupos. No puede especificar usuarios individuales para la lista de permisos.
+ La columna de la base de datos debe ser una cadena que contenga una lista de grupos delimitada por punto y coma.
### Filtrado del contexto de usuario para Amazon S3 las fuentes de datos
El filtrado de contexto de usuario se añade a un documento de una fuente de Amazon S3 datos mediante un archivo de metadatos asociado al documento. Debe añadir la información al campo `AccessControlList` del documento JSON. Para obtener más información sobre cómo añadir metadatos a los documentos indexados desde un origen de datos de Amazon S3 , consulte [Metadatos de documentos de S3](https://docs.aws.amazon.com/kendra/latest/dg/s3-metadata.html).
Debe proporcionar tres datos:
+ El acceso que debe tener la entidad. Puede decir `ALLOW` o `DENY`.
+ El tipo de entidad. Puede decir `USER` o `GROUP`.
+ El nombre de la entidad.
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado por contexto de usuario para los orígenes de datos de Box
Cuando utiliza una fuente de datos de Box, Amazon Kendra obtiene información de usuario y grupo de la instancia de Box.
El grupo y el usuario de Box IDs se mapean de la siguiente manera:
+ `_group_ids`—El grupo IDs existe en Box en los archivos en los que hay permisos de acceso establecidos. Se asignan a partir de los nombres de los grupos en Box.
+ `_user_id`—El usuario IDs aparece en Box en los archivos en los que hay permisos de acceso establecidos. Se mapean a partir de los correos electrónicos de los usuarios como usuarios de Box IDs .
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado por contexto de usuario para los orígenes de datos de Confluence
Cuando utilizas una fuente de datos de Confluence, Amazon Kendra obtiene información de usuarios y grupos de la instancia de Confluence.
Debe configurar el acceso de los usuarios y grupos a los espacios mediante la página de permisos de los espacios. Para las páginas y los blogs, debe utilizar la página de restricciones. Para obtener más información sobre los permisos de espacio, consulte [Información general de los permisos de espacio](https://confluence.atlassian.com/doc/space-permissions-overview-139521.html) en el sitio web de soporte de Confluence. Para obtener más información sobre las restricciones de páginas y blogs, consulte [Información general de las restricciones de espacio](https://confluence.atlassian.com/doc/page-restrictions-139414.html) en el sitio web de soporte de Confluence.
Los nombres de grupo y usuario de Confluence se asignan de la siguiente manera:
+ `_group_ids`: los nombres de grupo están presentes en los espacios, páginas y blogs donde hay restricciones. Se asignan a partir del nombre del grupo en Confluence. Los nombres de grupo siempre están en minúscula.
+ `_user_id`: los nombres de usuario están presentes en el espacio, página o blog donde hay restricciones. Se asignan en función del tipo de instancia de Confluence que utilice.
**Para el conector de Confluence v1.0**
+ Servidor: `_user_id` es el nombre de usuario. El nombre de usuario siempre está en minúscula.
+ Nube: `_user_id` es el ID de cuenta del usuario.
**Para el conector de Confluence v2.0**
+ Servidor: `_user_id` es el nombre de usuario. El nombre de usuario siempre está en minúscula.
+ Nube: `_user_id` es el ID de correo electrónico del usuario.
**importante**
Para que el filtrado por contexto de usuario funcione correctamente en su conector de Confluence, debe asegurarse de que la visibilidad de un usuario al que se le ha concedido acceso a una página de Confluence esté configurada como **Cualquiera.** Para obtener más información, consulte [Configurar la visibilidad del correo electrónico](https://support.atlassian.com/confluence-cloud/docs/configure-user-email-visibility/) en la documentación para desarrolladores de Atlassian.
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado por contexto de usuario para los orígenes de datos de Dropbox
Cuando utilizas una fuente de datos de Dropbox, Amazon Kendra obtiene la información del usuario y del grupo de la instancia de Dropbox.
El grupo y el usuario IDs se mapean de la siguiente manera:
+ `_group_ids`—Los grupos IDs existen en Dropbox en archivos para los que hay permisos de acceso establecidos. Se asignan a partir de los nombres de los grupos en Dropbox.
+ `_user_id`—El usuario IDs existe en Dropbox en los archivos en los que hay permisos de acceso establecidos. Se mapean a partir de los correos electrónicos de los usuarios, igual que IDs en Dropbox.
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado por contexto de usuario para los orígenes de datos de Drupal
Cuando utilizas una fuente de datos de Drupal, Amazon Kendra obtiene la información del usuario y del grupo de la instancia de Drupal.
El grupo y el usuario IDs se mapean de la siguiente manera:
+ `_group_ids`— El grupo IDs existe en Drupal en archivos donde hay permisos de acceso establecidos. Se asignan a partir de los nombres de los grupos en Drupal.
+ `_user_id`— El usuario IDs existe en Drupal en los archivos donde hay permisos de acceso establecidos. Se mapean a partir de los correos electrónicos de los usuarios como IDs en Drupal.
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado del contexto de usuario para GitHub las fuentes de datos
Cuando utiliza una fuente de GitHub datos, Amazon Kendra obtiene información de usuario de la GitHub instancia.
Los GitHub usuarios IDs se mapean de la siguiente manera:
+ `_user_id`—El usuario IDs existe en los archivos GitHub en los que hay permisos de acceso establecidos. Se mapean a partir de los correos electrónicos de los usuarios como en el IDs interior. GitHub
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado por contexto de usuario para los orígenes de datos de Gmail
Cuando utilizas una fuente de datos de Gmail, Amazon Kendra obtiene la información del usuario de la instancia de Gmail.
Los usuarios IDs se mapean de la siguiente manera:
+ `_user_id`— El usuario IDs existe en Gmail en archivos en los que hay permisos de acceso establecidos. Se mapean a partir de los correos electrónicos de los usuarios, igual que IDs en Gmail.
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado por contexto de usuario para los orígenes de datos de Google Drive
Un origen de datos de Google Workspace Drive devuelve información de usuarios y grupos para usuarios y grupos de Google Drive. La pertenencia a grupos y dominios se asigna al campo del índice `_group_ids`. El nombre de usuario de Google Drive se asigna al campo `_user_id`.
Si proporciona una o más direcciones de correo electrónico de usuario en la API `Query`, solo se devuelven los documentos que se hayan compartido con esas direcciones de correo electrónico. El siguiente parámetro `AttributeFilter` solo devuelve los documentos compartidos con “martha@example.com”.
```
"AttributeFilter": {
"EqualsTo":{
"Key": "_user_id",
"Value": {
"StringValue": "martha@example.com"
}
}
}
```
Si proporciona una o más direcciones de correo electrónico de grupos en la consulta, solo se devolverán los documentos compartidos con los grupos. El siguiente parámetro `AttributeFilter` solo devuelve los documentos compartidos con el grupo “hr@example.com”.
```
"AttributeFilter": {
"EqualsTo":{
"Key": "_group_ids",
"Value": {
"StringListValue": ["hr@example.com"]
}
}
}
```
Si proporciona el dominio en la consulta, se devolverán todos los documentos compartidos con el dominio. El siguiente parámetro `AttributeFilter` devuelve los documentos compartidos con el dominio “example.com”.
```
"AttributeFilter": {
"EqualsTo":{
"Key": "_group_ids",
"Value": {
"StringListValue": ["example.com"]
}
}
}
```
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado del contexto de usuario para las fuentes de DB2 datos de IBM
Cuando utiliza una fuente de DB2 datos de IBM, Amazon Kendra obtiene información de usuarios y grupos de una columna de la tabla de origen. Esta columna se especifica en la consola o se utiliza el [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objeto como parte de la [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Una fuente DB2 de datos de base de datos de IBM tiene las siguientes limitaciones:
+ Solo puede especificar una lista de permisos para un origen de datos de la base de datos. No puede especificar una lista de denegaciones.
+ Solo puede especificar grupos. No puede especificar usuarios individuales para la lista de permisos.
+ La columna de la base de datos debe ser una cadena que contenga una lista de grupos delimitada por punto y coma.
### Filtrado por contexto de usuario para los orígenes de datos de Jira
Cuando utiliza una fuente de datos de Jira, Amazon Kendra obtiene información de usuarios y grupos de la instancia de Jira.
Los usuarios de Jira IDs se mapean de la siguiente manera:
+ `_user_id`—El usuario IDs existe en Jira en archivos en los que hay permisos de acceso establecidos. Se mapean a partir de los correos electrónicos de los usuarios como usuarios IDs de Jira.
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado por contexto de usuario para orígenes de datos de Microsoft Exchange
Cuando utiliza una fuente de datos de Microsoft Exchange, Amazon Kendra obtiene la información del usuario de la instancia de Microsoft Exchange.
Los usuarios de Microsoft Exchange IDs se asignan de la siguiente manera:
+ `_user_id` IDs —Existen permisos de usuario en Microsoft Exchange para que los usuarios accedan a determinado contenido. Se asignan a partir de los nombres de usuario como IDs en Microsoft Exchange.
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado de contexto de usuario para fuentes OneDrive de datos de Microsoft
Amazon Kendra recupera información de usuarios y grupos de Microsoft OneDrive cuando indexa los documentos del sitio. La información de usuario y grupo se toma del SharePoint sitio de Microsoft subyacente que aloja OneDrive.
Cuando utilice un OneDrive usuario o un grupo para filtrar los resultados de la búsqueda, calcule el identificador de la siguiente manera:
1. Obtenga el nombre del sitio. Por ejemplo, `https://host.onmicrosoft.com/sites/siteName.`
1. Toma el MD5 hash del nombre del sitio. Por ejemplo, `430a6b90503eef95c89295c8999c7981`.
1. Cree el correo electrónico del usuario o el ID de grupo concatenando el MD5 hash con una barra vertical (\$1) y el ID. Por ejemplo, si el nombre de un grupo es "localGroupName«, el ID del grupo sería:
`"430a6b90503eef95c89295c8999c7981 | localGroupName"`
**nota**
Incluya un espacio antes y después de la barra vertical. La barra vertical se utiliza para identificarse `localGroupName` con su MD5 hash.
Para el nombre de usuario “someone@host.onmicrosoft.com”, el ID de usuario sería el siguiente:
`"430a6b90503eef95c89295c8999c7981 | someone@host.onmicrosoft.com"`
Envía el ID de usuario o grupo Amazon Kendra como `_group_id` atributo `_user_id` o cuando llames a la API de [consultas](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html). Por ejemplo, el AWS CLI comando que usa un grupo para filtrar los resultados de la búsqueda tiene el siguiente aspecto:
```
aws kendra query \
--index-id index ID
--query-text "query text"
--attribute-filter '{
"EqualsTo":{
"Key": "_group_id",
"Value": {"StringValue": "430a6b90503eef95c89295c8999c7981 | localGroupName"}
}}'
```
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado de contexto de usuario para fuentes de datos de Microsoft OneDrive v2.0
Una fuente de datos de Microsoft OneDrive v2.0 devuelve información de secciones y páginas de las entidades de la lista de control de OneDrive acceso (ACL). Amazon Kendra usa el dominio OneDrive arrendatario para conectarse a la OneDrive instancia y, a continuación, puede filtrar los resultados de la búsqueda en función del acceso de los usuarios o grupos a las secciones y los nombres de los archivos.
En el caso de los objetos estándar, los `_user_id` y `_group_id` se utilizan de la siguiente manera:
+ `_user_id`— Su ID OneDrive de correo electrónico de usuario de Microsoft está asignado al `_user_id` campo.
+ `_group_id`— El correo electrónico de su OneDrive grupo de Microsoft está asignado al `_group_id` campo.
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado de contexto de usuario para fuentes SharePoint de datos de Microsoft
Amazon Kendra recupera información de usuarios y grupos de Microsoft SharePoint cuando indexa los documentos del sitio. Para filtrar los resultados de la búsqueda en función del acceso de los usuarios o los grupos, proporcione información del usuario y el grupo cuando llame a la API `Query`.
Para filtrar mediante un nombre de usuario, utilice la dirección de correo electrónico del usuario. Por ejemplo, johnstiles@example.com.
Cuando utilice un SharePoint grupo para filtrar los resultados de la búsqueda, calcule el identificador del grupo de la siguiente manera:
**Para grupos locales**
1. Obtenga el nombre del sitio. Por ejemplo, `https://host.onmicrosoft.com/sites/siteName.`
1. Toma el SHA256 hash del nombre del sitio. Por ejemplo, `430a6b90503eef95c89295c8999c7981`.
1. Cree el ID del grupo concatenando el SHA256 hash con una barra vertical (\$1) y el nombre del grupo. Por ejemplo, si el nombre del grupo es "localGroupName«, el ID del grupo sería:
`"430a6b90503eef95c89295c8999c7981 | localGroupName"`
**nota**
Incluya un espacio antes y después de la barra vertical. La barra vertical se utiliza para identificarse `localGroupName` con su SHA256 hash.
Envía el ID de grupo Amazon Kendra como `_group_id` atributo cuando llames a la [API de consulta](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html). Por ejemplo, el AWS CLI comando tiene este aspecto:
```
aws kendra query \
--index-id index ID
--query-text "query text"
--attribute-filter '{
"EqualsTo":{
"Key": "_group_id",
"Value": {"StringValue": "430a6b90503eef95c89295c8999c7981 | localGroupName"}
}}'
```
**Para grupos de AD**
1. Utilice el ID de grupo de AD para configurar el filtrado de los resultados de búsqueda.
Envía el ID de grupo a Amazon Kendra como `_group_id` atributo cuando llames a la API de [consulta](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html). Por ejemplo, el AWS CLI comando tiene este aspecto:
```
aws kendra query \
--index-id index ID
--query-text "query text"
--attribute-filter '{
"EqualsTo":{
"Key": "_group_id",
"Value": {"StringValue": "AD group"}
}}'
```
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado por contexto de usuario para orígenes de datos de Microsoft SQL Server.
Cuando utiliza una fuente de datos de Microsoft SQL Server, Amazon Kendra obtiene información de usuarios y grupos de una columna de la tabla de fuentes. Esta columna se especifica en la consola o se utiliza el [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objeto como parte de la [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Un origen de datos de la base de datos de Microsoft SQL Server tiene las siguientes limitaciones:
+ Solo puede especificar una lista de permisos para un origen de datos de la base de datos. No puede especificar una lista de denegaciones.
+ Solo puede especificar grupos. No puede especificar usuarios individuales para la lista de permisos.
+ La columna de la base de datos debe ser una cadena que contenga una lista de grupos delimitada por punto y coma.
### Filtrado por contexto de usuario para orígenes de datos de Microsoft Teams
Amazon Kendra recupera la información de usuario de Microsoft Teams cuando indexa los documentos. La información de usuario se toma de la instancia de Microsoft Teams subyacente.
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado por contexto de usuario para orígenes de datos de Microsoft Yammer
Amazon Kendra recupera la información del usuario de Microsoft Yammer cuando indexa los documentos. La información de usuario y grupo se toma de la instancia de Microsoft Yammer subyacente.
Los usuarios de Microsoft Yammer IDs se mapean de la siguiente manera:
+ `_email_id`: el ID de correo electrónico de Microsoft asignado al campo `_user_id`.
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado por contexto de usuario para los orígenes de datos de MySQL
Cuando utiliza una fuente de datos MySQL, Amazon Kendra obtiene información de usuarios y grupos de una columna de la tabla de fuentes. Esta columna se especifica en la consola o se utiliza el [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objeto como parte de la [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Un origen de datos de la base de datos de MySQL tiene las siguientes limitaciones:
+ Solo puede especificar una lista de permisos para un origen de datos de la base de datos. No puede especificar una lista de denegaciones.
+ Solo puede especificar grupos. No puede especificar usuarios individuales para la lista de permisos.
+ La columna de la base de datos debe ser una cadena que contenga una lista de grupos delimitada por punto y coma.
### Filtrado por contexto de usuario para los orígenes de datos de Oracle Database
Cuando utiliza una fuente de datos de Oracle Database, Amazon Kendra obtiene información de usuarios y grupos de una columna de la tabla de fuentes. Esta columna se especifica en la consola o se utiliza el [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objeto como parte de la [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Un origen de datos de la base de datos de Oracle Database tiene las siguientes limitaciones:
+ Solo puede especificar una lista de permisos para un origen de datos de la base de datos. No puede especificar una lista de denegaciones.
+ Solo puede especificar grupos. No puede especificar usuarios individuales para la lista de permisos.
+ La columna de la base de datos debe ser una cadena que contenga una lista de grupos delimitada por punto y coma.
### Filtrado por contexto de usuario para los orígenes de datos de PostgreSQL
Cuando utiliza una fuente de datos de PostgreSQL Amazon Kendra , obtiene información de usuarios y grupos de una columna de la tabla de fuentes. Esta columna se especifica en la consola o se utiliza el [TemplateConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_TemplateConfiguration.html)objeto como parte de la [CreateDataSource](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CreateDataSource.html)API.
Un origen de datos de la base de datos de PostgreSQL tiene las siguientes limitaciones:
+ Solo puede especificar una lista de permisos para un origen de datos de la base de datos. No puede especificar una lista de denegaciones.
+ Solo puede especificar grupos. No puede especificar usuarios individuales para la lista de permisos.
+ La columna de la base de datos debe ser una cadena que contenga una lista de grupos delimitada por punto y coma.
### Filtrado por contexto de usuario para los orígenes de datos de Quip
Cuando utiliza una fuente de datos de Quip, Amazon Kendra obtiene la información de usuario de la instancia de Quip.
Los usuarios de Quip IDs se mapean de la siguiente manera:
+ `_user_id`—El usuario IDs existe en Quip en archivos en los que hay permisos de acceso establecidos. Se mapean a partir de los correos electrónicos de los usuarios, como en Quip. IDs
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado por contexto de usuario para los orígenes de datos de Salesforce
Un origen de datos de Salesforce devuelve información de usuarios y grupos a partir de las entidades de la lista de control de acceso (ACL) de Salesforce. Puede aplicar el filtrado por contexto de usuario a los objetos estándar o las fuentes de chat de Salesforce. El filtrado por contexto de usuario no está disponible para los artículos de conocimiento de Salesforce.
Si asigna algún campo de Salesforce a los campos del título y cuerpo del documento de Amazon Kendra, Amazon Kendra utilizará datos de los campos del título y el cuerpo del documento en las respuestas de búsqueda.
En el caso de los objetos estándar, los `_user_id` y `_group_ids` se utilizan de la siguiente manera:
+ `_user_id`: el nombre de usuario del usuario de Salesforce.
+ `_group_ids`—
+ Nombre de `Profile` de Salesforce
+ Nombre de `Group` de Salesforce
+ Nombre de `UserRole` de Salesforce
+ Nombre de `PermissionSet` de Salesforce
Para las fuentes de chat, los `_user_id` y `_group_ids` se utilizan de la siguiente manera:
+ `_user_id`: el nombre de usuario del usuario de Salesforce. Solo está disponible si el elemento está publicado en la fuente del usuario.
+ `_group_ids` IDs —Los grupos se utilizan de la siguiente manera. Solo está disponible si el elemento de la fuente se publica en un grupo de colaboración o chat.
+ El nombre del grupo de colaboración o chat.
+ Si el grupo es público, `PUBLIC:ALL`.
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado del contexto de usuario para las fuentes ServiceNow de datos
El filtrado del contexto de usuario solo ServiceNow se admite en la TemplateConfiguration API y en la versión 2.0 de ServiceNow Connector. ServiceNowConfiguration La API y ServiceNow Connector v1.0 no admiten el filtrado de contexto de usuario.
Cuando usa una fuente de ServiceNow datos, Amazon Kendra obtiene la información de usuario y grupo de la ServiceNow instancia.
El grupo y el usuario IDs se asignan de la siguiente manera:
+ `_group_ids`—El grupo IDs existe en los archivos ServiceNow en los que hay permisos de acceso establecidos. Se asignan a partir de los nombres de los roles de `sys_ids` in. ServiceNow
+ `_user_id`—El usuario IDs existe en los archivos ServiceNow en los que hay permisos de acceso establecidos. Se mapean a partir de los correos electrónicos de los usuarios como en el IDs interior. ServiceNow
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado por contexto de usuario para los orígenes de datos de Slack
Cuando utilizas una fuente de datos de Slack, Amazon Kendra obtiene la información del usuario de la instancia de Slack.
Los usuarios de Slack IDs se mapean de la siguiente manera:
+ `_user_id`—El usuario IDs existe en Slack en los mensajes y canales en los que hay permisos de acceso establecidos. Se mapean a partir de los correos electrónicos de los usuarios, como en Slack. IDs
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
### Filtrado por contexto de usuario para los orígenes de datos de Zendesk
Cuando se utiliza una fuente de datos de Zendesk, Amazon Kendra obtiene la información del usuario y del grupo de la instancia de Zendesk.
El grupo y el usuario IDs se mapean de la siguiente manera:
+ `_group_ids`—Los grupos IDs existen en los tickets y artículos de Zendesk en los que hay permisos de acceso establecidos. Se asignan a partir de los nombres de los grupos en Zendesk.
+ `_user_id` IDs —Existen grupos en los tickets y artículos de Zendesk en los que hay permisos de acceso establecidos. Se mapean a partir de los correos electrónicos de los usuarios, como en Zendesk. IDs
Puede añadir hasta 200 entradas en el campo `AccessControlList`.
# Respuestas a las consultas y tipos de respuestas
**nota**
La compatibilidad de características varía según el tipo de índice y la API de búsqueda que se use. Para comprobar si esta característica es compatible con el tipo de índice y la API de búsqueda que usa, consulte [Tipos de índices](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Amazon Kendra admite diferentes respuestas a consultas y tipos de respuesta.
## Respuestas a las consultas
Llamar a la API de [consulta](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) devuelve información sobre los resultados de una búsqueda. Los resultados se encuentran en una matriz de [QueryResultItem](https://docs.aws.amazon.com/kendra/latest/APIReference/API_QueryResultItem.html)objetos (`ResultItems`). Cada `QueryResultItem` incluye un resumen del resultado. También incluye los atributos del documento asociados al resultado de la consulta.
**Información del resumen**
La información del resumen varía según el tipo de resultado. En cada caso, incluye el texto del documento que coincide con el término de búsqueda. También incluye información resaltada que puede usar para resaltar el texto de la búsqueda en el resultado de la aplicación. Por ejemplo, si la búsqueda es *¿Cuál es la altura de la Space Needle?*, la información del resumen incluye la ubicación en el texto de las palabras *altura* y *space needle*. Para obtener más información sobre los tipos de respuestas, consulte [Respuestas a las consultas y tipos de respuestas](#query-responses-types).
**Atributos del documento**
Cada resultado contiene los atributos del documento que coincide con una consulta. Algunos de los atributos están predefinidos como `DocumentId`, `DocumentTitle`, y `DocumentUri`. Otros son atributos personalizados que puede definir. Puede usar los atributos del documento para filtrar la respuesta de la API `Query`. Por ejemplo, es posible que solo desee los documentos escritos por un autor específico o la versión específica de un documento. Para obtener más información, consulte [Filtrado y búsqueda por facetas](filtering.md). Debe especificar los atributos del documento al añadir documentos a un índice. Para obtener más información, consulte [Campos o atributos personalizados](https://docs.aws.amazon.com/kendra/latest/dg/custom-attributes.html).
El siguiente ejemplo muestra un código JSON para el resultado de una consulta. Observe los atributos del documento en `DocumentAttributes` y`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
}
```
## Tipos de respuestas
Amazon Kendra devuelve tres tipos de respuesta a la consulta.
+ Respuesta (incluye respuestas de tabla)
+ Documento
+ Pregunta y respuesta
El tipo de respuesta se devuelve en el campo de `Type` respuesta del [QueryResultItem](https://docs.aws.amazon.com/kendra/latest/APIReference/API_QueryResultItem.html)objeto.
### Respuesta
Amazon Kendra detectó una o más respuestas a una pregunta en la respuesta. Una trivialidad es la respuesta a una pregunta sobre quién, qué, cuándo o dónde. Por ejemplo: *¿Dónde está el centro de servicios más cercano a mi ubicación?* Amazon Kendra devuelve el texto del índice que mejor coincide con la consulta. El texto está en el campo `AnswerText` y contiene información destacada sobre el término de búsqueda en el texto de la respuesta. `AnswerText` incluye el extracto completo del documento con el texto resaltado, mientras que `DocumentExcerpt` incluye el extracto del documento truncado (290 caracteres) con el texto resaltado.
Amazon Kendra solo devuelve una respuesta por documento, y esa es la respuesta con mayor confianza. Para obtener varias respuestas de un documento, debe dividir el documento en varios documentos.
```
{
'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'
}
```
### Documento
Amazon Kendra devuelve los documentos clasificados de los que coinciden con el término de búsqueda. La clasificación se basa en la confianza que Amazon Kendra se deposita en la precisión del resultado de la búsqueda. La información sobre el documento coincidente se devuelve en el [QueryResultItem](https://docs.aws.amazon.com/kendra/latest/APIReference/API_QueryResultItem.html). Incluye el título del documento. El extracto incluye información destacada para el texto de búsqueda y la sección de texto coincidente del documento. El URI de los documentos coincidentes se encuentra en el atributo del documento `SourceURI`. En el siguiente ejemplo de JSON se muestra el resumen de un documento coincidente.
```
{
'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'
}
```
### Pregunta y respuesta
Se devuelve una respuesta de pregunta y respuesta cuando se hace Amazon Kendra coincidir una pregunta con una de las preguntas frecuentes del índice. La respuesta incluye la pregunta y la respuesta coincidentes en el [QueryResultItem](https://docs.aws.amazon.com/kendra/latest/APIReference/API_QueryResultItem.html)campo. También incluye información destacada sobre los términos de consulta detectados en la cadena de la consulta. El siguiente ejemplo de JSON muestra una respuesta de pregunta y respuesta. Observe que la respuesta incluye el texto de la pregunta.
```
{
'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?'
}
}
```
Para obtener información sobre cómo añadir el texto de una pregunta y una respuesta a un índice, consulte [Añadir preguntas frecuentes a un índice](https://docs.aws.amazon.com/kendra/latest/dg/in-creating-faq.html).
# Ajustar y ordenar las respuestas
**nota**
La compatibilidad de características varía según el tipo de índice y la API de búsqueda que se use. Para comprobar si esta característica es compatible con el tipo de índice y la API de búsqueda que usa, consulte [Tipos de índices](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Puede modificar el efecto de un campo o atributo en la relevancia de las búsquedas ajustando su relevancia. También puede ordenar los resultados de búsqueda por un atributo o campo determinado.
**Topics**
+ [Ajustar las respuestas](#tuning-responses)
+ [Ordenar las respuestas](#sorting-responses)
## Ajustar las respuestas
Puede modificar el efecto de un campo o atributo en la relevancia de las búsquedas ajustando su relevancia. Para probar rápidamente el ajuste de relevancia, use la API de [consulta](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) para aplicar las configuraciones de ajuste en la consulta. Así puede ver los distintos resultados de búsqueda que obtiene de las distintas configuraciones. La consola no permite ajustar la relevancia en la consulta. También puede ajustar los campos o atributos del tipo `StringList` solo en el índice. Para más información, consulte [Ajuste de la relevancia de la búsqueda](https://docs.aws.amazon.com/kendra/latest/dg/tuning.html).
De forma predeterminada, las respuestas a las consultas se ordenan según la puntuación de relevancia que se Amazon Kendra determina para cada resultado de la respuesta.
Puede ajustar los resultados para cualquier configuración integrada o personalizada attribute/field de los siguientes tipos:
+ Valor de fecha
+ Valor largo
+ Valor de cadena
No se pueden ordenar los atributos del siguiente tipo:
+ Valores de listas de cadenas
**Clasifique y ajuste los resultados de los documentos (AWS SDK)**
Establezca el parámetro `Searchable` como true para priorizar la configuración de los metadatos del documento.
Para ajustar un atributo en una consulta, defina el parámetro `DocumentRelevanceOverrideConfigurations` de la API `Query` y especifique el nombre del atributo que desea ajustar.
En el siguiente ejemplo de JSON, se muestra un objeto `DocumentRelevanceOverrideConfigurations` que anula el ajuste del atributo denominado “department” en el índice.
```
"DocumentRelevanceOverrideConfigurations" : [
"Name": "department",
"Relevance": {
"Importance": 1,
"ValueImportanceMap": {
"IT": 3,
"HR": 7
}
}
]
```
## Ordenar las respuestas
Amazon Kendra utiliza el campo o atributo de ordenación como parte de los criterios de los documentos devueltos por la consulta. Por ejemplo, es posible que los resultados devueltos por una consulta ordenada por “\$1created\$1at” no contengan los mismos resultados que una consulta ordenada por “\$1version”.
De forma predeterminada, las respuestas a las consultas se ordenan según la puntuación de relevancia que se Amazon Kendra determina para cada resultado de la respuesta. Para cambiar el orden de clasificación, haga que un atributo del documento se pueda ordenar y, a continuación, Amazon Kendra configúrelo para usar ese atributo para ordenar las respuestas.
Puede ordenar los resultados en cualquiera de los siguientes tipos integrados o personalizados attribute/field :
+ Valor de fecha
+ Valor largo
+ Valor de cadena
No se pueden ordenar los atributos del siguiente tipo:
+ Valores de listas de cadenas
Puede ordenar los resultados por uno o más atributos del documento en cada consulta. Las consultas devuelven 100 resultados. Si hay menos de 100 documentos con el atributo de ordenación establecido, los documentos sin un valor para el atributo de ordenación se devuelven al final de los resultados, ordenados por su relevancia para la consulta.
**Para ordenar los resultados de los documentos (AWS SDK)**
1. Para usar la [UpdateIndex](https://docs.aws.amazon.com/kendra/latest/APIReference/API_UpdateIndex.html)API para hacer que un atributo se pueda ordenar, defina `true` el `Sortable` parámetro en. En el siguiente ejemplo de JSON se utiliza `DocumentMetadataConfigurationUpdates` para añadir al índice un atributo denominado “Department” y hacer que se pueda ordenar.
```
"DocumentMetadataConfigurationUpdates": [
{
"Name": "Department",
"Type": "STRING_VALUE",
"Search": {
"Sortable": "true"
}
}
]
```
1. Para usar un atributo que se puede ordenar en una consulta, defina el parámetro `SortingConfiguration` de la API de [consulta](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html). Especifique el nombre del atributo según el cual se van a ordenar los resultados y si se deben ordenar en la respuesta en orden ascendente o descendente.
El siguiente ejemplo de JSON muestra el parámetro `SortingConfiguration` que se usa para ordenar los resultados de una consulta por el atributo “Department” en orden ascendente.
```
"SortingConfiguration": {
"DocumentAttributeKey": "Department",
"SortOrder": "ASC"
}
```
1. Para usar más de un atributo que se puede ordenar en una consulta, defina el parámetro `SortingConfigurations` de la API de [consulta](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html). Puede configurar hasta 3 campos para que Amazon Kendra los use para ordenar los resultados. También puede especificar si los resultados se deben ordenar en orden ascendente o descendente. Puede aumentar la cuota de campos de ordenación.
Si no proporciona una configuración de clasificación, los resultados se ordenan según la relevancia que Amazon Kendra determine el resultado. En caso de empate en la ordenación de los resultados, estos se ordenan por relevancia.
El siguiente ejemplo de JSON muestra el parámetro `SortingConfigurations` que se usa para ordenar los resultados de una consulta por los atributos “Name” y “Price” en orden ascendente.
```
"CollapseConfiguration" : {
"DocumentAttributeKey": "Name",
"SortingConfigurations": [
{
"DocumentAttributeKey": "Price",
"SortOrder": "ASC"
}
],
"MissingAttributeKeyStrategy": "IGNORE"
}
```
**Para ordenar los resultados de los documentos (consola)**
**nota**
La ordenación por varios atributos no es compatible actualmente con la Consola de administración de AWS.
1. Para hacer que un atributo se pueda ordenar en la consola, elija **Ordenable** en la definición del atributo. Puede hacer que un atributo se pueda ordenar al crearlo o bien modificarlo más adelante.
1. Para ordenar la respuesta a una consulta en la consola, elija el atributo para ordenar la respuesta en el menú **Ordenar**. En la lista solo aparecen los atributos que se marcaron como ordenables durante la configuración del origen de datos.
# Contraer o expandir los resultados de la consulta
**nota**
La compatibilidad de características varía según el tipo de índice y la API de búsqueda que se use. Para comprobar si esta característica es compatible con el tipo de índice y la API de búsqueda que usa, consulte [Tipos de índices](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Cuando se conecta Amazon Kendra a sus datos, rastrea los [atributos de los metadatos del documento](https://docs.aws.amazon.com/kendra/latest/dg/hiw-document-attributes.html) (como `_document_title``_created_at`, y) y `_document_id` utiliza estos atributos o campos para proporcionar funciones de búsqueda avanzada durante el tiempo de consulta.
La característica de contraer y expandir los resultados de las consultas de Amazon Kendra le permite agrupar los resultados de búsqueda mediante un atributo de documento común y mostrarlos, contraídos o parcialmente expandidos, en un documento principal designado.
**nota**
La característica de contraer y expandir los resultados de las consultas solo está disponible actualmente a través de la API [Amazon Kendra](https://docs.aws.amazon.com/kendra/latest/APIReference/welcome.html).
Esto resulta útil en las siguientes situaciones de búsqueda:
+ Cuando existen varias versiones del contenido en los documentos de su índice. Cuando el usuario final consulte el índice, querrá que vea la versión más relevante del documento con duplicados. hidden/collapsed. For example, if your index contains multiple versions of a document named "NYC leave policy" you can choose to collapse the documents for the specific groups "HR" and "Legal" using the "Type" attribute/field
![\[Ejemplo 1\]](http://docs.aws.amazon.com/es_es/kendra/latest/dg/images/expand-collapse-1.png)
+ Su índice contiene varios documentos con información única sobre un tipo de elemento u objeto, como el inventario de un producto, por ejemplo. Para capturar y ordenar la información de los elementos de forma cómoda, su intención es que los usuarios finales accedan a todos los documentos enlazados por un elemento u objeto como un resultado de búsqueda. En el siguiente ejemplo, un cliente busca “animal print shirts” y los resultados se agrupan por nombre y se ordenan por orden de precio ascendente.
![\[Ejemplo 2\]](http://docs.aws.amazon.com/es_es/kendra/latest/dg/images/expand-collapse-2.png)
## Contraer los resultados
Para agrupar documentos similares o relacionados, debes especificar el atributo por el que deseas reducirlos (por ejemplo, puedes usar collapse/group los documentos`_category`). Para ello, llama a la [API de consultas](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) y usa el [CollapseConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CollapseConfiguration.html)objeto para especificar el objeto sobre el `DocumentAttributeKey` que se va a contraer. La `DocumentAttributeKey` controla el campo por el que se contraerán los resultados de búsqueda. Los campos clave de atributos admitidos incluyen `String` y `Number`. Los tipos `String list` y `Date` tipo no son compatibles.
## Elegir un documento principal mediante la ordenación
Para configurar el documento principal para que se muestre en un grupo contraído, utilice el `SortingConfigurations` parámetro siguiente [CollapseConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CollapseConfiguration.html). Por ejemplo, para obtener la versión más reciente de un documento, debe ordenar cada grupo contraído por `_version`. Puede especificar hasta 3 attributes/fields para ordenar y un orden para cada attribute/field uso`SortingConfigurations`. Puede solicitar un aumento de cuota para el número de atributos de ordenación.
De forma predeterminada, Amazon Kendra ordena las respuestas a las consultas según la puntuación de relevancia que determina para cada resultado de la respuesta. Para cambiar el orden de clasificación predeterminado, haga que los atributos del documento se puedan ordenar y, a continuación, Amazon Kendra configúrelos para usar estos atributos para ordenar las respuestas. Para obtener más información, consulte [Ordenar las respuestas](https://docs.aws.amazon.com/kendra/latest/dg/tuning-sorting-responses.html#sorting-responses).
## No hay una estrategia clave para el documento
Si el documento no tiene un valor de atributo de contracción, Amazon Kendra ofrece tres opciones de personalización:
+ Seleccione que se `COLLAPSE` todos los documentos con valores nulos o sin valores en un grupo. Esta configuración es la predeterminada.
+ Seleccione que se `IGNORE` los documentos con valores nulos o sin valores. Los documentos ignorados no aparecerán en los resultados de la consulta.
+ Seleccione que se `EXPAND` cada documento con un valor nulo o sin valor en su propio grupo.
## Expandir los resultados
Puede elegir si los grupos de resultados de búsqueda contraídos se expanden utilizando el `Expand` parámetro del [CollapseConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_CollapseConfiguration.html)objeto. Los resultados expandidos mantienen el mismo orden que se ha utilizado para seleccionar el documento principal del grupo.
Para configurar el número de grupos de resultados de búsqueda contraídos que se van a expandir, utilice el `MaxResultItemstoExpand` parámetro del [ExpandConfiguration](https://docs.aws.amazon.com/kendra/latest/APIReference/API_ExpandConfiguration.html)objeto. Si establece este valor como 10, por ejemplo, solo los primeros 10 de los 100 grupos de resultados tendrán la funcionalidad de expansión.
Para configurar el número de resultados expandidos que se mostrarán por documento principal contraído, utilice el parámetro `MaxExpandResultsPerItem`. Por ejemplo, si establece este valor como 3, se mostrarán como máximo 3 resultados por grupo contraído.
## Interacciones con otras Amazon Kendra funciones
+ Al contraer y expandir los resultados no se modifica el número de facetas ni se ve afectado el número total de resultados mostrados.
+ [Los resultados de búsqueda destacados](https://docs.aws.amazon.com/kendra/latest/dg/featured-results.html) de Amazon Kendra no se contraerán aunque tengan el mismo valor de campo que el campo para contraer que haya configurado.
+ La contracción y la expansión de los resultados solo se aplica a los resultados del tipo `DOCUMENT`.