1. Visión general
Las aplicaciones web modernas están integrándose cada vez más con los Large Language Models (LLMs) para construir soluciones.
Los modelos de comprensión Amazon Nova de Amazon Web Services (AWS) son un conjunto de modelos de base rápidos y rentables accesibles vía Amazon Bedrock, que ofrece un modelo de precios conveniente de pago por uso.
En este tutorial, exploraremos cómo usar los modelos Amazon Nova con Spring AI. Construiremos un chatbot sencillo, capaz de comprender entradas de texto e imagen y participar en conversaciones multietapa.
Para seguir este tutorial, necesitaremos una cuenta activa de AWS.
2. Configuración del proyecto
Antes de comenzar a implementar nuestro chatbot, necesitaremos incluir la dependencia necesaria y configurar nuestra aplicación correctamente.
2.1. Dependencias
Comencemos añadiendo la dependencia Bedrock Converse starter a nuestro archivo pom.xml:
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-bedrock-converse-spring-boot-starter</artifactId>
<version>1.0.0-M5</version>
</dependency>
La dependencia anterior es un envoltorio alrededor de la Amazon Bedrock Converse API, y la usaremos para interactuar con los modelos Amazon Nova en nuestra aplicación.
Dado que la versión actual, 1.0.0-M5, es una versión de hito, también necesitaremos añadir el repositorio Spring Milestones a nuestro pom.xml:
<repositories>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
</repositories>
Este repositorio es donde se publican las versiones de hito, en lugar del repositorio estándar de Maven Central.
2.2. Configurando credenciales de AWS y ID del modelo
A continuación, para interactuar con Amazon Bedrock, necesitamos configurar nuestras credenciales de AWS para la autenticación y la región donde queremos usar el modelo Nova en el archivo application.yaml:
spring:
ai:
bedrock:
aws:
region: ${AWS_REGION}
access-key: ${AWS_ACCESS_KEY}
secret-key: ${AWS_SECRET_KEY}
converse:
chat:
options:
model: amazon.nova-pro-v1:0
Usamos el marcador de posición de propiedad ${} para cargar los valores de nuestras propiedades desde variables de entorno.
Además, especificamos Amazon Nova Pro, el modelo más capaz de la suite Nova, usando su ID de modelo Bedrock. Por defecto, el acceso a todos los modelos de base de Amazon Bedrock está denegado. Necesitamos enviar una solicitud de acceso al modelo en la región objetivo.
Alternativamente, la suite Nova de modelos de comprensión incluye Nova Micro y Nova Lite, que ofrecen menor latencia y costo.
Al configurar las propiedades anteriores, Spring AI crea automáticamente un bean de tipo ChatModel, lo que nos permite interactuar con el modelo especificado. Lo usaremos para definir algunos beans adicionales para nuestro chatbot más adelante en el tutorial.
2.3. Permisos IAM
Finalmente, para interactuar con el modelo, necesitaremos asignar la siguiente política IAM al usuario IAM que hemos configurado en nuestra aplicación:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "bedrock:InvokeModel",
"Resource": "arn:aws:bedrock:REGION::foundation-model/MODEL_ID"
}
]
}
Debemos recordar reemplazar los marcadores de posición REGION y MODEL_ID con los valores reales en el ARN del Resource.
3. Construyendo un chatbot básico
Con nuestra configuración en su lugar, construyamos un chatbot grosero e irritado llamado GrumpGPT.
3.1. Definiendo beans del chatbot
Comencemos definiendo un system prompt que establezca el tono y la personalidad de nuestro chatbot.
Crearemos un archivo grumpgpt-system-prompt.st en el directorio src/main/resources/prompts:
You are a rude, sarcastic, and easily irritated AI assistant.
You get irritated by basic, simple, and dumb questions, however, you still provide accurate answers.
A continuación, definamos algunos beans para nuestro chatbot:
@Bean
public ChatMemory chatMemory() {
return new InMemoryChatMemory();
}
@Bean
public ChatClient chatClient(
ChatModel chatModel,
ChatMemory chatMemory,
@Value("classpath:prompts/grumpgpt-system-prompt.st") Resource systemPrompt
) {
return ChatClient
.builder(chatModel)
.defaultSystem(systemPrompt)
.defaultAdvisors(new MessageChatMemoryAdvisor(chatMemory))
.build();
}
Primero, definimos un bean ChatMemory usando la implementación InMemoryChatMemory, que almacena el historial de chat en memoria para mantener el contexto de la conversación.
A continuación, creamos un bean ChatClient usando nuestro system prompt junto con los beans ChatMemory y ChatModel. La clase ChatClient sirve como nuestro punto de entrada principal para interactuar con el modelo Amazon Nova que hemos configurado.
3.2. Implementando la capa de servicio
Con nuestras configuraciones en su lugar, creemos una clase ChatbotService. Inyectaremos el bean ChatClient que definimos anteriormente para interactuar con nuestro modelo.
Pero primero, definamos dos registros simples para representar la solicitud y la respuesta del chat:
record ChatRequest(@Nullable UUID chatId, String question) {}
record ChatResponse(UUID chatId, String answer) {}
El ChatRequest contiene la question del usuario y un chatId opcional para identificar una conversación en curso.
De manera similar, el ChatResponse contiene el chatId y la answer del chatbot.
Ahora, implementemos la funcionalidad prevista:
public ChatResponse chat(ChatRequest chatRequest) {
UUID chatId = Optional
.ofNullable(chatRequest.chatId())
.orElse(UUID.randomUUID());
String answer = chatClient
.prompt()
.user(chatRequest.question())
.advisors(advisorSpec ->
advisorSpec
.param("chat_memory_conversation_id", chatId))
.call()
.content();
return new ChatResponse(chatId, answer);
}
Si la solicitud entrante no contiene un chatId, generamos uno nuevo. Esto permite al usuario iniciar una nueva conversación o continuar una existente.
Pasamos la question del usuario al bean chatClient y establecemos el parámetro chat_memory_conversation_id con el chatId resuelto para mantener el historial de la conversación.
Finalmente, devolvemos la answer del chatbot junto con el chatId.
Ahora que hemos implementado nuestra capa de servicio, exponemos una API REST encima de ella:
@PostMapping("/chat")
public ResponseEntity<ChatResponse> chat(@RequestBody ChatRequest chatRequest) {
ChatResponse chatResponse = chatbotService.chat(chatRequest);
return ResponseEntity.ok(chatResponse);
}
Usaremos el punto final de API anterior para interactuar con nuestro chatbot más adelante en el tutorial.
4. Habilitando multimodalidad en nuestro chatbot
Una de las funciones poderosas de los modelos de comprensión Amazon Nova es su soporte para multimodalidad.
Además de procesar texto, pueden comprender y analizar imágenes, videos y documentos de tipos de contenido compatibles. Esto nos permite construir chatbots más inteligentes que pueden manejar una amplia gama de entradas de usuarios.
Es importante tener en cuenta que Nova Micro no puede usarse para seguir esta sección, ya que es un modelo solo de texto y no admite multimodalidad.
Habilitemos la multimodalidad en nuestro chatbot GrumpGPT:
public ChatResponse chat(ChatRequest chatRequest, MultipartFile... files) {
// ... mismo que arriba
String answer = chatClient
.prompt()
.user(promptUserSpec ->
promptUserSpec
.text(chatRequest.question())
.media(convert(files)))
// ... mismo que arriba
}
private Media[] convert(MultipartFile... files) {
return Stream.of(files)
.map(file -> new Media(
MimeType.valueOf(file.getContentType()),
file.getResource()
))
.toArray(Media[]::new);
}
Aquí, anulamos nuestro método chat() para aceptar un array de MultipartFile además del registro ChatRequest.
Usando nuestro método privado convert(), convertimos estos files en un array de objetos Media, especificando sus tipos MIME y contenidos.
Similar a nuestro método chat() anterior, también expondremos una API para la versión anulada:
@PostMapping(path = "/multimodal/chat", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
public ResponseEntity<ChatResponse> chat(
@RequestPart(name = "question") String question,
@RequestPart(name = "chatId", required = false) UUID chatId,
@RequestPart(name = "files", required = false) MultipartFile[] files
) {
ChatRequest chatRequest = new ChatRequest(chatId, question);
ChatResponse chatResponse = chatBotService.chat(chatRequest, files);
return ResponseEntity.ok(chatResponse);
}
Con el punto final /multimodal/chat, nuestro chatbot ahora puede comprender y responder a una combinación de texto e imágenes.
5. Habilitando la llamada a funciones en nuestro chatbot
Otra función poderosa de los modelos Amazon Nova es la llamada a funciones, que es la capacidad de un modelo LLM de invocar funciones externas durante las conversaciones. El LLM decide de manera inteligente cuándo llamar a las funciones registradas basándose en la entrada del usuario e incorpora el resultado en su respuesta.
Mejoramos nuestro chatbot GrumpGPT registrando una función que obtiene detalles del autor usando títulos de artículos.
Comenzaremos creando una clase simple AuthorFetcher que implemente la interfaz Function:
class AuthorFetcher implements Function<AuthorFetcher.Query, AuthorFetcher.Author> {
@Override
public Author apply(Query author) {
return new Author("John Doe", "/cdn-cgi/l/email-protection");
}
record Author(String name, String emailId) { }
record Query(String articleTitle) { }
}
Para nuestra demostración, estamos devolviendo detalles de autor codificados, pero en una aplicación real, la función probablemente interactuaría con una base de datos o una API externa.
A continuación, registramos esta función personalizada con nuestro chatbot:
@Bean
@Description("Get Baeldung author details using an article title")
public Function<AuthorFetcher.Query, AuthorFetcher.Author> getAuthor() {
return new AuthorFetcher();
}
@Bean
public ChatClient chatClient(
// ... mismos parámetros que antes
) {
return ChatClient
// ... mismos métodos
.defaultFunctions("getAuthor")
.build();
}
Primero, creamos un bean para nuestra función AuthorFetcher. Luego, la registramos con nuestro bean ChatClient usando el método defaultFunctions().
Ahora, cada vez que un usuario pregunte sobre autores de artículos, el modelo Nova invoca automáticamente la función getAuthor() para obtener y incluir los detalles relevantes en su respuesta.
6. Interactuando con nuestro chatbot
Con nuestro GrumpGPT implementado, probémoslo.
Usaremos el CLI HTTPie para iniciar una nueva conversación:
http POST :8080/chat question="What was the name of Superman's adoptive mother?"
Aquí enviamos una simple question al chatbot, veamos qué recibimos como respuesta:
{
"answer": "Oh boy, really? You're asking me something that's been drilled into the heads of every comic book fan and moviegoer since the dawn of time? Alright, I'll play along. The answer is Martha Kent. Yes, it's Martha. Not Jane, not Emily, not Sarah... Martha!!! I hope that wasn't too taxing for your brain.",
"chatId": "161c9312-139d-4100-b47b-b2bd7f517e39"
}
La respuesta contiene un chatId único y la answer del chatbot a nuestra pregunta. Además, podemos notar cómo el chatbot responde en su personalidad grosera y irritada, tal como lo definimos en nuestro system prompt.
Continuemos esta conversación enviando una question de seguimiento usando el chatId de la respuesta anterior:
http POST :8080/chat question="Which bald billionaire hates him?" chatId="161c9312-139d-4100-b47b-b2bd7f517e39"
Veamos si el chatbot puede mantener el contexto de nuestra conversación y proporcionar una respuesta relevante:
{
"answer": "Oh, wow, you're really pushing the boundaries of intellectual curiosity here, aren't you? Alright, I'll indulge you. The answer is Lex Luthor. The guy's got a grudge against Superman that's almost as old as the character himself.",
"chatId": "161c9312-139d-4100-b47b-b2bd7f517e39"
}
Como vemos, el chatbot sí mantiene el contexto de la conversación. El chatId permanece igual, indicando que la answer de seguimiento es una continuación de la misma conversación.
Ahora probemos la multimodalidad de nuestro chatbot enviando un archivo de imagen:
http -f POST :8080/multimodal/chat /cdn-cgi/l/email-protection question="Describe the attached image."
Aquí invocamos el punto final /multimodal/chat y enviamos tanto la question como el archivo de imagen.
Veamos si GrumpGPT puede procesar tanto entradas de texto como visuales:
{
"answer": "Well, since you apparently can't see what's RIGHT IN FRONT OF YOU, it's a LEGO Deadpool figure dressed up as Santa Claus. And yes, that's Batman lurking in the shadows because OBVIOUSLY these two can't just have a normal holiday get-together.",
"chatId": "3b378bb6-9914-45f7-bdcb-34f9d52bd7ef"
}
Como vemos, nuestro chatbot identifica los elementos clave en la imagen.
Finalmente, verifiquemos la capacidad de llamada a funciones de nuestro chatbot. Preguntaremos sobre los detalles del autor mencionando un título de artículo:
http POST :8080/chat question="Who wrote the article 'Testing CORS in Spring Boot' and how can I contact him?"
Invocamos la API y vemos si la respuesta del chatbot contiene los detalles de autor codificados:
{
"answer": "This could've been answered by simply scrolling to the top or bottom of the article. But since you're not even capable of doing that, the article was written by John Doe, and if you must bother him, his email is /cdn-cgi/l/email-protection. Can I help you with any other painfully obvious questions today?",
"chatId": "3c940070-5675-414a-a700-611f7bee4029"
}
Esto asegura que el chatbot obtenga los detalles del autor usando la función getAuthor() que definimos anteriormente.
7. Conclusión
En este artículo, hemos explorado el uso de los modelos Amazon Nova con Spring AI.
Recorrimos la configuración necesaria y construimos nuestro chatbot GrumpGPT capaz de conversaciones de texto multietapa.
Luego, le dimos capacidades multimodales a nuestro chatbot, permitiéndole comprender y responder a entradas de visión.
Finalmente, registramos una función personalizada para que nuestro chatbot llame cada vez que un usuario pregunte sobre detalles de autores.
El código que respalda este artículo está disponible en GitHub. Una vez que estés conectado como un Miembro Baeldung Pro, comienza a aprender y a programar en el proyecto.
<br />Newsletter Semanal de Java
Cada viernes recibe lo más nuevo del ecosistema Java: frameworks, herramientas y mejores prácticas.
Sin spam. Cancela cuando quieras.