Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Esecuzione di query su un indice
**Nota**
Il supporto delle funzionalità varia in base al tipo di indice e all'API di ricerca utilizzata. Per verificare se questa funzionalità è supportata per il tipo di indice e l'API di ricerca che stai utilizzando, consulta [Tipi di indice](https://docs.aws.amazon.com/kendra/latest/dg/hiw-index-types.html).
Quando esegui una ricerca nell'indice, Amazon Kendra utilizza tutte le informazioni che hai fornito sui documenti per determinare i documenti più pertinenti ai termini di ricerca inseriti. Alcuni degli elementi che vengono presi in Amazon Kendra considerazione sono:
+ Il testo o il corpo del documento.
+ Il titolo del documento.
+ Campi di testo personalizzati contrassegnati come ricercabili.
+ Il campo della data che hai indicato deve essere usato per determinare la «freschezza» di un documento.
+ Qualsiasi altro campo che possa fornire informazioni pertinenti.
Amazon Kendra può anche filtrare la risposta in base a qualsiasi field/attribute filtro che potresti aver impostato per la ricerca. Ad esempio, se disponi di un campo personalizzato chiamato «reparto», puoi filtrare la risposta per restituire solo i documenti di un reparto chiamato «legale». Per ulteriori informazioni, consulta [Campi o attributi personalizzati](https://docs.aws.amazon.com/kendra/latest/dg/custom-attributes.html).
I risultati di ricerca restituiti vengono ordinati in base alla pertinenza che Amazon Kendra determina per ogni documento. I risultati sono suddivisi in pagine in modo da poter mostrare all'utente una pagina alla volta.
[Per cercare i documenti con Amazon Kendra cui hai indicizzato, usa AMAZON. Amazon Lex KendraSearchIntent](https://docs.aws.amazon.com/lexv2/latest/APIReference/API_KendraConfiguration.html). Per un esempio di configurazione Amazon Kendra con Amazon Lex, consulta [Creazione di un bot per le domande frequenti per un Amazon Kendra indice](https://docs.aws.amazon.com/lexv2/latest/dg/faq-bot-kendra-search.html).
L'esempio seguente mostra come cercare un indice. Amazon Kendra determina il tipo di risultato della ricerca (risposta, documento, domanda-risposta) più adatto alla query. Non è possibile Amazon Kendra configurare la restituzione di un tipo specifico di risposta di ricerca (risposta, documento, domanda-risposta) a una query.
Per informazioni sulle risposte alle interrogazioni, vedere. [Risposte alle interrogazioni e tipi di risposta](query-responses-types.md)
**Topics**
+ [Prerequisiti](#searching-prerequisites)
+ [Ricerca in un indice (console)](#searching-index-console)
+ [Ricerca in un indice (SDK)](#searching-index-sdk)
+ [Ricerca in un indice (Postman)](#searching-index-postman)
+ [Ricerca con sintassi di interrogazione avanzata](#searching-index-query-syntax)
+ [Ricerca in lingue](#searching-index-languages)
## Prerequisiti
Prima di utilizzare l'API [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html) per interrogare un indice:
+ Configura le autorizzazioni richieste per un indice e connettiti alla tua fonte di dati o carica in batch i tuoi documenti. Per ulteriori informazioni, consulta [IAM ruoli](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html). Utilizzi l'Amazon Resource Name del ruolo quando chiami l'API per creare un connettore di indicizzazione e origine dati o per caricare documenti in batch.
+ Configura un SDK o accedi alla Amazon Kendra console. AWS Command Line Interface Per ulteriori informazioni, consulta [Configurazione Amazon Kendra](https://docs.aws.amazon.com/kendra/latest/dg/setup.html).
+ Crea un indice e connettiti a una fonte di dati di documenti o carica documenti in batch. Per ulteriori informazioni, vedere [Creazione di un indice](https://docs.aws.amazon.com/kendra/latest/dg/create-index.html) e [Creazione di un connettore di origine dati](https://docs.aws.amazon.com/kendra/latest/dg/data-source.html).
## Ricerca in un indice (console)
Puoi usare la Amazon Kendra console per cercare e testare il tuo indice. Puoi fare domande e vedere i risultati.
**Per cercare un indice con la console**
1. Accedi Console di gestione AWS e apri la Amazon Kendra console all'[indirizzo http://console.aws.amazon.com/kendra/](https://console.aws.amazon.com/kendra).
1. Nel riquadro di navigazione, scegli **Indici**.
1. Scegli il tuo indice.
1. Nel menu di navigazione, scegli l'opzione per cercare nell'indice.
1. Inserisci una query nella casella di testo, quindi premi invio.
1. Amazon Kendra restituisce i risultati della ricerca.
Puoi anche ottenere l'ID della query per la ricerca selezionando l'icona a forma di lampadina nel pannello laterale.
## Ricerca in un indice (SDK)
**Per cercare un indice con Python o Java**
+ L'esempio seguente esegue una ricerca in un indice. Modificate `query` il valore della query di ricerca `index_id` e/o `indexId` dell'identificatore dell'indice in cui desiderate cercare.
Puoi anche ottenere l'ID della query per la ricerca come parte degli elementi di risposta quando chiami l'API [Query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Query.html).
------
#### [ Python ]
```
import boto3
import pprint
kendra = boto3.client("kendra")
# Provide the index ID
index_id = "index-id"
# Provide the query text
query = "query text"
response = kendra.query(
QueryText = query,
IndexId = index_id)
print("\nSearch results for query: " + query + "\n")
for query_result in response["ResultItems"]:
print("-------------------")
print("Type: " + str(query_result["Type"]))
if query_result["Type"]=="ANSWER" or query_result["Type"]=="QUESTION_ANSWER":
answer_text = query_result["DocumentExcerpt"]["Text"]
print(answer_text)
if query_result["Type"]=="DOCUMENT":
if "DocumentTitle" in query_result:
document_title = query_result["DocumentTitle"]["Text"]
print("Title: " + document_title)
document_text = query_result["DocumentExcerpt"]["Text"]
print(document_text)
print("------------------\n\n")
```
------
#### [ Java ]
```
package com.amazonaws.kendra;
import software.amazon.awssdk.services.kendra.KendraClient;
import software.amazon.awssdk.services.kendra.model.QueryRequest;
import software.amazon.awssdk.services.kendra.model.QueryResponse;
import software.amazon.awssdk.services.kendra.model.QueryResultItem;
public class SearchIndexExample {
public static void main(String[] args) {
KendraClient kendra = KendraClient.builder().build();
String query = "query text";
String indexId = "index-id";
QueryRequest queryRequest = QueryRequest
.builder()
.queryText(query)
.indexId(indexId)
.build();
QueryResponse queryResponse = kendra.query(queryRequest);
System.out.println(String.format("\nSearch results for query: %s", query));
for(QueryResultItem item: queryResponse.resultItems()) {
System.out.println("----------------------");
System.out.println(String.format("Type: %s", item.type()));
switch(item.type()) {
case QUESTION_ANSWER:
case ANSWER:
String answerText = item.documentExcerpt().text();
System.out.println(answerText);
break;
case DOCUMENT:
String documentTitle = item.documentTitle().text();
System.out.println(String.format("Title: %s", documentTitle));
String documentExcerpt = item.documentExcerpt().text();
System.out.println(String.format("Excerpt: %s", documentExcerpt));
break;
default:
System.out.println(String.format("Unknown query result type: %s", item.type()));
}
System.out.println("-----------------------\n");
}
}
}
```
------
## Ricerca in un indice (Postman)
Puoi usare [Postman](https://www.postman.com/) per interrogare e testare il tuo Amazon Kendra indice.
**Per cercare un indice usando Postman**
1. **Crea una nuova raccolta in Postman e imposta il tipo di richiesta su POST.**
1. Inserisci l'URL dell'endpoint. Ad esempio, *https://kendra. .amazonaws.com.*
1. Seleziona la scheda **Autorizzazione** e inserisci le seguenti informazioni.
+ **Tipo**: seleziona la **AWS firma**.
+ **AccessKey**—Inserisci la chiave di accesso generata quando crei un IAM utente.
+ **SecretKey**—Immettere la chiave segreta generata quando si crea un IAM utente.
+ **AWS Regione**: inserire la regione dell'indice. Ad esempio, *us-west-2*.
+ **Nome servizio***: inserisci kendra.* Fa distinzione tra maiuscole e minuscole, quindi deve essere minuscola.
**avvertimento**
Se inserisci il nome di servizio errato o non usi lettere minuscole, viene generato un errore dopo aver selezionato **Invia per inviare** la richiesta: «La credenziale deve essere limitata al servizio corretto 'kendra'».
È inoltre necessario verificare di aver inserito la chiave di accesso e la chiave segreta corrette.
1. Seleziona la scheda **Intestazioni** e inserisci le seguenti informazioni sulla chiave e sul valore.
+ *Chiave: X-Amz-Target*
*Valore: com.amazonaws.kendra. AWSKendraFrontendService*.Interrogazione
+ *Chiave: codifica del contenuto*
*Valore: amz-1.0*
1. Selezionate la scheda **Corpo** ed effettuate le seguenti operazioni.
+ Scegliete il tipo JSON non **elaborato** per il corpo della richiesta.
+ Inserisci un codice JSON che includa l'ID dell'indice e il testo della query.
```
{
"IndexId": "index-id",
"QueryText": "enter a query here"
}
```
**avvertimento**
Se il tuo JSON non utilizza l'indendazione corretta, viene generato un errore: "». SerializationException Controlla l'indendazione nel tuo codice JSON.
1. Seleziona **Invia** (in alto a destra).
## Ricerca con sintassi di interrogazione avanzata
È possibile creare interrogazioni più specifiche delle semplici query con parole chiave o in linguaggio naturale utilizzando la sintassi o gli operatori di query avanzati. Ciò include intervalli, valori booleani, caratteri jolly e altro ancora. Utilizzando gli operatori, è possibile contestualizzare la query e rifinire ulteriormente i risultati della ricerca.
Amazon Kendra supporta i seguenti operatori.
+ Boolean: logica per limitare o ampliare la ricerca. Ad esempio, `amazon AND sports` limita la ricerca alla ricerca solo di documenti contenenti entrambi i termini.
+ Parentesi: legge i termini di interrogazione annidati in ordine di precedenza. Ad esempio, legge prima. `(amazon AND sports) NOT rainforest` `(amazon AND sports)` `NOT rainforest`
+ Intervalli: valori di date o intervalli numerici. Gli intervalli possono essere inclusivi, esclusivi o illimitati. Ad esempio, puoi cercare i documenti che sono stati aggiornati l'ultima volta tra il 1° gennaio 2020 e il 31 dicembre 2020, comprese queste date.
+ Campi: utilizza un campo specifico per limitare la ricerca. Ad esempio, puoi cercare documenti con «Stati Uniti» nel campo «posizione».
+ Carte jolly: corrispondono parzialmente a una stringa di testo. Ad esempio, `Cloud*` potrebbe corrispondere CloudFormation. Amazon Kendra attualmente supporta solo i caratteri jolly finali.
+ Virgolette esatte: corrispondono esattamente a una stringa di testo. Ad esempio, documenti che contengono`"Amazon Kendra" "pricing"`.
È possibile utilizzare una combinazione di uno qualsiasi degli operatori precedenti.
Tieni presente che un uso eccessivo di operatori o query estremamente complesse potrebbero influire sulla latenza delle query. Le wildcard sono alcuni degli operatori più costosi in termini di latenza. Una regola generale è che maggiore è il numero di termini e operatori utilizzati, maggiore è il potenziale impatto sulla latenza. Altri fattori che influiscono sulla latenza includono la dimensione media dei documenti indicizzati, la dimensione dell'indice, qualsiasi filtro sui risultati di ricerca e il carico complessivo dell'indice. Amazon Kendra
### Booleano
È possibile combinare o escludere parole utilizzando gli operatori booleani,. `AND` `OR` `NOT`
Di seguito sono riportati alcuni esempi di utilizzo degli operatori booleani.
**`amazon AND sports`**
Restituisce risultati di ricerca che contengono sia i termini «amazon» che «sport» nel testo, come Amazon Prime video sport o altri contenuti simili.
**`sports OR recreation`**
Restituisce risultati di ricerca che contengono i termini «sport» o «ricreazione», o entrambi, nel testo.
**`amazon NOT rainforest`**
Restituisce risultati di ricerca che contengono il termine «amazon» ma non il termine «foresta pluviale» nel testo. Questo serve per cercare documenti sull'azienda Amazon, non sulla foresta pluviale amazzonica.
### Parentesi
È possibile interrogare le parole annidate in ordine di precedenza utilizzando le parentesi. Le parentesi indicano come deve essere letta una query. Amazon Kendra
Di seguito sono riportati alcuni esempi di utilizzo degli operatori tra parentesi.
**`(amazon AND sports) NOT rainforest`**
Restituisce documenti che contengono sia i termini «amazon» che «sports» nel testo, ma non il termine «foresta pluviale». Questo serve per cercare video sportivi o altri contenuti simili su Amazon Prime, non sugli sport d'avventura nella foresta pluviale amazzonica. Le parentesi aiutano a indicare che `amazon AND sports` dovrebbe essere letto prima. `NOT rainforest` L'interrogazione non deve essere letta come. `amazon AND (sports NOT rainforest)`
**`(amazon AND (sports OR recreation)) NOT rainforest`**
Restituisce documenti che contengono i termini «sport» o «ricreazione», o entrambi, e il termine «amazon». Ma non include il termine «foresta pluviale». Questo è per cercare video sportivi o ricreativi su Amazon Prime, non per sport d'avventura nella foresta pluviale amazzonica. Le parentesi aiutano a indicare che `sports OR recreation` deve essere letto prima di combinarlo con «amazon», che viene letto prima. `NOT rainforest` La query non deve essere letta come. `amazon AND (sports OR (recreation NOT rainforest))`
### Intervalli
È possibile utilizzare un intervallo di valori per filtrare i risultati della ricerca. È possibile specificare un attributo e i valori dell'intervallo. Può essere una data o un tipo numerico.
Gli intervalli di date devono avere i seguenti formati:
+ Epoch
+ YYYY
+ yyyy-MM
+ aaaa-mm-gg
+ YYYY-MM-D'T'HH
È inoltre possibile specificare se includere o escludere i valori inferiori e superiori dell'intervallo.
Di seguito sono riportati alcuni esempi di utilizzo degli operatori di intervallo.
**`_processed_date:>2019-12-31 AND _processed_date:<2021-01-01`**
Restituisce i documenti che sono stati elaborati nel 2020, ovvero dopo il 31 dicembre 2019 e inferiori al 1° gennaio 2021.
**`_processed_date:>=2020-01-01 AND _processed_date:<=2020-12-31`**
Restituisce i documenti elaborati nel 2020, maggiori o uguali al 1° gennaio 2020 e inferiori o uguali al 31 dicembre 2020.
**`_document_likes:<1`**
Restituisce documenti con zero Mi piace o nessun feedback da parte degli utenti, ovvero con meno di 1 like.
È possibile specificare se un intervallo deve essere considerato inclusivo o escluso dei valori dell'intervallo specificato.
**Inclusivo**
**`_last_updated_at:[2020-01-01 TO 2020-12-31]`**
Restituisce i documenti aggiornati l'ultima volta nel 2020, inclusi i giorni 1° dicembre 2020 e 31 dicembre 2020.
**Esclusivo**
**`_last_updated_at:{2019-12-31 TO 2021-01-01}`**
Restituisce i documenti aggiornati l'ultima volta nel 2020, esclusi i giorni 31 dicembre 2019 e 1 gennaio 2021.
< and >Per intervalli illimitati che non sono né inclusivi né esclusivi, è sufficiente utilizzare gli operatori. Ad esempio, `_last_updated_at:>2019-12-31 AND _last_updated_at:<2021-01-01`
#### Campi
Puoi limitare la ricerca in modo da restituire solo i documenti che soddisfano un valore in un campo specifico. Il campo può essere di qualsiasi tipo.
Di seguito sono riportati alcuni esempi di utilizzo degli operatori di contesto a livello di campo.
**`status:"Incomplete" AND financial_year:2021`**
Restituisce i documenti per l'esercizio finanziario 2021 con lo stato incompleto.
**`(sports OR recreation) AND country:"United States" AND level:"professional"`**
Restituisce documenti che trattano di sport o attività ricreative professionistiche negli Stati Uniti d'America.
#### Caratteri jolly
È possibile ampliare la ricerca per tenere conto delle varianti di parole e frasi utilizzando l'operatore wildcard. Ciò è utile per la ricerca di varianti di nome. Amazon Kendra attualmente supporta solo i caratteri jolly finali. Il numero di caratteri di prefisso per un jolly finale deve essere maggiore di due.
Di seguito sono riportati alcuni esempi di utilizzo degli operatori jolly.
**`Cloud*`**
Restituisce documenti che contengono varianti come CloudFormation e CloudWatch.
**`kendra*aws`**
Restituisce documenti che contengono varianti come kendra.amazonaws.
**`kendra*aws*`**
Restituisce documenti che contengono varianti come kendra.amazonaws.com
#### Citazioni esatte
È possibile utilizzare le virgolette per cercare una corrispondenza esatta di una parte di testo.
Di seguito sono riportati alcuni esempi di utilizzo delle virgolette.
**`"Amazon Kendra" "pricing"`**
Restituisce documenti che contengono sia la frase 'Amazon Kendra' che il termine 'prezzo'. I documenti devono contenere sia «Amazon Kendra» che «prezzi» per poter visualizzare i risultati.
**`"Amazon Kendra" "pricing" cost`**
Restituisce documenti che contengono sia la frase «Amazon Kendra» che il termine «prezzo» e, facoltativamente, il termine «costo». I documenti devono contenere sia «Amazon Kendra» che «prezzi» per poter restituire i risultati, ma potrebbero non includere necessariamente il termine «costo».
#### Sintassi di interrogazione non valida
Amazon Kendra emette un avviso se ci sono problemi con la sintassi della query o se la query non è attualmente supportata da. Amazon Kendra Per ulteriori informazioni, consulta la [documentazione dell'API per gli avvisi sulle query](https://docs.aws.amazon.com/kendra/latest/APIReference/API_Warning.html).
Le seguenti query sono esempi di sintassi di query non valida.
**`_last_updated_at:<2021-12-32`**
Data non valida. Il giorno 32 non esiste nel calendario gregoriano, utilizzato da. Amazon Kendra
**`_view_count:ten`**
Valore numerico non valido. Le cifre devono essere utilizzate per rappresentare valori numerici.
**`nonExistentField:123`**
Ricerca nei campi non valida. Il campo deve esistere per poter utilizzare la ricerca nei campi.
**`Product:[A TO D]`**
Intervallo non valido. È necessario utilizzare valori numerici o date per gli intervalli.
**`OR Hello`**
Valore booleano non valido. Gli operatori devono essere utilizzati con termini e collocati tra i termini.
## Ricerca in lingue
È possibile cercare documenti in una lingua supportata. Inserisci il codice della lingua [AttributeFilter](https://docs.aws.amazon.com/kendra/latest/APIReference/API_AttributeFilter.html)per restituire i documenti filtrati nella lingua scelta. È possibile digitare la query in una lingua supportata.
Se non si specifica una lingua, per impostazione predefinita Amazon Kendra interroga i documenti in inglese. Per ulteriori informazioni sulle lingue supportate, compresi i relativi codici, consulta [Aggiungere documenti in lingue diverse dall'inglese](https://docs.aws.amazon.com/kendra/latest/dg/in-adding-languages.html).
Per cercare documenti in una lingua supportata nella console, seleziona l'indice, quindi seleziona l'opzione di ricerca nell'indice dal menu di navigazione. Scegli la lingua in cui desideri restituire i documenti selezionando le impostazioni di ricerca e quindi selezionando una lingua dal menu a discesa **Lingua**.
Gli esempi seguenti mostrano come cercare documenti in spagnolo.
**Per cercare un indice in spagnolo nella console**
1. Accedi Console di gestione AWS e apri la Amazon Kendra console all'[indirizzo http://console.aws.amazon.com/kendra/](https://console.aws.amazon.com/kendra).
1. Nel menu di navigazione, scegli **Indici** e scegli il tuo indice.
1. Nel menu di navigazione, scegli l'opzione per cercare nell'indice.
1. Nelle impostazioni di ricerca, seleziona il menu a discesa **Lingue** e scegli lo spagnolo.
1. Inserisci una query nella casella di testo, quindi premi invio.
1. Amazon Kendra restituisce i risultati della ricerca in spagnolo.
**Per cercare un indice in spagnolo utilizzando CLI, Python o Java**
+ L'esempio seguente cerca un indice in spagnolo. Modificate `searchString` il valore della query di ricerca e `indexID` il valore con l'identificatore dell'indice che desiderate cercare. Il codice della lingua per lo spagnolo è`es`. Puoi sostituirlo con il tuo codice di lingua.
------
#### [ 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");
}
}
}
```
------