AWS Review
English

Appearance

On this page

Ejercicio: Chatbot de Reservas de Restaurante con Amazon Lex ​

Objetivo ​

Crear un chatbot que permita:

  • Realizar reservas de restaurante
  • Consultar disponibilidad
  • Modificar/cancelar reservas
  • Responder preguntas frecuentes

Parte 1: Configuración Inicial de Lex ​

1. Acceder a Amazon Lex ​

  1. Ve a la consola AWS:
    Búsqueda: "Lex"
O: Services > Machine Learning > Amazon Lex

2. Crear Bot ​

  1. Create bot:
    Bot name: RestaurantReservationBot
IAM role: Create new role
COPPA: No
Language: Spanish
Session timeout: 5 minutes
Sentiment analysis: No

Parte 2: Configurar Intenciones ​

1. Crear Intención de Reserva ​

Intent name: ReservarMesa
Sample utterances (frases de ejemplo):
- Quiero hacer una reserva
- Necesito una mesa
- Reservar para cenar
- Hacer una reservación
- Quiero reservar una mesa

Slots (campos requeridos):
1. Fecha
   Name: FechaReserva
   Slot type: AMAZON.DATE
   Prompt: ¿Para qué día desea la reserva?

2. Hora
   Name: HoraReserva
   Slot type: AMAZON.TIME
   Prompt: ¿A qué hora desea la reserva?

3. Personas
   Name: NumeroPersonas
   Slot type: AMAZON.NUMBER
   Prompt: ¿Para cuántas personas es la reserva?

4. Nombre
   Name: NombreCliente
   Slot type: AMAZON.FirstName
   Prompt: ¿A qué nombre hacemos la reserva?

Confirmation prompt:
Message: ¿Confirma la reserva para {NumeroPersonas} personas el {FechaReserva} a las {HoraReserva} a nombre de {NombreCliente}?

2. Crear Intención de Consulta ​

Intent name: ConsultarReserva
Sample utterances:
- Ver mi reserva
- Consultar reservación
- Estado de mi reserva
- Información de mi reserva

Slots:
1. Nombre
   Name: NombreConsulta
   Slot type: AMAZON.FirstName
   Prompt: ¿A qué nombre está la reserva?
   
2. Fecha
   Name: FechaConsulta
   Slot type: AMAZON.DATE
   Prompt: ¿Para qué día es la reserva?

3. Crear Intención de Cancelación ​

Intent name: CancelarReserva
Sample utterances:
- Cancelar reserva
- Anular reservación
- Eliminar mi reserva
- Quiero cancelar mi reserva

Slots:
1. Nombre
   Name: NombreCancelacion
   Slot type: AMAZON.FirstName
   Prompt: ¿A qué nombre está la reserva?
   
2. Fecha
   Name: FechaCancelacion
   Slot type: AMAZON.DATE
   Prompt: ¿Qué día era la reserva?

Confirmation prompt:
Message: ¿Está seguro que desea cancelar la reserva a nombre de {NombreCancelacion} para el día {FechaCancelacion}?

Parte 3: Configurar Lambda para Procesar Intenciones ​

1. Crear Función Lambda ​

python
import json
import boto3
from datetime import datetime

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('Reservaciones')

def lambda_handler(event, context):
    intent_name = event['currentIntent']['name']
    slots = event['currentIntent']['slots']
    
    if intent_name == 'ReservarMesa':
        return procesar_reserva(slots)
    elif intent_name == 'ConsultarReserva':
        return consultar_reserva(slots)
    elif intent_name == 'CancelarReserva':
        return cancelar_reserva(slots)
    
def procesar_reserva(slots):
    # Validar disponibilidad
    if not verificar_disponibilidad(slots['FechaReserva'], slots['HoraReserva'], slots['NumeroPersonas']):
        return {
            'dialogAction': {
                'type': 'Close',
                'fulfillmentState': 'Failed',
                'message': {
                    'contentType': 'PlainText',
                    'content': 'Lo siento, no hay disponibilidad para esa fecha y hora.'
                }
            }
        }
    
    # Guardar reserva
    reserva_id = guardar_reserva(slots)
    
    return {
        'dialogAction': {
            'type': 'Close',
            'fulfillmentState': 'Fulfilled',
            'message': {
                'contentType': 'PlainText',
                'content': f'Su reserva ha sido confirmada. Su número de reserva es: {reserva_id}'
            }
        }
    }

