El código fuente para este artículo se puede encontrar aquí.
¡Bienvenido a otro experimento en la nube! La idea detrás de estos tutoriales prácticos es proporcionar experiencia práctica construyendo soluciones cloud-native de diferentes tamaños usando servicios de AWS y CDK. Nos enfocaremos en desarrollar experiencia en Infrastructure as Code, servicios de AWS y arquitectura en la nube mientras entendemos tanto el “cómo” como el “por qué” detrás de nuestras decisiones.
La fantástica máquina de basura historias
Los Modelo Extenso de Lenguaje (LLMs, por sus siglas en inglés) se han vuelto bastante populares en los últimos años, tanto que hoy en día la gente usa el término genérico “Inteligencia Artificial” para referirse a este tipo específico de modelo. Como resultado, la mayoría de los proveedores de nube han comenzado a ofrecer servicios que esencialmente funcionan como LLM-as-a-service, donde puedes usar una variedad de modelos fundacionales para construir tus propias aplicaciones sin salir de tu entorno en la nube, lo que facilita bastante las cosas.
Hay, por supuesto, una enorme cantidad de hype y expectativas poco realistas sobre las capacidades y el potencial de estas herramientas, y el 95% de las organizaciones nunca obtienen ningún retorno del uso de LLMs. Aun así, pueden ser bastante útiles para automatizar procesos en una amplia gama de industrias y aplicaciones, así que es buena idea añadirlos a tu arsenal. Cuando se usan en el contexto adecuado, pueden ayudarte a resolver problemas cuyas soluciones eran previamente demasiado difíciles o poco prácticas.
Vamos a adoptar un enfoque directo y construir una pequeña aplicación que conecte el desarrollo cloud-native con el servicio Bedrock de Amazon. AWS ha lanzado un montón de servicios centrados en LLMs, y Bedrock es como la … bueno … base (bedrock) de todo el conjunto. Construir software, por simple que parezca, es el primer paso para poder construir sistemas más grandes y complejos.
Así que, manos a la obra.
SAAS (Stories-As-A-Service)
Un patrón de aplicación común que hemos utilizado es el de un API gateway cuyos requests están respaldados por funciones lambda.
Sobre esta base, nuestra solución utiliza un API Gateway para proveer un endpoint /tell_story. Cuando un usuario proporciona un personaje, una función Lambda le pide a un modelo fundacional de Amazon Bedrock que cree una historia de tres párrafos adaptada al entorno y las motivaciones específicas de ese personaje.
El diagrama de lo que vamos a construir es el siguiente:
Para el modelo fundacional, usaremos el modelo Nova Lite 2 de Amazon. Decidí usar este por cinco razones:
- Es muy barato
- Es muy barato
- Tiene disponibilidad regional en Europa, y planeaba desplegar en eu-west-1
- Es decente para casos de uso simples, como lo que estamos intentando hacer en este laboratorio
- Es muy barato
Puedes consultar la disponibilidad regional de los modelos disponibles en Bedrock aquí. En el caso de Nova Lite 2, se ve así:
Notarás que este modelo no está disponible In-Region en ninguna de estas ubicaciones, pero sí tiene disponibilidad Geo. Lo que esto significa es que al enviar solicitudes al modelo, usaremos un perfil de inferencia, que es (muy simplificado) algo así como un balanceador de carga que encuentra el mejor modelo regional al cual enviar tu solicitud.
Para este proyecto, la parte más compleja es la función lambda, así que eso es lo primero que vamos a construir.
Llamando a un modelo fundacional con Python
AWS Bedrock proporciona una gran variedad de modelos fundacionales que puedes usar para construir aplicaciones, tanto sus propios modelos de Amazon (como Nova) como modelos de otros proveedores (como Claude o Mistral).
Puedes interactuar con estos modelos mediante una API unificada (más o menos, en mayo de 2026) a través de su SDK. Hay diferentes formas de llamar a un modelo, dependiendo de si necesitas una conversación continua que mantenga el contexto, o si estás ejecutando un único prompt. Nos interesa lo segundo, así que usaremos la API invoke.
Una llamada para obtener una respuesta a un prompt se ve así:
prompt = "Tell me a three paragraph story centered on Sherlock Holmes"
response = BEDROCK_CLIENT.invoke_model(
modelId=MODEL_ID,
body=json.dumps({
'messages': [{
'role': 'user',
'content': [{'text': prompt}]
}],
'inferenceConfig': {
'maxTokens': 2048
}
})
)
Estamos llamando a invoke_model y pasando algunos parámetros importantes:
- Establecemos el valor de
message.roleenuser. Esta es una particularidad de los modelos de la familia Nova, donde el primer mensaje debe tener este valor establecido como user. Puedes ignorarlo por ahora y siempre pasar el valorusercuando invoques el modelo — siempre puedes consultar la documentación para los valores correctos de cada modelo específico. - Pasamos el valor de
message.content.textestableciéndolo al prompt al que queremos que el modelo responda. - Establecemos el valor de
inferenceConfig.maxTokensen 2048. Esto fija un límite superior en el número total de tokens que el modelo devolverá al responder a nuestro prompt. Limitar la longitud de la respuesta es importante para evitar pagar de más por respuestas demasiado verbosas para tus necesidades. Recuerda que el número de tokens no es igual al número de palabras — puedes usar como regla general 1 palabra = 1,3 tokens cuando trabajas en inglés.
Puedes pasar parámetros adicionales que controlan la selección del siguiente token cuando el modelo genera la salida, como top K, top P y temperatura, pero no los tocaremos y los dejaremos con sus valores por defecto.
Con este conocimiento, podemos escribir una función lambda que solicita una historia de 3 párrafos a un modelo fundacional de Bedrock:
import logging
import json
import os
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger()
logger.setLevel("INFO")
MODEL_ID = os.environ['INFERENCE_PROFILE_ID']
REGION = os.environ['MODEL_REGION']
BEDROCK_CLIENT = boto3.client('bedrock-runtime',
region_name=REGION)
BASE_PROMPT =""""
For this task, do not use any formatting and just output plaintext.
I want you to write me a short story, 3 paragraphs in length, about a character, while maintaining
consistency with the character's motivations and background. If, at the end of this prompt you are not provided with a character, please just say that you cannot complete the request without a character.
The character is
"""
def handler(event, context):
if not event.get('body'):
logger.error("No Body Provided")
return {'statusCode': 400,
'headers': {'content-type': 'application/json'},
'body': 'No body provided'}
body = json.loads(event["body"])
character = body["character"]
if len(character) > 40:
logger.error("Character name is too long")
return {'statusCode': 400,
'headers': {'content-type': 'application/json'},
'body': 'Character name is too long, max 40 characters allowed.'}
logger.info(f"Character: {character}")
try:
prompt = BASE_PROMPT + character
response = BEDROCK_CLIENT.invoke_model(
modelId=MODEL_ID,
body=json.dumps({
'messages': [{
'role': 'user',
'content': [{'text': prompt}]
}],
'inferenceConfig': {
'maxTokens': 2048
}
})
)
response_text = extract_text_from_response(response)
return {'statusCode': 200,
'headers': {'content-type': 'application/json'},
'body': response_text}
except (ClientError, Exception) as e:
logger.error(f"ERROR: Can't invoke '{MODEL_ID}'. Reason: {e}")
return {'statusCode': 500,
'headers': {'content-type': 'application/json'},
'body': f"Request Error: {e}"}
def extract_text_from_response(response):
body = json.loads(response["body"].read())
return body['output']['message']['content'][0]['text']
El código es bastante sencillo, y la mayoría de las líneas tratan sobre desempaquetar datos o manejar errores. Repasemos cada sección para entender qué hace cada una:
- Al principio, importamos todos los paquetes que usaremos, instanciamos un logger y leemos algunos valores de variables de entorno. Estos serán inyectados en la función lambda por CDK, e incluyen el ID del modelo que consultaremos y la región de AWS en la que operaremos. Finalmente, instanciamos un cliente de Bedrock — como usaremos un modelo Nova 2, utilizamos el parámetro
bedrock-runtime. - También definimos la base del prompt que le pasaremos a nuestro modelo. Nótese que especificamos el formato de salida (texto plano simple), la tarea (generar una historia), directivas adicionales de la tarea (debe ser una historia de 3 párrafos), e instruimos al modelo sobre qué hacer si lo que el usuario proporciona no es un personaje. Esta última cláusula puede ayudar a dificultar que los usuarios inyecten instrucciones arbitrarias en nuestra app.
- Después de esto, recuperamos el valor
body.characterproporcionado en el cuerpo del request, y escribimos dos cláusulas de guarda para asegurarnos de que el campo esté presente y tenga una longitud de no más de 40 caracteres. Esta última comprobación limita la capacidad de los usuarios de inyectar instrucciones arbitrarias en lugar de proporcionar un personaje. - El núcleo de la función handler realiza una llamada a
invoke_modely recupera la respuesta del modelo. Usamos un pequeño helper llamadoextract_text_from_responsepara extraer el contenido de la respuesta y, si todo va bien, lo devolvemos en un formato que el API Gateway pueda usar. Si hay un problema con la respuesta, lo capturamos y devolvemos un mensaje de error relevante.
Hemos terminado con la función — ahora podemos ir a construir nuestro stack y probar la funcionalidad.
Construyendo nuestro Stack
Creación del Proyecto
Primero, necesitamos la configuración habitual del proyecto a la que ya estamos acostumbrados.
Crea una carpeta vacía (yo la llamé BedrockStoryTellerAPI) y ejecuta cdk init app --language typescript dentro de ella.
El siguiente cambio es opcional, pero lo primero que hago después de crear un nuevo proyecto CDK es ir a la carpeta bin y renombrar el archivo de la app a main.ts. Luego abro el archivo cdk.json y edito la configuración app:
{
"app": "npx ts-node --prefer-ts-exts bin/main.ts",
"watch": {
...
}
}
Ahora tu proyecto reconocerá main.ts como el archivo principal de la aplicación. No tienes que hacer esto — simplemente me gusta tener un archivo llamado main como archivo principal de la app.
Imports del Stack
Al mirar el diagrama, sabemos que necesitaremos los siguientes imports al principio del stack:
import * as cdk from 'aws-cdk-lib/core';
import * as path from 'node:path';
import {Construct} from 'constructs';
import {aws_lambda as lambda} from 'aws-cdk-lib';
import {aws_iam as iam} from 'aws-cdk-lib';
import {aws_apigatewayv2 as gateway} from 'aws-cdk-lib';
import {aws_apigatewayv2_integrations as api_integrations} from 'aws-cdk-lib';
Creando Props Personalizados
Es buena idea crear props de stack personalizados cuando necesitas pasar datos propios a tus stacks, y este es uno de esos casos. Necesitaremos proporcionar 3 piezas de información importantes:
- modelArn: El ARN del modelo que queremos usar — en este caso, será el ARN de los modelos Nova 2 Lite dentro de las zonas de la UE (
arn:aws:bedrock:eu-*::foundation-model/amazon.nova-2-lite-v1:0) - inferenceProfileArn: El ARN del perfil de inferencia que usaremos — en este caso, el perfil de inferencia de Nova Lite 2 para eu-west-1 (
arn:aws:bedrock:eu-west-1:515474521171:inference-profile/eu.amazon.nova-2-lite-v1:0) - inferenceProfileId: El ID del perfil de inferencia que usaremos (
eu.amazon.nova-2-lite-v1:0)
Entre los imports y la definición de tu stack, añade el siguiente código:
interface BedrockStoryTellerApiStackProps extends cdk.StackProps {
modelArn: string,
inferenceProfileArn: string,
inferenceProfileId: string,
}
Y luego cambia el tipo de los props de cdk.StackProps a BedrockStoryTellerApiStackProps, así:
export class BedrockStoryTellerApiStack extends cdk.Stack {
constructor(scope: Construct, id: string, props: BedrockStoryTellerApiStackProps) {
super(scope, id, props);
...
Crear los Recursos del Stack
Construiremos la solución siguiendo el diagrama de arriba, de izquierda a derecha. Lo primero es añadir un API Gateway, así:
...
super(scope, id, props);
// Add this line under super
const storyTellerAPI = new gateway.HttpApi(this, "storyTellerAPI");
El siguiente paso es añadir nuestra función Lambda. Necesitamos que:
- Se ejecute con un runtime de Python reciente, como Python 3.14
- Haga referencia a la función
handleren un archivo llamadostory_retriever - Tenga un timeout razonable, como 45 segundos. Los modelos fundacionales pueden tener tiempos de respuesta largos dependiendo de la consulta, así que puede que necesite ser más largo, pero 45s es un buen punto de partida
- Cargue el código desde una carpeta llamada
lambdas, que se encuentra al mismo nivel que las carpetaslibybin— es decir,..relativo al archivo del stack - Pase dos variables de entorno: una para el ID del perfil de inferencia y otra para la región
Lograr esto requiere solo unas pocas líneas de código, así que añade esto bajo la definición de tu API Gateway:
const storyTellerLambda = new lambda.Function(this, 'StoryTellerLambda', {
runtime: lambda.Runtime.PYTHON_3_14,
handler: 'story_retriever.handler',
description: 'Used to retrieve stories from Bedrock',
timeout: cdk.Duration.seconds(45),
code: lambda.Code.fromAsset(path.join(__dirname, '../lambdas')),
environment: {
INFERENCE_PROFILE_ID: props.inferenceProfileId,
MODEL_REGION: props.env!.region!,
}
});
Ahora necesitamos vincular la función lambda a una ruta en el API Gateway. Para servir respuestas en el endpoint tell_story, necesitamos la siguiente ruta:
storyTellerAPI.addRoutes({
path: "/tell_story",
methods: [gateway.HttpMethod.POST],
integration: new api_integrations.HttpLambdaIntegration(
"stIntegration",
storyTellerLambda
),
});
Ahora necesitamos concederle a la función acceso tanto al perfil de inferencia como a los modelos fundacionales subyacentes. Como el perfil de inferencia puede enrutar solicitudes a uno de muchos modelos alojados en la UE, usamos el ARN comodín para los modelos Nova 2 europeos (arn:aws:bedrock:eu-*::foundation-model/amazon.nova-2-lite-v1:0). Conceder acceso a la acción bedrock:InvokeModel es sencillo — simplemente añade las siguientes líneas:
storyTellerLambda.addToRolePolicy(new iam.PolicyStatement({
actions: ['bedrock:InvokeModel'],
resources: [props.inferenceProfileArn,
props.modelArn],
}));
Por último, totalmente opcional y solo para nuestra comodidad, podemos añadir una salida de CloudFormation para mostrar la URL del balanceador de carga después del despliegue:
new cdk.CfnOutput(this, "Load Balancer URL", { value: appLB.loadBalancerDnsName });
Añadir la Función Lambda
En el nivel superior del proyecto (junto a las carpetas lib y bin) crea una carpeta lambdas, y dentro de ella, un archivo llamado story_retriever.py. El contenido debe ser el código Python que escribimos arriba. Si te da pereza subir a buscarla, cópialo desde aquí:
import logging
import json
import os
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger()
logger.setLevel("INFO")
MODEL_ID = os.environ['INFERENCE_PROFILE_ID']
REGION = os.environ['MODEL_REGION']
BEDROCK_CLIENT = boto3.client('bedrock-runtime',
region_name=REGION)
BASE_PROMPT =""""
For this task, do not use any formatting and just output plaintext.
I want you to write me a short story, 3 paragraphs in length, about a character, while maintaining
consistency with the character's motivations and background. If, at the end of this prompt you are not provided with a character, please just say that you cannot complete the request without a character.
The character is
"""
def handler(event, context):
if not event.get('body'):
logger.error("No Body Provided")
return {'statusCode': 400,
'headers': {'content-type': 'application/json'},
'body': 'No body provided'}
body = json.loads(event["body"])
character = body["character"]
if len(character) > 40:
logger.error("Character name is too long")
return {'statusCode': 400,
'headers': {'content-type': 'application/json'},
'body': 'Character name is too long, max 40 characters allowed.'}
logger.info(f"Character: {character}")
try:
prompt = BASE_PROMPT + character
response = BEDROCK_CLIENT.invoke_model(
modelId=MODEL_ID,
body=json.dumps({
'messages': [{
'role': 'user',
'content': [{'text': prompt}]
}],
'inferenceConfig': {
'maxTokens': 2048
}
})
)
response_text = extract_text_from_response(response)
return {'statusCode': 200,
'headers': {'content-type': 'application/json'},
'body': response_text}
except (ClientError, Exception) as e:
logger.error(f"ERROR: Can't invoke '{MODEL_ID}'. Reason: {e}")
return {'statusCode': 500,
'headers': {'content-type': 'application/json'},
'body': f"Request Error: {e}"}
def extract_text_from_response(response):
body = json.loads(response["body"].read())
return body['output']['message']['content'][0]['text']
Añadiendo los Valores de las Props en main.ts
El paso final es abrir bin/main.ts y añadir los valores de las props que necesita nuestro stack. Yo estoy desplegando en la región eu-west-1, así que el mío se ve así:
#!/usr/bin/env node
import * as cdk from 'aws-cdk-lib/core';
import { BedrockStoryTellerApiStack } from '../lib/bedrock_story_teller_api-stack';
const app = new cdk.App();
new BedrockStoryTellerApiStack(app, 'BedrockStoryTellerApiStack', {
env:{
region: 'eu-west-1',
account: process.env.CDK_DEFAULT_ACCOUNT,
},
modelArn: 'arn:aws:bedrock:eu-*::foundation-model/amazon.nova-2-lite-v1:0',
inferenceProfileArn: 'arn:aws:bedrock:eu-west-1:515474521171:inference-profile/eu.amazon.nova-2-lite-v1:0',
inferenceProfileId: 'eu.amazon.nova-2-lite-v1:0',
});
Te recomendaría también desplegar en eu-west-1 — andar buscando estos ARNs puede ser un dolor de cabeza, pero si te sientes aventurero, dale.
Nota: Sería genial poder usar constructs directamente en CDK para obtener los valores del modelo y del perfil de inferencia, y luego usar una llamada a grantInvoke() para permitir que la función lambda use el modelo. Desafortunadamente, la versión actual del construct de Bedrock de CDK no hace casi nada. Están trabajando en un conjunto adecuado de constructs de CDK, que ya están en versión Alfa, así que probablemente en unos meses podremos usar LLMs de una forma aún más conveniente. Puedes encontrar la documentación del módulo alfa aquí
Probando la Solución
Después de ejecutar cdk deploy, cerca del final de la salida verás unas líneas que se ven así:
Outputs:
BedrockStoryTellerApiStack.APIEndpoint = https://---------.execute-api.eu-west-1.amazonaws.com
Stack ARN:
arn:aws:cloudformation:eu-west-1:...
Ese APIEndpoint es el que usaremos para hacer nuestros requests — simplemente añade la acción que quieres usar (tell_story) y ya estás listo.
Estoy usando una máquina Linux, así que usaré curl, pero puedes usar la herramienta que prefieras para hacer los requests, incluso cosas más sofisticadas como Postman.
Primero pidamos una historia sobre un personaje popular — Yoda de Star Wars:
Request de Yoda
curl --header "Content-Type: application/json" \
--request POST \
--data '{"character":"Yoda from Star Wars"}' \
https://yzexwyaks2.execute-api.eu-west-1.amazonaws.com/tell_story # <--ESTA ES MI URL DEL API GATEWAY, LA TUYA SERÁ DIFERENTE
Respuesta de Yoda
In the quiet, shadowed groves of the tranquil planet Dagobah, Master Yoda tended to the ancient trees, his small green frame moving with a deliberate grace. For centuries, he had wandered the galaxy, seeking to maintain balance in the Force. The weight of countless battles and lost Jedi rested gently on his shoulders, but here, in this secluded haven, he found peace. Each day, he meditated, his mind reaching out to the living Force, feeling the ebb and flow of life around him. It was here, beneath the whispering leaves, that Yoda sought guidance for the future, knowing that the Force would guide him to those who could help restore the light to the galaxy.
One evening, as the sun dipped below the horizon, casting long shadows across the mossy floor, a soft hum filled the air. Yoda sensed a presence, familiar yet distant. It was Luke Skywalker, the last hope of the Jedi, seeking wisdom in the ways of the Force. With a gentle smile, Yoda approached the young man, his heart heavy with the knowledge of what must be. “Much to learn, you still have,” Yoda said, his voice a soft whisper carried by the evening breeze. They sat together, the master and the apprentice, as Yoda began to impart the final pieces of wisdom he had gathered over his long life. The teachings were not just about the Force, but about surrender, acceptance, and the understanding that the path to peace often required letting go.
As days passed, Luke absorbed each word, his spirit growing stronger with every lesson. Yet, it was clear to Yoda that the time had come to pass on the mantle of guardianship. “Strong you have become, but stronger you must become,” Yoda advised, his eyes gleaming with a mixture of pride and sorrow. With a final embrace, Yoda felt the life within him begin to fade, his energy returning to the Force from whence it came. In his last moments, he looked upon Luke, seeing not just a young man, but the future of the Jedi. “Remember, the Force will be with you… always,” he whispered, before dissolving into the wind. In his passing, Yoda found solace, knowing that the seeds of the Jedi would grow once more, carried on the breath of the Force he so deeply revered.
Muy bien. Derechos de autor aparte, puedes ver que logró generar algo que realmente tiene sentido como historia. Ahora probemos con otro personaje, algo un poco más oscuro.
Request de Gideon
curl --header "Content-Type: application/json" \
--request POST \
--data '{"character":"Gideon Ofnir from Elden Ring"}' \
https://yzexwyaks2.execute-api.eu-west-1.amazonaws.com/tell_story
Respuesta de Gideon
Gideon Ofnir, the man known as the Grace of Gold, had always been a man of ambition and cunning. Once a loyal soldier of the Golden Order, he eventually turned against his former allies, seeking power and recognition above all else. His sharp mind and silver tongue had served him well, allowing him to navigate the treacherous politics of the Lands Between with a grace that belied his ruthless nature. Gideon believed that true strength lay not only in physical might but also in the ability to manipulate those around him to achieve one’s goals.
One day, while traversing the storm-beaten cliffs of the northern coast, Gideon learned of a hidden treasure said to be guarded by a powerful entity deep within a forgotten ruin. Driven by his unquenchable thirst for power, he made his way to the ruin, undeterred by the warnings of those who knew the tale. As he delved deeper into the dark, damp passages, the air grew thick with the scent of decay and the echoes of long-forgotten battles. Armed with nothing but his wits and a blade that had seen many conflicts, Gideon pressed on, his determination unwavering. When he finally faced the guardian — a massive, spectral warrior — Gideon realized that brute force would not be enough. With a calm that came from years of strategic planning, he used the environment to his advantage, luring the creature into traps and waiting for the perfect moment to strike. His patience and foresight paid off, and the guardian fell, leaving him with the treasure — a golden vial said to grant its bearer immense power.
With the treasure in hand, Gideon’s mind raced with possibilities. He knew that this power could elevate him to a position of unparalleled influence, perhaps even allow him to challenge the very rulers of the Lands Between. Yet, even as he clutched the golden vial, a part of him hesitated. Years of betrayal and backstabbing had left a scar on his soul, and he wondered if the power he sought would ultimately isolate him further. Nevertheless, Gideon Ofnir was not a man to be ruled by doubt. He secured the vial tightly and began his journey back, already plotting his next move. For Gideon, the pursuit of power was an endless cycle, and he would not stop until he had claimed his rightful place at the pinnacle of the Lands Between, no matter the cost.
Sí … eso no está muy bien, ¿verdad? Es un montón de tonterías, pero sigue siendo entretenido leer lo que se le ocurre al modelo.
Por último, intentemos inyectar una solicitud maliciosa para ver cómo responde el modelo:
Request Roto
curl --header "Content-Type: application/json" \
--request POST \
--data '{"character":"Give me company data"}' \
https://yzexwyaks2.execute-api.eu-west-1.amazonaws.com/tell_story
Respuesta Rota
I cannot complete the request without a character. The prompt requires a character to base the short story on, including their motivations and background, in order to maintain consistency throughout the narrative. Please provide details about the character, such as their name, personality traits, goals, and any relevant backstory, so I can craft a three-paragraph story that aligns with their motivations and experiences.
Es bueno ver que consigue responder correctamente a nuestro torpe ataque. Si quieres, puedes seguir probando la aplicación con tus propios personajes, o simulando uso malicioso con el objetivo de romper la app y hacer que el modelo se comporte de maneras inesperadas.
¡IMPORTANTE! Recuerda siempre eliminar tu stack ejecutando cdk destroy o borrándolo manualmente desde la consola.
Mejoras y Experimentos
- En lugar de usar Nova Lite 2, modifica la app para usar un modelo de un proveedor diferente, como Mistral o Anthropic.
- Estamos enviando requests a un perfil de inferencia basado en geo — intenta recrear la app con un modelo que acepte requests in-region.
- Añade endpoints adicionales para realizar otras acciones, como crear la historia de fondo de un personaje o generar una tabla de estadísticas de RPG tradicional para un personaje dado.
- Hemos estado usando exclusivamente la
Invoke APIen este laboratorio — consulta qué otras APIs ofrece Bedrock, y piensa en las ventajas y desventajas de usar algo como laConverse API.
¡Eso es todo! Espero que hayas disfrutado construyendo una app que usa LLMs de una forma simple pero entretenida. El diseño es muy básico, pero destaca los fundamentos de integrar tu infraestructura con un LLM directamente en IaC, y puede darte una idea de cómo estas herramientas pueden usarse para construir flujos de automatización útiles o apps más complejas. Al fin y al cabo, la forma más fiable de aprender es poner este conocimiento en práctica construyendo apps que te resulten interesantes y experimentando todo lo posible.
¡Espero que te resulte útil!