Avviso di fine del supporto: il 15 settembre 2025 AWS interromperà il supporto per Amazon Lex V1. Dopo il 15 settembre 2025, non potrai più accedere alla console di Amazon Lex V1 o alle risorse di Amazon Lex V1. Se utilizzi Amazon Lex V2, consulta invece la [guida Amazon Lex V2](https://docs.aws.amazon.com/lexv2/latest/dg/what-is.html).
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à.
# Prenota un viaggio
Nell'esempio seguente viene illustrata la creazione di un bot configurato per supportare più intenti. L'esempio illustra inoltre come utilizzare gli attributi di sessione per la condivisione di informazioni tra più intenti. Dopo aver creato il bot, usi un client di test nella console Amazon Lex per testare il bot (BookTrip). Il client utilizza l'operazione API [PostText](API_runtime_PostText.md) di runtime per inviare richieste ad Amazon Lex per ogni input dell'utente.
Il BookTrip bot in questo esempio è configurato con due intenti (BookHotel e BookCar). Supponiamo ad esempio che un utente prenoti in primo luogo un hotel. Durante l'interazione, l'utente fornisce informazioni quali date di check-in, località e il numero di notti. Dopo che l'intento è realizzato, il client può conservare queste informazioni tramite gli attributi di sessione. Per ulteriori informazioni sugli attributi di sessione, consulta [PostText](API_runtime_PostText.md).
Supponiamo a questo punto che l'utente continui con la prenotazione di un'automobile. Utilizzando le informazioni fornite dall'utente nell' BookHotel intento precedente (ovvero la città di destinazione e le date di check-in e check-out), il codehook (funzione Lambda) che hai configurato per inizializzare e convalidare BookCar l'intento, inizializza i dati degli slot relativi all'intento (ovvero destinazione, città di ritiro, data di ritiro e data di ritorno). BookCar Questo illustra come la condivisione di informazioni tra più intenti consenta di creare bot in grado di iniziare una conversazione dinamica con l'utente.
In questo esempio vengono utilizzati gli attributi di sessione riportati di seguito. Solo il client e la funzione Lambda possono impostare e aggiornare gli attributi della sessione. Amazon Lex li trasferisce solo tra il client e la funzione Lambda. Amazon Lex non mantiene o modifica alcun attributo di sessione.
+ `currentReservation`— Contiene i dati sugli slot per una prenotazione in corso e altre informazioni pertinenti. Di seguito è riportata una richiesta di esempio dal client ad Amazon Lex, con l'attributo di sessione `currentReservation` mostrato nel corpo della richiesta.
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"Chicago",
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":\"Moscow\",
\"RoomType\":null,
\"CheckInDate\":null,
\"Nights\":null}"
}
}
```
+ `lastConfirmedReservation`— Contiene informazioni simili relative a un intento precedente, se del caso. Ad esempio, se l'utente ha prenotato un hotel e poi sta prenotando un'auto, questo attributo di sessione memorizza i dati relativi agli slot relativi all' BookHotel intento precedente.
+ `confirmationContext`— La funzione Lambda imposta questa impostazione `AutoPopulate` quando precompila alcuni dati dello slot in base ai dati degli slot della prenotazione precedente (se presente). Ciò consente la condivisione delle informazioni tra più intenti. Ad esempio, se l'utente aveva precedentemente prenotato un hotel e ora desidera prenotare un'auto, Amazon Lex può richiedere all'utente di confermare (o negare) che l'auto sia prenotata per la stessa città e le stesse date della prenotazione alberghiera
In questo esercizio utilizzerai i blueprint per creare un bot Amazon Lex e una funzione Lambda. Per ulteriori informazioni sui piani, consulta [Amazon Lex e AWS Lambda Blueprints](lex-lambda-blueprints.md).
**Fase succcessiva**
[Fase 1. Analisi dei piani utilizzati in questo esercizio](ex-book-trip-blueprints.md)
# Fase 1. Analisi dei piani utilizzati in questo esercizio
**Topics**
+ [Panoramica del Bot Blueprint () BookTrip](#ex-book-trip-bp-summary-bot)
+ [Panoramica del Lambda Function Blueprint () lex-book-trip-python](#ex-book-trip-summary-lambda)
## Panoramica del Bot Blueprint () BookTrip
Il blueprint (**BookTrip**) utilizzato per creare un bot fornisce la seguente preconfigurazione:
+ **Tipi di slot**: due tipi di slot personalizzati:
+ `RoomTypes` con valori di enumerazione: `king`, `queen` e `deluxe`, per l'uso nell'intento `BookHotel`.
+ `CarTypes` con valori di enumerazione: `economy`, `standard`, `midsize`, `full size`, `luxury` e `minivan`, per l'uso nell'intento `BookCar`.
+ **Intento 1 (BookHotel)** — È preconfigurato come segue:
+ **Slot preconfigurati**
+ `RoomType`, del tipo di slot personalizzato `RoomTypes`
+ `Location`, del tipo di slot integrato `AMAZON.US_CITY`
+ `CheckInDate`, del tipo di slot integrato `AMAZON.DATE`
+ `Nights`, del tipo di slot integrato `AMAZON.NUMBER`
+ **Enunciazioni preconfigurate**
+ "Book a hotel"
+ "I want to make hotel reservations"
+ "Book a \$1Nights\$1 stay in \$1Location\$1"
Se l'utente pronuncia uno di questi termini, Amazon Lex determina che `BookHotel` si tratta dell'intento e quindi richiede all'utente i dati dello slot.
+ **Messaggi di richiesta preconfigurati**
+ Prompt per lo slot `Location`: "What city will you be staying in?"
+ Prompt per lo slot `CheckInDate`: "What day do you want to check in?"
+ Prompt per lo slot `Nights`: "How many nights will you be staying?"
+ Prompt per lo slot `RoomType`: "What type of room would you like, queen, king, or deluxe?"
+ Dichiarazione di conferma: «Ok, ti ho prenotato un soggiorno di \$1notti\$1 a \$1Location\$1 a partire da \$1\$1. CheckInDate Shall I book the reservation?"
+ Rifiuto: "Okay, I have cancelled your reservation in progress."
+ **Intent 2 (BookCar)** — È preconfigurato come segue:
+ **Slot preconfigurati**
+ `PickUpCity`, del tipo integrato `AMAZON.US_CITY`
+ `PickUpDate`, del tipo integrato `AMAZON.DATE`
+ `ReturnDate`, del tipo integrato `AMAZON.DATE`
+ `DriverAge`, del tipo integrato `AMAZON.NUMBER`
+ `CarType`, del tipo personalizzato `CarTypes`
+ **Enunciazioni preconfigurate**
+ "Book a car"
+ "Reserve a car"
+ "Make a car reservation"
Se l'utente pronuncia uno di questi termini, Amazon Lex ne determina BookCar l'intento e quindi richiede all'utente i dati dello slot.
+ **Messaggi di richiesta preconfigurati**
+ Prompt per lo slot `PickUpCity`: "In what city do you need to rent a car?"
+ Prompt per lo slot `PickUpDate`: "What day do you want to start your rental?""
+ Prompt per lo slot `ReturnDate`: "What day do you want to return this car?"
+ Prompt per lo slot `DriverAge`: "How old is the driver for this rental?"
+ Richiedi lo `CarType` slot: «Che tipo di auto desideri noleggiare? Le nostre opzioni più richieste sono: economica, media e di lusso"
+ Dichiarazione di conferma: «Ok, ti metto a disposizione per un noleggio a \$1PickUpCity\$1 da \$1PickUpDate\$1 a \$1ReturnDate\$1. CarType Should I book the reservation?"
+ Rifiuto: "Okay, I have cancelled your reservation in progress."
## Panoramica del Lambda Function Blueprint () lex-book-trip-python
Oltre al progetto del bot, AWS Lambda fornisce un blueprint (**lex-book-trip-python**) che puoi usare come code hook con il blueprint del bot. Per un elenco dei blueprint dei bot e dei corrispondenti blueprint delle funzioni Lambda, consulta. [Amazon Lex e AWS Lambda Blueprints](lex-lambda-blueprints.md)
Quando si crea un bot utilizzando il BookTrip blueprint, si aggiorna la configurazione di entrambi gli intenti (BookCar e BookHotel) aggiungendo questa funzione Lambda come codice hook sia per l'immissione initialization/validation dei dati dell'utente che per il raggiungimento degli intenti.
Il codice di funzione Lambda fornito mostra una conversazione dinamica che utilizza le informazioni precedentemente note (conservate negli attributi di sessione) relative a un utente per inizializzare i valori di slot per un intento. Per ulteriori informazioni, consulta [Gestione del contesto di una conversazione](context-mgmt.md).
**Fase succcessiva**
[Fase 2: creare un bot Amazon Lex](ex-book-trip-create-bot.md)
# Fase 2: creare un bot Amazon Lex
In questa sezione, crei un bot Amazon Lex (BookTrip).
1. Accedi a Console di gestione AWS e apri la console Amazon Lex all'indirizzo [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Nella pagina **Bots (Bot)** scegli **Create (Crea)**.
1. Nella pagina **Create your Lex bot** (Crea bot di Lex):
+ Scegli **BookTrip**blueprint.
+ Lascia il nome del bot predefinito (BookTrip).
1. Scegli **Create** (Crea). La console invia una serie di richieste ad Amazon Lex per creare il bot. Tenere presente quanto segue:
1. La console mostra il BookTrip bot. Nella scheda **Editor**, esamina i dettagli degli intenti preconfigurati (BookCar e BookHotel).
1. Esegui il test del bot nella finestra di prova. Utilizza quanto segue per iniziare una conversazione di test con il bot:
![\[Conversazione con un agente, in cui l'agente fornisce informazioni sulla città, il giorno, il numero di notti e il tipo di camera per il viaggio del cliente. L'agente conferma quindi la prenotazione.\]](http://docs.aws.amazon.com/it_it/lex/latest/dg/images/book-trip-no-lambda-10.png)
Dall'input iniziale dell'utente («Prenota un hotel»), Amazon Lex deduce l'intento (BookHotel). Il bot utilizza quindi i prompt preconfigurati nell'intento per ottenere i dati dello slot dall'utente. Dopo che l'utente ha fornito tutti i dati dello slot, Amazon Lex restituisce una risposta al client con un messaggio che include tutti gli input dell'utente come messaggio. Il client visualizza il messaggio nella risposta, come mostrato.
```
CheckInDate:2016-12-18 Location:Chicago Nights:5 RoomType:queen
```
Ora continui la conversazione e provi a prenotare un'auto nella conversazione successiva.
![\[Conversazione con un agente, in cui l'agente fornisce informazioni sulla città, la data di inizio, il giorno di ritorno, l'età del conducente e il tipo di auto per il servizio di autonoleggio del cliente. L'agente conferma quindi la prenotazione.\]](http://docs.aws.amazon.com/it_it/lex/latest/dg/images/book-trip-no-lambda-20.png)
Nota,
+ Non è attiva alcuna convalida dei dati utente in questo momento. Puoi ad esempio specificare qualsiasi città per prenotare un hotel.
+ Alcune delle informazioni fornite per prenotare un'automobile corrispondono a quelle specificate in precedenza (destinazione, città di ritiro, data di ritiro e data di riconsegna). In una conversazione dinamica il bot deve inizializzare alcune di queste informazioni in base all'input utente precedente specificato per la prenotazione dell'hotel.
In questa sezione successiva creerai una funzione Lambda per eseguire alcune attività di convalida e inizializzazione dei dati utente, utilizzando la condivisione delle informazioni tra più intenti tramite gli attributi di sessione. Quindi aggiorni la configurazione dell'intento aggiungendo la funzione Lambda come code hook per initialization/validation eseguire l'input dell'utente e soddisfare l'intento.
**Fase succcessiva**
[Fase 3: Creare una funzione Lambda](ex-book-trip-create-lambda-function.md)
# Fase 3: Creare una funzione Lambda
In questa sezione crei una funzione Lambda utilizzando un blueprint (**lex-book-trip-python**) fornito nella console. AWS Lambda Puoi anche testare la funzione Lambda richiamandola utilizzando dati di evento di esempio forniti dalla console.
Questa funzione Lambda è scritta in Python.
1. Accedi a Console di gestione AWS e apri la AWS Lambda console all'indirizzo. [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)
1. Scegli **Crea funzione**.
1. Scegli **Usa uno schema**. Digitare **lex** per individuare il piano e scegliere il piano `lex-book-trip-python`.
1. Scegli **Configura** la funzione Lambda come segue.
+ Digitate il nome di una funzione Lambda ()`BookTripCodeHook`.
+ Per il ruolo, scegli **Create a new role from template(s)** (Crea un nuovo ruolo da modello), quindi digita un nome di ruolo.
+ Non modificare gli altri valori di default.
1. Scegli **Crea funzione**.
1. Se utilizzi una lingua diversa dall'inglese (USA) (en-US), aggiorna i nomi degli intenti come descritto in. [Aggiornamento di un blueprint per una locale specifica](lex-lambda-blueprints.md#blueprint-update-locale)
1. Prova la funzione Lambda. Si richiama la funzione Lambda due volte, utilizzando dati di esempio sia per la prenotazione di un'auto che per la prenotazione di un hotel.
1. Scegliere **Configura evento di test** dal menu a discesa **Seleziona un evento di test**.
1. Seleziona **Amazon Lex-Book Hotel** nell'elenco **Modello evento di esempio**.
Questo evento di esempio corrisponde al request/response modello Amazon Lex. Per ulteriori informazioni, consulta [Utilizzo delle funzioni Lambda](using-lambda.md).
1. Seleziona **Save and test** (Salva ed esegui test).
1. Verifica che la funzione Lambda sia stata eseguita correttamente. La risposta in questo caso corrisponde al modello di risposta di Amazon Lex.
1. Ripeti la fase. Questa volta scegli **Amazon Lex-Book Car** (Lex-Book Car nell'elenco **Modello evento di esempio**. La funzione Lambda elabora la prenotazione dell'auto.
**Fase succcessiva**
[Fase 4: Aggiungere la funzione Lambda come Code Hook](ex-book-trip-create-integrate.md)
# Fase 4: Aggiungere la funzione Lambda come Code Hook
In questa sezione, aggiorni le configurazioni sia degli BookCar BookHotel intenti che aggiungendo la funzione Lambda come codice hook per initialization/validation le attività di adempimento. Assicurati di scegliere la versione \$1LATEST degli intenti perché puoi aggiornare solo la versione \$1LATEST delle tue risorse Amazon Lex.
1. Nella console Amazon Lex, scegli il **BookTrip**bot.
1. Nella scheda **Editor**, scegli l'**BookHotel**intento. Aggiorna la configurazione dell'intento come segue:
1. Assicurati che la versione dell'intento (accanto al nome dell'intento) sia \$1LATEST.
1. Aggiungi la funzione Lambda come codice hook di inizializzazione e convalida come segue:
+ In **Options** (Opzioni) scegli **Initialization and validation code hook** (Hook di codice di inizializzazione e di convalida).
+ Scegli la tua funzione Lambda dall'elenco.
1. Aggiungi la funzione Lambda come hook del codice di adempimento come segue:
+ In **Fulfillment** (Soddisfazione) scegli **AWS Lambda function** (Funzione AWS Lambda).
+ Scegli la tua funzione Lambda dall'elenco.
+ Seleziona **Goodbye message** (Messaggio di saluto).
1. Scegli **Save** (Salva).
1. Nella scheda **Editor**, scegli l' BookCar intento. Segui la fase precedente per aggiungere la funzione Lambda come hook di codice di convalida e soddisfazione.
1. Seleziona **Crea**. La console invia una serie di richieste ad Amazon Lex per salvare le configurazioni.
1. Esegui il test del bot. Ora che disponi di una funzione Lambda che esegue l'inizializzazione, la convalida e l'adempimento dei dati utente, puoi vedere la differenza nell'interazione dell'utente nella seguente conversazione:
![\[Conversazione con un agente, in cui l'agente richiede la città, il giorno, il numero di notti e il tipo di camera per la prenotazione di un viaggio, quindi conferma la prenotazione.\]](http://docs.aws.amazon.com/it_it/lex/latest/dg/images/book-trip-with-lambda-30.png)
Per ulteriori informazioni sul flusso di dati dal client (console) ad Amazon Lex e da Amazon Lex alla funzione Lambda, consulta. [Flusso di dati: intento di prenotazione hotel](book-trip-detail-flow.md#data-flow-book-hotel)
1. Continua la conversazione e prenota un'auto come mostrato nell'immagine seguente:
![\[Conversazione con un agente, in cui l'agente indica l'età del conducente e il tipo di auto, quindi conferma la prenotazione dell'auto.\]](http://docs.aws.amazon.com/it_it/lex/latest/dg/images/book-trip-with-lambda-40.png)
Quando scegli di prenotare un'auto, il client (console) invia una richiesta ad Amazon Lex che include gli attributi della sessione (dalla conversazione precedente BookHotel). Amazon Lex trasmette queste informazioni alla funzione Lambda, che quindi inizializza (ovvero precompila) alcuni dati dello BookCar slot (ovvero, e). PickUpDate ReturnDate PickUpCity
**Nota**
Viene illustrato come possono essere utilizzati gli attributi di sessione per mantenere il contesto tra gli intenti. Nella finestra di test del client della console è disponibile il collegamento **Clear** (Cancella), che consente all'utente di cancellare gli attributi di sessione precedenti.
Per ulteriori informazioni sul flusso di dati dal client (console) ad Amazon Lex e da Amazon Lex alla funzione Lambda, consulta. [Flusso di dati: intento di prenotazione automobile](book-trip-detail-flow.md#data-flow-book-car)
# Dettagli del flusso di informazioni
In questo esercizio, hai avviato una conversazione con il BookTrip bot Amazon Lex utilizzando il client della finestra di test fornito nella console Amazon Lex. Questa sezione descrive quanto segue:
+ Il flusso di dati tra il client e Amazon Lex.
La sezione presuppone che il client invii richieste ad Amazon Lex utilizzando l'API `PostText` di runtime e mostri di conseguenza i dettagli di richiesta e risposta. Per ulteriori informazioni sull'API di runtime `PostText`, consulta [PostText](API_runtime_PostText.md).
**Nota**
Per un esempio del flusso di informazioni tra il client e Amazon Lex in cui il client utilizza l'`PostContent`API, consulta[Fase 2a (facoltativo): Revisione dei dettagli del flusso di informazioni parlate (console)](gs-bp-details-postcontent-flow.md).
+ Il flusso di dati tra Amazon Lex e la funzione Lambda. Per ulteriori informazioni, consulta [Evento di input e formato di risposta della funzione Lambda](lambda-input-response-format.md).
**Topics**
+ [Flusso di dati: intento di prenotazione hotel](#data-flow-book-hotel)
+ [Flusso di dati: intento di prenotazione automobile](#data-flow-book-car)
## Flusso di dati: intento di prenotazione hotel
Questa sezione spiega cosa accade dopo ogni input utente.
1. Utente: "book a hotel"
1. Il client (console) invia la seguente richiesta [PostText](API_runtime_PostText.md) ad Amazon Lex:
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"book a hotel",
"sessionAttributes":{}
}
```
Sia l'URI della richiesta che il corpo forniscono informazioni ad Amazon Lex:
+ URI della richiesta: fornisce il nome del bot (BookTrip), l'alias del bot (\$1LATEST) e il nome utente. Il codice `text` finale indica che si tratta di una richiesta API `PostText` (non `PostContent`).
+ Corpo della richiesta: include l'input utente (`inputText`) e il campo `sessionAttributes` vuoto. Inizialmente, si tratta di un oggetto vuoto e la funzione Lambda imposta innanzitutto gli attributi della sessione.
1. Da`inputText`, Amazon Lex rileva l'intento ()BookHotel. Questo intento è configurato con una funzione Lambda come code hook per l'inizializzazione/convalida dei dati utente. Pertanto, Amazon Lex richiama la funzione Lambda passando le seguenti informazioni come parametro dell'evento (vedi): [Formato dell'evento di input](lambda-input-response-format.md#using-lambda-input-event-format)
```
{
"messageVersion":"1.0",
"invocationSource":"DialogCodeHook",
"userId":"wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes":{
},
"bot":{
"name":"BookTrip",
"alias":null,
"version":"$LATEST"
},
"outputDialogMode":"Text",
"currentIntent":{
"name":"BookHotel",
"slots":{
"RoomType":null,
"CheckInDate":null,
"Nights":null,
"Location":null
},
"confirmationStatus":"None"
}
}
```
Oltre alle informazioni inviate dal cliente, Amazon Lex include anche i seguenti dati aggiuntivi:
+ `messageVersion`— Attualmente Amazon Lex supporta solo la versione 1.0.
+ `invocationSource`— Indica lo scopo dell'invocazione della funzione Lambda. In questo caso, si tratta di eseguire l'inizializzazione e la convalida dei dati dell'utente (al momento Amazon Lex sa che l'utente non ha fornito tutti i dati dello slot per soddisfare l'intento).
+ `currentIntent`: tutti i valori di slot sono impostati su null.
1. Al momento, tutti i valori dello slot sono nulli. Non c'è nulla da convalidare per la funzione Lambda. La funzione Lambda restituisce la seguente risposta ad Amazon Lex. Per informazioni sul formato della risposta, consulta [Formato della risposta](lambda-input-response-format.md#using-lambda-response-format).
```
{
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",\"Location\":null,\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"dialogAction":{
"type":"Delegate",
"slots":{
"RoomType":null,
"CheckInDate":null,
"Nights":null,
"Location":null
}
}
}
```
**Nota**
`currentReservation`— La funzione Lambda include questo attributo di sessione. Il relativo valore è una copia delle informazioni sullo slot e del tipo di prenotazione correnti.
Solo la funzione Lambda e il client possono aggiornare questi attributi di sessione. Amazon Lex trasmette semplicemente questi valori.
`dialogAction.type`— Impostando questo valore su`Delegate`, la funzione Lambda delega la responsabilità della prossima linea d'azione ad Amazon Lex.
Se la funzione Lambda rileva qualcosa nella convalida dei dati utente, indica ad Amazon Lex cosa fare dopo.
1. Secondo il`dialogAction.type`, Amazon Lex decide la prossima linea d'azione: raccogliere dati dall'utente per lo slot. `Location` Seleziona uno dei messaggi di richiesta ("What city will you be staying in?") per questo slot in base alla configurazione dell'intento, quindi invia la seguente risposta all'utente:
![\[Risposta JSON contenente lo stato della finestra di dialogo, il nome dell'intento, il messaggio, la scheda di risposta, gli attributi della sessione, lo slot da richiamare e gli slot.\]](http://docs.aws.amazon.com/it_it/lex/latest/dg/images/book-hotel-10.png)
Gli attributi di sessione vengono passati al client.
Il client legge la risposta e quindi visualizza il messaggio: "What city will you be staying in?"
1. Utente: "Moscow"
1. Il client invia la seguente `PostText` richiesta ad Amazon Lex (interruzioni di riga aggiunte per motivi di leggibilità):
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"Moscow",
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":null,
\"RoomType\":null,
\"CheckInDate\":null,
\"Nights\":null}"
}
}
```
Oltre a `inputText`, il client include gli stessi attributi di sessione `currentReservation` ricevuti.
1. Amazon Lex interpreta innanzitutto le informazioni `inputText` nel contesto dell'intento corrente (il servizio ricorda di aver chiesto all'utente specifico informazioni sullo `Location` slot). Aggiorna il valore dello slot per l'intento corrente e richiama la funzione Lambda utilizzando il seguente evento:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":null,\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookHotel",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": "Moscow"
},
"confirmationStatus": "None"
}
}
```
**Nota**
`invocationSource` continua a essere `DialogCodeHook`. In questa fase, eseguiamo soltanto la convalida dei dati utente.
Amazon Lex sta semplicemente passando l'attributo session alla funzione Lambda.
Infatti`currentIntent.slots`, Amazon Lex ha aggiornato lo `Location` slot a`Moscow`.
1. La funzione Lambda esegue la convalida dei dati utente e determina che si `Moscow` tratta di una posizione non valida.
**Nota**
La funzione Lambda in questo esercizio ha un semplice elenco di città valide e non `Moscow` è presente nell'elenco. In un'applicazione di produzione, è possibile utilizzare un database di back-end per ottenere queste informazioni.
Reimposta il valore dello slot su null e ordina ad Amazon Lex di richiedere nuovamente all'utente un altro valore inviando la seguente risposta:
```
{
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Moscow\",\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"dialogAction": {
"type": "ElicitSlot",
"intentName": "BookHotel",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": null
},
"slotToElicit": "Location",
"message": {
"contentType": "PlainText",
"content": "We currently do not support Moscow as a valid destination. Can you try a different city?"
}
}
}
```
**Nota**
`currentIntent.slots.Location` viene reimpostato su null.
`dialogAction.type`è impostato su`ElicitSlot`, il che indica ad Amazon Lex di richiedere nuovamente all'utente fornendo quanto segue:
`dialogAction.slotToElicit`: slot per il quale ottenere i dati dall'utente.
`dialogAction.message`: elemento `message` da trasmettere all'utente.
1. Amazon Lex rileva `dialogAction.type` e trasmette le informazioni al cliente nella seguente risposta:
![\[Risposta JSON contenente lo stato della finestra di dialogo, il nome dell'intento, il messaggio, la scheda di risposta, gli attributi della sessione, lo slot da richiedere e gli slot.\]](http://docs.aws.amazon.com/it_it/lex/latest/dg/images/book-hotel-20.png)
Il client visualizza semplicemente il messaggio: "We currently do not support Moscow as a valid destination. Can you try a different city?"
1. Utente: "Chicago"
1. Il client invia la seguente `PostText` richiesta ad Amazon Lex:
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"Chicago",
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":\"Moscow\",
\"RoomType\":null,
\"CheckInDate\":null,
\"Nights\":null}"
}
}
```
1. Amazon Lex conosce il contesto e sa che stava raccogliendo dati per lo `Location` slot. In questo contesto, sa che il valore `inputText` è per lo slot `Location`. Quindi richiama la funzione Lambda inviando il seguente evento:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":Moscow,\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookHotel",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": "Chicago"
},
"confirmationStatus": "None"
}
}
```
Amazon Lex ha aggiornato il `currentIntent.slots` file impostando lo `Location` slot su`Chicago`.
1. In base al `invocationSource` valore di`DialogCodeHook`, la funzione Lambda esegue la convalida dei dati utente. Riconosce `Chicago` come valore di slot valido, aggiorna di conseguenza l'attributo di sessione e quindi restituisce la seguente risposta ad Amazon Lex.
```
{
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"dialogAction": {
"type": "Delegate",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": "Chicago"
}
}
}
```
**Nota**
`currentReservation`— La funzione Lambda aggiorna questo attributo di sessione impostando su. `Location` `Chicago`
`dialogAction.type`: è impostato su `Delegate`. I dati utente erano validi e la funzione Lambda indica ad Amazon Lex di scegliere la linea d'azione successiva.
1. Secondo`dialogAction.type`, Amazon Lex sceglie la linea d'azione successiva. Amazon Lex sa di aver bisogno di più dati sugli slot e sceglie lo slot vuoto successivo (`CheckInDate`) con la massima priorità in base alla configurazione dell'intento. Seleziona uno dei messaggi di richiesta ("What day do you want to check in?") per questo slot in base alla configurazione dell'intento, quindi invia la seguente risposta al client:
![\[Risposta JSON contenente lo stato della finestra di dialogo, il nome dell'intento, il messaggio, la scheda di risposta, gli attributi della sessione, lo slot da richiamare e gli slot. Lo slot di posizione è ora compilato come Chicago.\]](http://docs.aws.amazon.com/it_it/lex/latest/dg/images/book-hotel-30.png)
Il client visualizza il messaggio: "What day do you want to check in?"
1. L'interazione con l'utente continua: l'utente fornisce i dati, la funzione Lambda li convalida e quindi delega la linea d'azione successiva ad Amazon Lex. Alla fine l'utente fornisce tutti i dati dello slot, la funzione Lambda convalida tutti gli input dell'utente e quindi Amazon Lex riconosce che dispone di tutti i dati dello slot.
**Nota**
In questo esercizio, dopo che l'utente ha fornito tutti i dati dello slot, la funzione Lambda calcola il prezzo della prenotazione alberghiera e lo restituisce come un altro attributo di sessione (). `currentReservationPrice`
A questo punto, l'intento è pronto per essere soddisfatto, ma viene configurato con una richiesta di conferma che richiede la conferma dell'utente prima che Amazon Lex possa soddisfare l' BookHotelintento. Pertanto, Amazon Lex invia il seguente messaggio al cliente richiedendo la conferma prima di prenotare l'hotel:
![\[Risposta JSON contenente lo stato della finestra di dialogo, il nome dell'intento, il messaggio, la scheda di risposta, gli attributi della sessione, lo slot da richiamare e gli slot. Tutti gli slot sono ora occupati.\]](http://docs.aws.amazon.com/it_it/lex/latest/dg/images/book-hotel-40.png)
Il client visualizza il messaggio: "Okay, I have you down for a 5 night in Chicago starting 2016-12-18. Shall I book the reservation?"
1. Utente: "yes"
1. Il client invia la seguente `PostText` richiesta ad Amazon Lex:
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"Yes",
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":\"Chicago\",
\"RoomType\":\"queen\",
\"CheckInDate\":\"2016-12-18\",
\"Nights\":\"5\"}",
"currentReservationPrice":"1195"
}
}
```
1. Amazon Lex interpreta il `inputText` nel contesto della conferma dell'intento attuale. Amazon Lex capisce che l'utente desidera procedere con la prenotazione. Questa volta Amazon Lex richiama la funzione Lambda per soddisfare l'intento inviando il seguente evento. Impostando `invocationSource` su `FulfillmentCodeHook` nell'evento, invia alla funzione Lambda. Amazon Lex imposta anche `confirmationStatus` il`Confirmed`.
```
{
"messageVersion": "1.0",
"invocationSource": "FulfillmentCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}",
"currentReservationPrice": "956"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookHotel",
"slots": {
"RoomType": "queen",
"CheckInDate": "2016-12-18",
"Nights": "5",
"Location": "Chicago"
},
"confirmationStatus": "Confirmed"
}
}
```
**Nota**
`invocationSource`— Questa volta, Amazon Lex ha impostato questo valore su`FulfillmentCodeHook`, indirizzando la funzione Lambda a soddisfare l'intento.
`confirmationStatus`: è impostato su `Confirmed`.
1. Questa volta, la funzione Lambda soddisfa l'intento BookHotel , Amazon Lex completa la prenotazione e quindi restituisce la seguente risposta:
```
{
"sessionAttributes": {
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}"
},
"dialogAction": {
"type": "Close",
"fulfillmentState": "Fulfilled",
"message": {
"contentType": "PlainText",
"content": "Thanks, I have placed your reservation. Please let me know if you would like to book a car rental, or another hotel."
}
}
}
```
**Nota**
`lastConfirmedReservation`— È un nuovo attributo di sessione aggiunto dalla funzione Lambda (anziché`currentReservation`,`currentReservationPrice`).
`dialogAction.type`— La funzione Lambda imposta questo valore su`Close`, a indicare che Amazon Lex non si aspetta una risposta da parte dell'utente.
`dialogAction.fulfillmentState`: è impostato su `Fulfilled` (Soddisfatto) e include un elemento `message` appropriato da trasmettere all'utente.
1. Amazon Lex esamina `fulfillmentState` e invia la seguente risposta al cliente:
![\[Risposta JSON contenente lo stato della finestra di dialogo, il nome dell'intento, il messaggio, la scheda di risposta, gli attributi della sessione, lo slot da richiedere e gli slot. Tutti gli slot sono stati compilati e ora viene compilato un campo per l'ultima prenotazione confermata negli attributi della sessione.\]](http://docs.aws.amazon.com/it_it/lex/latest/dg/images/book-hotel-60.png)
**Nota**
`dialogState`— Amazon Lex imposta questo valore su`Fulfilled`.
`message`— È lo stesso messaggio fornito dalla funzione Lambda.
Il client visualizza il messaggio.
## Flusso di dati: intento di prenotazione automobile
Il BookTrip bot in questo esercizio supporta due intenti (BookHotel e BookCar). Dopo aver prenotato un hotel, l'utente può continuare la conversazione per prenotare un'automobile. Purché non si sia verificato il timeout della sessione, in ogni richiesta successiva il client continua a inviare gli attributi di sessione (in questo esempio, `lastConfirmedReservation`). La funzione Lambda può utilizzare queste informazioni per inizializzare i dati degli slot per l'intento. BookCar Ciò illustra come utilizzare gli attributi di sessione nella condivisione dei dati tra più intenti.
In particolare, quando l'utente sceglie l' BookCar intento, la funzione Lambda utilizza le informazioni pertinenti nell'attributo session per precompilare gli slot (PickUpDate ReturnDate, e) per l'intento. PickUpCity BookCar
**Nota**
La console Amazon Lex fornisce il link **Clear** che puoi utilizzare per cancellare qualsiasi attributo della sessione precedente.
Seguire le fasi di questa procedura per continuare la conversazione.
1. Utente: "also book a car"
1. Il client invia la seguente `PostText` richiesta ad Amazon Lex.
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"also book a car",
"sessionAttributes":{
"lastConfirmedReservation":""{\"ReservationType\":\"Hotel\",
\"Location\":\"Chicago\",
\"RoomType\":\"queen\",
\"CheckInDate\":\"2016-12-18\",
\"Nights\":\"5\"}"
}
}
```
Il client include l'attributo di sessione `lastConfirmedReservation`.
1. Amazon Lex rileva l'intento (BookCar) da. `inputText` Questo intento è inoltre configurato per richiamare la funzione Lambda per eseguire l'inizializzazione e la convalida dei dati utente. Amazon Lex richiama la funzione Lambda con il seguente evento:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookCar",
"slots": {
"PickUpDate": null,
"ReturnDate": null,
"DriverAge": null,
"CarType": null,
"PickUpCity": null
},
"confirmationStatus": "None"
}
}
```
**Nota**
`messageVersion`— Attualmente Amazon Lex supporta solo la versione 1.0.
`invocationSource`: indica che lo scopo dell'invocazione è quello di eseguire l'inizializzazione e la convalida dei dati utente.
`currentIntent`— Include il nome dell'intento e gli slot. A questo punto, tutti i valori di slot sono null.
1. La funzione Lambda rileva tutti i valori nulli degli slot senza nulla da convalidare. Utilizza tuttavia gli attributi di sessione per inizializzare alcuni valori di slot (`PickUpDate``ReturnDate` e `PickUpCity`) e restituisce la seguente risposta:
```
{
"sessionAttributes": {
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}",
"currentReservation": "{\"ReservationType\":\"Car\",\"PickUpCity\":null,\"PickUpDate\":null,\"ReturnDate\":null,\"CarType\":null}",
"confirmationContext": "AutoPopulate"
},
"dialogAction": {
"type": "ConfirmIntent",
"intentName": "BookCar",
"slots": {
"PickUpCity": "Chicago",
"PickUpDate": "2016-12-18",
"ReturnDate": "2016-12-22",
"CarType": null,
"DriverAge": null
},
"message": {
"contentType": "PlainText",
"content": "Is this car rental for your 5 night stay in Chicago on 2016-12-18?"
}
}
}
```
**Nota**
Oltre a`lastConfirmedReservation`, la funzione Lambda include più attributi di sessione (`currentReservation`e`confirmationContext`).
`dialogAction.type`è impostato su`ConfirmIntent`, il che informa Amazon Lex che è prevista una risposta sì o no da parte dell'utente (ConfirmationContext è impostato su, la funzione Lambda sa yes/no che la risposta dell'utente serve AutoPopulate per ottenere la conferma dell'inizializzazione eseguita dalla funzione Lambda (dati dello slot popolati automaticamente).
La funzione Lambda include anche nella risposta un messaggio informativo che Amazon Lex deve restituire al client. `dialogAction.message`
Il termine `ConfirmIntent` (valore di `dialogAction.type`) non è correlato ad alcun intento di bot. Nell'esempio, la funzione Lambda utilizza questo termine per indirizzare Amazon Lex a ricevere una yes/no risposta dall'utente.
1. In base a`dialogAction.type`, Amazon Lex restituisce al client la seguente risposta:
![\[Risposta JSON contenente lo stato della finestra di dialogo, il nome dell'intento, il messaggio, la scheda di risposta, gli attributi della sessione, lo slot da richiamare e gli slot.\]](http://docs.aws.amazon.com/it_it/lex/latest/dg/images/book-car-10.png)
Il client mostra il messaggio: "Is this car rental for your 5 night stay in Chicago on 2016-12-18?"
1. Utente: "yes"
1. Il client invia la seguente `PostText` richiesta ad Amazon Lex.
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"yes",
"sessionAttributes":{
"confirmationContext":"AutoPopulate",
"currentReservation":"{\"ReservationType\":\"Car\",
\"PickUpCity\":null,
\"PickUpDate\":null,
\"ReturnDate\":null,
\"CarType\":null}",
"lastConfirmedReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":\"Chicago\",
\"RoomType\":\"queen\",
\"CheckInDate\":\"2016-12-18\",
\"Nights\":\"5\"}"
}
}
```
1. Amazon Lex legge `inputText` e conosce il contesto (ha chiesto all'utente di confermare la popolazione delle auto). Amazon Lex richiama la funzione Lambda inviando il seguente evento:
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"confirmationContext": "AutoPopulate",
"currentReservation": "{\"ReservationType\":\"Car\",\"PickUpCity\":null,\"PickUpDate\":null,\"ReturnDate\":null,\"CarType\":null}",
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookCar",
"slots": {
"PickUpDate": "2016-12-18",
"ReturnDate": "2016-12-22",
"DriverAge": null,
"CarType": null,
"PickUpCity": "Chicago"
},
"confirmationStatus": "Confirmed"
}
}
```
Poiché l'utente ha risposto Sì, Amazon Lex imposta `confirmationStatus` il`Confirmed`.
1. Da`confirmationStatus`, la funzione Lambda sa che i valori precompilati sono corretti. La funzione Lambda; svolge le operazioni seguenti:
+ Aggiorna l'attributo di sessione `currentReservation` con il valore di slot precompilato.
+ Imposta `dialogAction.type` su `ElicitSlot`.
+ Imposta il valore `slotToElicit` su `DriverAge`.
Viene inviata la seguente risposta:
```
{
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Car\",\"PickUpCity\":\"Chicago\",\"PickUpDate\":\"2016-12-18\",\"ReturnDate\":\"2016-12-22\",\"CarType\":null}",
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}"
},
"dialogAction": {
"type": "ElicitSlot",
"intentName": "BookCar",
"slots": {
"PickUpDate": "2016-12-18",
"ReturnDate": "2016-12-22",
"DriverAge": null,
"CarType": null,
"PickUpCity": "Chicago"
},
"slotToElicit": "DriverAge",
"message": {
"contentType": "PlainText",
"content": "How old is the driver of this car rental?"
}
}
}
```
1. Amazon Lex restituisce la seguente risposta:
![\[Risposta JSON che mostra l'intenzione di prenotare un'auto e un messaggio che indica lo slot per lo slot Driver Age.\]](http://docs.aws.amazon.com/it_it/lex/latest/dg/images/book-car-20.png)
Il cliente visualizza il messaggio «Quanti anni ha l'autista di questo servizio di autonoleggio?» e la conversazione continua.