Los agentes para Amazon Bedrock ahora admiten retención de memoria e interpretación de código (versión preliminar) | Amazon Web Services

Con Agents for Amazon Bedrock, las aplicaciones de inteligencia artificial (IA) generativa pueden ejecutar tareas de varios pasos en diferentes sistemas y fuentes de datos. Hace un par de meses, simplificamos la creación y configuración de agentes. Hoy, presentamos en versión preliminar dos nuevas capacidades totalmente administradas:

Conservar la memoria a través de múltiples interacciones – Los agentes ahora pueden conservar un resumen de sus conversaciones con cada usuario y brindar una experiencia fluida y adaptable, especialmente para tareas complejas de varios pasos, como interacciones con el usuario y soluciones de automatización empresarial como reservar vuelos o procesar reclamos de seguros.

Soporte para interpretación de código – Los agentes ahora pueden generar y ejecutar fragmentos de código de forma dinámica dentro de un entorno seguro y protegido, y pueden abordar casos de uso complejos, como análisis de datos, visualización de datos, procesamiento de texto, resolución de ecuaciones y problemas de optimización. Para facilitar el uso de esta función, también agregamos la capacidad de cargar documentos directamente a un agente.

Veamos con más detalle cómo funcionan estas nuevas capacidades.

Retención de memoria a través de múltiples interacciones
Con la retención de memoria, puede crear agentes que aprendan y se adapten a las necesidades y preferencias únicas de cada usuario a lo largo del tiempo. Al mantener una memoria persistente, los agentes pueden retomar el trabajo justo donde lo dejaron los usuarios, lo que proporciona un flujo fluido de conversaciones y flujos de trabajo, especialmente para tareas complejas de varios pasos.

Imaginemos que un usuario reserva un vuelo. Gracias a la capacidad de retener la memoria, el agente puede conocer sus preferencias de viaje y utilizar ese conocimiento para agilizar las solicitudes de reserva posteriores, creando una experiencia personalizada y eficiente. Por ejemplo, puede proponer automáticamente a un usuario el asiento adecuado o una comida similar a sus elecciones anteriores.

El uso de la retención de memoria para tener más conciencia del contexto también simplifica la automatización de los procesos empresariales. Por ejemplo, un agente utilizado por una empresa para procesar los comentarios de los clientes ahora puede estar al tanto de las interacciones anteriores y actuales con el mismo cliente sin tener que gestionar integraciones personalizadas.

El historial de conversaciones y el contexto de cada usuario se almacenan de forma segura bajo un identificador de memoria (ID) único, lo que garantiza una separación completa entre usuarios. Con la retención de memoria, es más fácil crear agentes que brinden experiencias fluidas, adaptables y personalizadas que mejoren continuamente con el tiempo. Veamos cómo funciona esto en la práctica.

Uso de la retención de memoria en agentes para Amazon Bedrock
En la consola de Amazon Bedrock, elijo Agentes desde el Herramientas de construcción sección del panel de navegación y comience a crear un agente.

Para el agente, utilizo agente-libro-vuelo Como el nombre con esto como descripción:

Help book a flight.

Luego, en el generador de agentes, selecciono el modelo Claude 3 Sonnet de Anthropic e ingreso estas instrucciones:

To book a flight, you should know the origin and destination airports and the day and time the flight takes off.

En Ajustes adicionalesyo habilito Entrada del usuario Permitir que el agente haga preguntas aclaratorias para captar los datos necesarios. Esto será de ayuda cuando en una solicitud de reserva de vuelo falte información necesaria, como el origen y el destino o la fecha y hora del vuelo.

En el nuevo Memoria Sección, habilito la memoria para generar y almacenar un resumen de la sesión al final de cada sesión y uso los 30 días predeterminados para la duración de la memoria.

Luego, agrego un grupo de acciones para buscar y reservar vuelos. Utilizo buscar y reservar vuelos como nombre y esta descripción:

Search for flights between two destinations on a given day and book a specific flight.

Luego, elijo definir el grupo de acciones con detalles de funciones y luego crear una nueva función Lambda. La función Lambda implementará la lógica empresarial para todas las funciones en este grupo de acciones.

Añado dos funciones a este grupo de acciones: una para buscar vuelos y otra para reservar vuelos.

La primera función es búsqueda de vuelos y tiene esta descripción:

Search for flights on a given date between two destinations.

Todos los parámetros de esta función son obligatorios y de tipo cadena. A continuación se muestran los nombres y descripciones de los parámetros:

origen_aeropuerto – Origin IATA airport code
aeropuerto de destino – Destination IATA airport code
fecha – Date of the flight in YYYYMMDD format

La segunda función es reservar un vuelo y utiliza esta descripción:

Book a flight at a given date and time between two destinations.

Nuevamente, todos los parámetros son obligatorios y de tipo cadena. Estos son los nombres y descripciones de los parámetros:

origen_aeropuerto – Origin IATA airport code
aeropuerto de destino – Destination IATA airport code
fecha – Date of the flight in YYYYMMDD format
tiempo – Time of the flight in HHMM format

Para completar la creación del agente, elijo Crear.

Para acceder al código fuente de la función Lambda, elijo el buscar y reservar vuelos grupo de acción y luego Vista (cerca de Seleccionar la función Lambda Normalmente, utilizaría esta función Lambda para integrarla con un sistema existente, como una plataforma de reservas de viajes. En este caso, utilizo este código para simular una plataforma de reservas para el agente.

import json
import random
from datetime import datetime, time, timedelta


def convert_params_to_dict(params_list):
    params_dict = {}
    for param in params_list:
        name = param.get("name")
        value = param.get("value")
        if name is not None:
            params_dict[name] = value
    return params_dict


def generate_random_times(date_str, num_flights, min_hours, max_hours):
    # Set seed based on input date
    seed = int(date_str)
    random.seed(seed)

    # Convert min_hours and max_hours to minutes
    min_minutes = min_hours * 60
    max_minutes = max_hours * 60

    # Generate random times
    random_times = set()
    while len(random_times) 

Preparo el agente para probarlo en la consola y hago esta pregunta:

Which flights are available from London Heathrow to Rome Fiumicino on July 20th, 2024?

El agente responde con una lista de horarios. Elijo Mostrar rastro para obtener más información sobre cómo el agente procesó mis instrucciones.

En el Rastro En la pestaña, exploro los pasos de seguimiento para comprender la cadena de pensamiento utilizada por la orquestación del agente. Por ejemplo, aquí veo que el agente manejó la conversión de los nombres de los aeropuertos a códigos (LHR para Londres Heathrow, FCO para Roma Fiumicino) antes de llamar a la función Lambda.

En el nuevo Memoria Pestaña, veo cuál es el contenido de la memoria. La consola usa un ID de memoria de prueba específico. En una aplicación, para mantener la memoria separada para cada usuario, puedo usar un ID de memoria diferente para cada usuario.

Miro la lista de vuelos y pido reservar uno:

Book the one at 6:02pm.

El agente responde confirmando la reserva.

Después de unos minutos, una vez finalizada la sesión, veo un resumen de mi conversación en el Memoria pestaña.

Elijo el icono de la escoba para iniciar una nueva conversación y hacer una pregunta que, por sí sola, no proporciona un contexto completo al agente:

Which other flights are available on the day of my flight?

El agente recuerda el vuelo que reservé de nuestra conversación anterior. Para darme una respuesta, el agente me pide que confirme los detalles del vuelo. Tenga en cuenta que la función Lambda es solo una simulación y no almacenó la información de la reserva en ninguna base de datos. Los detalles del vuelo se recuperaron de la memoria del agente.

Confirmo esos valores y obtengo la lista de los demás vuelos con el mismo origen y destino en ese día.

Yes, please.

Para demostrar mejor los beneficios de la retención de memoria, llamemos al agente mediante el SDK de AWS para Python (Boto3). Para ello, primero debo crear un alias y una versión del agente. Anoto el ID del agente y el ID del alias porque son necesarios al invocar al agente.

En la invocación del agente, agrego el nuevo memoryId Opción para utilizar la memoria. Al incluir esta opción obtengo dos beneficios:

• El recuerdo que se conserva para ello memoryId (si lo hay) es utilizado por el agente para mejorar su respuesta.
• Se conserva un resumen de la conversación de la sesión actual. memoryId para que pueda ser utilizado en otra sesión.

Al utilizar un SDK de AWS, también puedo obtener el contenido o eliminar el contenido de la memoria para un objeto específico. memoryId.

import random
import string
import boto3
import json

DEBUG = False # Enable debug to see all trace steps
DATE_FORMAT = "%Y-%m-%d %H:%M:%S"

AGENT_ID = 'URSVOGLFNX'
AGENT_ALIAS_ID = 'JHLX9ERCMD'

SESSION_ID_LENGTH = 10
SESSION_ID = "".join(
    random.choices(string.ascii_uppercase + string.digits, k=SESSION_ID_LENGTH)
)

# A unique identifier for each user
MEMORY_ID = 'danilop-92f79781-a3f3-4192-8de6-890b67c63d8b' 
bedrock_agent_runtime = boto3.client('bedrock-agent-runtime', region_name="us-east-1")


def invoke_agent(prompt, end_session=False):
    response = bedrock_agent_runtime.invoke_agent(
        agentId=AGENT_ID,
        agentAliasId=AGENT_ALIAS_ID,
        sessionId=SESSION_ID,
        inputText=prompt,
        memoryId=MEMORY_ID,
        enableTrace=DEBUG,
        endSession=end_session,
    )

    completion = ""

    for event in response.get('completion'):
        if DEBUG:
            print(event)
        if 'chunk' in event:
            chunk = event['chunk']
            completion += chunk['bytes'].decode()

    return completion


def delete_memory():
    try:
        response = bedrock_agent_runtime.delete_agent_memory(
            agentId=AGENT_ID,
            agentAliasId=AGENT_ALIAS_ID,
            memoryId=MEMORY_ID,
        )
    except Exception as e:
        print(e)
        return None
    if DEBUG:
        print(response)


def get_memory():
    response = bedrock_agent_runtime.get_agent_memory(
        agentId=AGENT_ID,
        agentAliasId=AGENT_ALIAS_ID,
        memoryId=MEMORY_ID,
        memoryType="SESSION_SUMMARY",
    )
    memory = ""
    for content in response['memoryContents']:
        if 'sessionSummary' in content:
            s = content['sessionSummary']
            memory += f"Session ID {s['sessionId']} from {s['sessionStartTime'].strftime(DATE_FORMAT)} to {s['sessionExpiryTime'].strftime(DATE_FORMAT)}\n"
            memory += s['summaryText'] + "\n"
    if memory == "":
        memory = ""
    return memory


def main():
    print("Delete memory? (y/n)")
    if input() == 'y':
        delete_memory()

    print("Memory content:")
    print(get_memory())

    prompt = input('> ')
    if len(prompt) > 0:
        print(invoke_agent(prompt, end_session=False)) # Start a new session
        invoke_agent('end', end_session=True) # End the session

if __name__ == "__main__":
    main()

Ejecuto el script de Python desde mi computadora portátil. Elijo eliminar la memoria actual (aunque debería estar vacía por ahora) y luego solicito reservar un vuelo por la mañana en una fecha específica.

Delete memory? (y/n)
y
Memory content:

> Book me on a morning flight on July 20th, 2024 from LHR to FCO.
I have booked you on the morning flight from London Heathrow (LHR) to Rome Fiumicino (FCO) on July 20th, 2024 at 06:44.

Espero un par de minutos y vuelvo a ejecutar el script. El script crea una nueva sesión cada vez que se ejecuta. Esta vez, no borro la memoria y veo el resumen de mi interacción anterior con el mismo memoryIdLuego pregunto en qué fecha está programado mi vuelo. Aunque se trata de una nueva sesión, el agente encuentra la reserva anterior en el contenido de la memoria.

Delete memory? (y/n)
n
Memory content:
Session ID MM4YYW0DL2 from 2024-07-09 15:35:47 to 2024-07-09 15:35:58
The user's goal was to book a morning flight from LHR to FCO on July 20th, 2024. The assistant booked a 0644 morning flight from LHR to FCO on the requested date of July 20th, 2024. The assistant successfully booked the requested morning flight for the user. The user requested a morning flight booking on July 20th, 2024 from London Heathrow (LHR) to Rome Fiumicino (FCO). The assistant booked a 0644 flight for the specified route and date.

> Which date is my flight on?
I recall from our previous conversation that you booked a morning flight from London Heathrow (LHR) to Rome Fiumicino (FCO) on July 20th, 2024. Please confirm if this date of July 20th, 2024 is correct for the flight you are asking about.

¡Si, ese es mi vuelo!

Dependiendo de su caso de uso, la retención de memoria puede ayudar a rastrear interacciones y preferencias anteriores del mismo usuario y brindar una experiencia fluida en todas las sesiones.

Un resumen de sesión incluye una visión general y los puntos de vista del usuario y del asistente. En una sesión corta como esta, esto puede generar cierta repetición.

Soporte de interpretación de código
Los agentes para Amazon Bedrock ahora admiten la interpretación de código, de modo que los agentes pueden generar y ejecutar dinámicamente fragmentos de código dentro de un entorno seguro y aislado, lo que amplía significativamente los casos de uso que pueden abordar, incluidas tareas complejas como análisis de datos, visualización, procesamiento de texto, resolución de ecuaciones y problemas de optimización.

Los agentes ahora pueden procesar archivos de entrada con diversos tipos y formatos de datos, incluidos CSV, XLS, YAML, JSON, DOC, HTML, MD, TXT y PDF. La interpretación de código permite a los agentes generar también gráficos, lo que mejora la experiencia del usuario y hace que la interpretación de datos sea más accesible.

Un agente utiliza la interpretación de código cuando el modelo de lenguaje grande (LLM) determina que puede ayudar a resolver un problema específico con mayor precisión y no admite escenarios de diseño en los que los usuarios solicitan la generación de código arbitrario. Por motivos de seguridad, cada sesión de usuario cuenta con un entorno de ejecución de código aislado y protegido.

Hagamos una prueba rápida para ver cómo esto puede ayudar a un agente a manejar tareas complejas.

Uso de la interpretación de código en Agentes para Amazon Bedrock
En la consola de Amazon Bedrock, selecciono el mismo agente de la demostración anterior (agente-libro-vuelo) y elige Editar en el generador de agentesEn el generador de agentes, habilito Intérprete de código bajo Ajustes adicionales y guarda.

Preparo el agente y lo pruebo directamente en la consola. Primero, hago una pregunta matemática.

Compute the sum of the first 10 prime numbers.

Después de unos segundos, recibo la respuesta del agente:

The sum of the first 10 prime numbers is 129.

Eso es correcto. Al observar los rastros, el agente creó y ejecutó este programa Python para calcular lo que le pedí:

import math

def is_prime(n):
    if n 

Ahora, volvamos a la agente-libro-vuelo Agente. Quiero tener una mejor comprensión de la cantidad total de vuelos disponibles durante un largo período de tiempo. Para ello, empiezo por agregar una nueva función al mismo grupo de acciones para obtener todos los vuelos disponibles en un rango de fechas.

Nombro la nueva función obtener vuelos dentro del rango de fechas y usa esta descripción:

Get all the flights between two destinations for each day in a date range.

Todos los parámetros son obligatorios y de tipo cadena. Estos son los nombres y descripciones de los parámetros:

origen_aeropuerto – Origin IATA airport code
aeropuerto de destino – Destination IATA airport code
fecha de inicio – Start date of the flight in YYYYMMDD format
fecha final – End date of the flight in YYYYMMDD format

Si observa el código de la función Lambda que compartí anteriormente, encontrará que ya admite esta función de agente.

Ahora que el agente tiene una forma de extraer más información con una sola llamada de función, le pido que visualice los datos de información del vuelo en un gráfico:

Draw a chart with the number of flights each day from JFK to SEA for the first ten days of August, 2024.

La respuesta del agente incluye un gráfico:

Selecciono el enlace para descargar la imagen en mi computadora:

Así es. De hecho, el simulador de las funciones Lambda genera entre uno y seis vuelos al día, como se muestra en el gráfico.

Uso de interpretación de código con archivos adjuntos
Debido a que la interpretación de código permite a los agentes procesar y extraer información de los datos, introdujimos la capacidad de incluir documentos al invocar a un agente. Por ejemplo, tengo un archivo de Excel con la cantidad de vuelos reservados para diferentes vuelos:

Origen	Destino	Número de vuelos
LHR	Ministerio de Relaciones Exteriores	636
Ministerio de Relaciones Exteriores	LHR	456
JFK	MAR	921
MAR	JFK	544

Usando el icono del clip en la interfaz de prueba, adjunto el archivo y pregunto (el agente responde en atrevido):

What is the most popular route? And the least one?

Según el análisis, la ruta más popular es JFK -> SEA con 921 reservas, y la ruta menos popular es FCO -> LHR con 456 reservas.

How many flights in total have been booked?

El número total de vuelos reservados en todas las rutas es 2557.

Draw a chart comparing the % of flights booked for these routes compared to the total number.

Puedo ver los rastros para ver el código Python utilizado para extraer información del archivo y pasárselo al agente. Puedo adjuntar más de un archivo y utilizar diferentes formatos de archivo. Estas opciones están disponibles en los SDK de AWS para permitir que los agentes utilicen archivos en sus aplicaciones.

Cosas que saber
La retención de memoria está disponible en versión preliminar en todas las regiones de AWS donde están disponibles los agentes para Amazon Bedrocks y Claude 3 Sonnet o Haiku de Anthropic (los modelos admitidos durante la versión preliminar). La interpretación de código está disponible en versión preliminar en las regiones Este de EE. UU. (Norte de Virginia), Oeste de EE. UU. (Oregón) y Europa (Frankfurt).

No hay costos adicionales durante la vista previa por usar la retención de memoria y la interpretación de código con sus agentes. Cuando se usan agentes con estas funciones, se aplican los cargos normales por uso del modelo. Cuando se habilita la retención de memoria, usted paga por el modelo utilizado para resumir la sesión. Para obtener más información, consulte la página de precios de Amazon Bedrock.

Para obtener más información, consulte la sección Agentes para Amazon Bedrock de la Guía del usuario. Para obtener contenido técnico detallado y descubrir cómo otros utilizan la IA generativa en sus soluciones, visite comunidad.aws.

— Danilo