def verificar_disponibilidad(fecha, hora, personas):
    # Lógica para verificar disponibilidad
    return True

def guardar_reserva(slots):
    reserva_id = generate_reservation_id()
    
    table.put_item(
        Item={
            'reserva_id': reserva_id,
            'nombre': slots['NombreCliente'],
            'fecha': slots['FechaReserva'],
            'hora': slots['HoraReserva'],
            'personas': slots['NumeroPersonas'],
            'estado': 'CONFIRMADA'
        }
    )
    
    return reserva_id

2. Configurar Permisos Lambda ​

json
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "dynamodb:PutItem",
                "dynamodb:GetItem",
                "dynamodb:UpdateItem",
                "dynamodb:DeleteItem"
            ],
            "Resource": "arn:aws:dynamodb:region:account:table/Reservaciones"
        }
    ]
}

Parte 4: Integrar con DynamoDB ​

1. Crear Tabla ​

Table name: Reservaciones
Partition key: reserva_id (String)
Sort key: fecha (String)

Índices secundarios:
- nombre-fecha-index
  Partition key: nombre
  Sort key: fecha

Parte 5: Pruebas y Validación ​

1. Probar Conversaciones ​

Usuario: "Quiero hacer una reserva"
Bot: "¿Para qué día desea la reserva?"
Usuario: "Mañana"
Bot: "¿A qué hora desea la reserva?"
Usuario: "8:30 PM"
Bot: "¿Para cuántas personas es la reserva?"
Usuario: "4"
Bot: "¿A qué nombre hacemos la reserva?"
Usuario: "Juan"
Bot: "¿Confirma la reserva para 4 personas mañana a las 8:30 PM a nombre de Juan?"
Usuario: "Sí"
Bot: "Su reserva ha sido confirmada. Su número de reserva es: RES-001"

2. Validar Respuestas ​

Escenarios a probar:

  • Reserva exitosa
  • Fecha no disponible
  • Cancelación correcta
  • Consulta de reserva existente
  • Manejo de errores

Parte 6: Monitoreo ​

1. Configurar CloudWatch ​

Métricas a monitorear:
- Número de conversaciones
- Tasa de éxito
- Tiempo de respuesta
- Errores de procesamiento

2. Crear Alarmas ​

Alarmas para:
- Error rate > 5%
- Latencia > 2 segundos
- Fallas de fulfillment

Verificación ​

1. Funcionalidad ​

  • [ ] Reconocimiento correcto de intenciones
  • [ ] Captura correcta de slots
  • [ ] Validación de datos
  • [ ] Respuestas coherentes

2. Integración ​

  • [ ] Lambda se ejecuta correctamente
  • [ ] DynamoDB almacena datos
  • [ ] CloudWatch registra métricas

Solución de Problemas Comunes ​

Error de Reconocimiento ​

  1. Revisar utterances
  2. Añadir más ejemplos
  3. Verificar configuración de slots

Error de Lambda ​

  1. Verificar permisos
  2. Revisar logs
  3. Validar formato de respuesta

Limpieza ​

  1. Eliminar bot
  2. Eliminar función Lambda
  3. Eliminar tabla DynamoDB
  4. Eliminar logs CloudWatch

Conceptos Clave para el Examen ​

  • Intenciones y slots
  • Integración con servicios AWS
  • Procesamiento de lenguaje natural
  • Monitoreo y logs

Puntos importantes a recordar:

  1. Lex maneja el procesamiento de lenguaje natural
  2. La integración con Lambda permite lógica personalizada
  3. Los slots capturan información específica
  4. El monitoreo es crucial para la calidad del servicio

Para el examen Cloud Practitioner, enfócate en:

  • Propósito de Amazon Lex
  • Casos de uso comunes
  • Integraciones con otros servicios AWS
  • Conceptos básicos de chatbots