DEV Community: felino33

AWS ChatBot_Lavanderia

felino33 — Fri, 17 Apr 2026 03:43:03 +0000

💧 Chatbot con Amazon Bedrock Agent + Knowledge Base RAG — Lavandería Ecológica

Cómo construimos un asistente de IA conversacional para una lavandería ecológica usando Amazon Bedrock Agent, Knowledge Base RAG, AWS Lambda y una landing page 100% estática — sin servidores, sin frameworks pesados, sin complicaciones.

¿Por qué Amazon Bedrock Agent?

La mayoría de los chatbots simples solo responden con texto genérico. Un Bedrock Agent va más allá:

Memoria de sesión nativa — el agente recuerda el contexto de la conversación sin que tengas que implementar nada
Knowledge Base RAG integrada — conecta el agente a documentos propios (PDFs, FAQs, manuales) y responde con información real del negocio, no alucinaciones
Orquestación automática — el agente decide cuándo consultar la KB, cuándo responder directamente y cómo combinar fuentes
Modelo Nova-Lite — rápido, económico y suficientemente potente para casos de uso conversacionales en producción
Sin infraestructura de ML — no hay modelos que mantener, no hay GPUs, no hay pipelines de entrenamiento

Para un negocio local como una lavandería, esto significa tener un asistente que conoce sus precios, horarios, procesos ecológicos y políticas — todo extraído automáticamente de sus propios documentos.

Arquitectura completa

Cliente (navegador)
        │
        ▼
  CloudFront CDN
  ┌─────────────────────────────────────────┐
  │  /          → S3 Bucket                 │
  │             (index.html + widget JS)    │
  │                                         │
  │  /chat      → API Gateway HTTP API      │
  │             → Lambda (Flask)            │
  │             → Bedrock Agent Runtime     │
  │               ┌──────────────────────┐  │
  │               │  Bedrock Agent       │  │
  │               │  (Nova-Lite v1)      │  │
  │               │       │              │  │
  │               │  Knowledge Base RAG  │  │
  │               │  (OpenSearch + S3)   │  │
  │               └──────────────────────┘  │
  └─────────────────────────────────────────┘

Servicio AWS	Rol en el proyecto
Amazon Bedrock Agent	Orquesta la conversación, mantiene sesión, decide cuándo consultar la KB
Bedrock Knowledge Base	Indexa documentos del negocio, responde con RAG (Retrieval-Augmented Generation)
Amazon Nova-Lite v1	Modelo de lenguaje — rápido y económico para chat en producción
AWS Lambda	Ejecuta el backend Flask sin servidores, escala a cero cuando no hay tráfico
API Gateway HTTP API	Expone el endpoint `/chat` con baja latencia y manejo de CORS
Amazon S3	Almacena el frontend estático y los documentos fuente de la Knowledge Base
Amazon CloudFront	CDN global — sirve el frontend y enruta `/chat` al backend desde el mismo dominio
AWS IAM	Controla permisos mínimos entre Lambda y Bedrock

Cómo funciona el flujo de una pregunta

Usuario escribe: "¿Cuánto cuesta lavar un traje?"
        │
        ▼
chatbot-wiget.js  →  POST /chat  { sessionId, message, context }
        │
        ▼
Lambda (Flask)  →  bedrock_client.py
        │
        ▼
invoke_agent(agentId, agentAliasId, sessionId, inputText)
        │
        ▼
Bedrock Agent evalúa:
  ¿Tengo esta info en la KB?  →  Sí
        │
        ▼
Knowledge Base RAG:
  1. Embedding de la pregunta
  2. Búsqueda semántica en OpenSearch
  3. Recupera fragmentos relevantes del PDF de precios
  4. Nova-Lite genera respuesta contextualizada
        │
        ▼
Stream de respuesta  →  Lambda  →  API Gateway  →  Widget

Configuración del Bedrock Agent

Crear la Knowledge Base

# 1. Subir documentos fuente al bucket S3
aws s3 cp documentos/ s3://tintorerias-kb-docs/ --recursive

# 2. Crear la Knowledge Base (desde consola o CLI)
aws bedrock-agent create-knowledge-base \
  --name "tintorerias-ecologicas-kb" \
  --description "Documentos de servicios, precios y procesos ecológicos" \
  --role-arn arn:aws:iam::ACCOUNT_ID:role/AmazonBedrockExecutionRoleForKnowledgeBase \
  --knowledge-base-configuration '{
    "type": "VECTOR",
    "vectorKnowledgeBaseConfiguration": {
      "embeddingModelArn": "arn:aws:bedrock:us-east-1::foundation-model/amazon.titan-embed-text-v1"
    }
  }' \
  --storage-configuration '{
    "type": "OPENSEARCH_SERVERLESS",
    "opensearchServerlessConfiguration": {
      "collectionArn": "arn:aws:aoss:us-east-1:ACCOUNT_ID:collection/COLLECTION_ID",
      "vectorIndexName": "tintorerias-index",
      "fieldMapping": {
        "vectorField": "embedding",
        "textField": "text",
        "metadataField": "metadata"
      }
    }
  }'

Crear el Data Source y sincronizar

# Crear data source apuntando al bucket S3
aws bedrock-agent create-data-source \
  --knowledge-base-id TU_KB_ID \
  --name "documentos-tintorerias" \
  --data-source-configuration '{
    "type": "S3",
    "s3Configuration": {
      "bucketArn": "arn:aws:s3:::tintorerias-kb-docs"
    }
  }'

# Iniciar sincronización (indexación de documentos)
aws bedrock-agent start-ingestion-job \
  --knowledge-base-id TU_KB_ID \
  --data-source-id TU_DATA_SOURCE_ID

# Verificar estado de la sincronización
aws bedrock-agent get-ingestion-job \
  --knowledge-base-id TU_KB_ID \
  --data-source-id TU_DATA_SOURCE_ID \
  --ingestion-job-id TU_JOB_ID

Crear el Agente y asociar la Knowledge Base

# Crear el agente
aws bedrock-agent create-agent \
  --agent-name "asistente-tintorerias" \
  --agent-resource-role-arn arn:aws:iam::ACCOUNT_ID:role/AmazonBedrockExecutionRoleForAgents \
  --foundation-model "amazon.nova-lite-v1:0" \
  --instruction "Eres el asistente virtual de una lavandería ecológica. Responde preguntas sobre servicios, precios, horarios y procesos de limpieza ecológica de manera amable y concisa. Usa la información de los documentos para dar respuestas precisas."

# Asociar la Knowledge Base al agente
aws bedrock-agent associate-agent-knowledge-base \
  --agent-id TU_AGENT_ID \
  --agent-version DRAFT \
  --knowledge-base-id TU_KB_ID \
  --description "Base de conocimiento de servicios y precios"

# Preparar y publicar el agente
aws bedrock-agent prepare-agent --agent-id TU_AGENT_ID

aws bedrock-agent create-agent-alias \
  --agent-id TU_AGENT_ID \
  --agent-alias-name "produccion"

Código del cliente Bedrock

Invocar el agente (con streaming)

import boto3

client = boto3.client("bedrock-agent-runtime", region_name="us-east-1")

def chat_con_agente(mensaje: str, session_id: str) -> str:
    response = client.invoke_agent(
        agentId="PPJ6T6QBDD",
        agentAliasId="VQKXHLAVG1",
        sessionId=session_id,       # Bedrock mantiene el contexto por sessionId
        inputText=mensaje,
    )

    # La respuesta llega como stream de eventos
    texto_completo = ""
    for event in response.get("completion", []):
        chunk = event.get("chunk", {})
        if "bytes" in chunk:
            texto_completo += chunk["bytes"].decode("utf-8")

    return texto_completo or "(sin respuesta)"

# Uso
respuesta = chat_con_agente("¿Cuánto cuesta lavar una chamarra de cuero?", "sesion-123")
print(respuesta)

Consultar la Knowledge Base directamente (sin agente)

def consultar_kb(pregunta: str, kb_id: str) -> str:
    response = client.retrieve_and_generate(
        input={"text": pregunta},
        retrieveAndGenerateConfiguration={
            "type": "KNOWLEDGE_BASE",
            "knowledgeBaseConfiguration": {
                "knowledgeBaseId": kb_id,
                "modelArn": "amazon.nova-lite-v1:0",
                "generationConfiguration": {
                    "promptTemplate": {
                        "textPromptTemplate": (
                            "Eres un asistente de lavandería ecológica. "
                            "Responde basándote en esta información:\n\n"
                            "$search_results$"
                        )
                    }
                },
            },
        },
    )
    return response["output"]["text"]

Soporte multi-contexto (varios clientes, un backend)

# bedrock_client.py — patrón usado en este proyecto
CONFIGS = {
    'aquamax': {
        'type': 'agent',
        'agent_id': 'PPJ6T6QBDD',
        'agent_alias_id': 'VQKXHLAVG1',
    },
    'otro_cliente': {
        'type': 'kb',
        'kb_id': 'KB_ID_DEL_CLIENTE',
        'model_arn': 'amazon.nova-lite-v1:0',
        'prompt': "Eres el asistente de...\n\n$search_results$",
    },
}

def chat(mensaje: str, session_id: str, contexto: str) -> str:
    cfg = CONFIGS.get(contexto, CONFIGS['aquamax'])
    if cfg['type'] == 'agent':
        return _invoke_agent(mensaje, session_id, cfg)
    return _retrieve_and_generate(mensaje, cfg)

Despliegue del backend en Lambda

Empaquetar y crear la función

cd tintorerias-chatbot

# Instalar dependencias en carpeta local
pip install flask flask-cors boto3 python-dotenv -t package/
cp app.py bedrock_client.py config.py lambda_handler.py package/

# Crear ZIP de despliegue
cd package && zip -r ../lambda_deployment.zip . && cd ..

# Obtener Account ID
ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)

# Crear rol IAM con permisos mínimos
aws iam create-role \
  --role-name tintorerias-lambda-role \
  --assume-role-policy-document '{
    "Version":"2012-10-17",
    "Statement":[{
      "Effect":"Allow",
      "Principal":{"Service":"lambda.amazonaws.com"},
      "Action":"sts:AssumeRole"
    }]
  }'

aws iam attach-role-policy \
  --role-name tintorerias-lambda-role \
  --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole

aws iam put-role-policy \
  --role-name tintorerias-lambda-role \
  --policy-name BedrockAccess \
  --policy-document '{
    "Version":"2012-10-17",
    "Statement":[{
      "Effect":"Allow",
      "Action":[
        "bedrock:InvokeAgent",
        "bedrock:RetrieveAndGenerate",
        "bedrock:Retrieve",
        "bedrock:InvokeModel"
      ],
      "Resource":"*"
    }]
  }'

# Crear la función Lambda
aws lambda create-function \
  --function-name tintorerias-chatbot \
  --runtime python3.11 \
  --role arn:aws:iam::${ACCOUNT_ID}:role/tintorerias-lambda-role \
  --handler lambda_handler.handler \
  --zip-file fileb://lambda_deployment.zip \
  --timeout 30 \
  --memory-size 256 \
  --environment Variables="{
    KB_ID=TU_KB_ID,
    MODEL_ARN=amazon.nova-lite-v1:0,
    AWS_REGION=us-east-1
  }"

Crear API Gateway y conectar con Lambda

# Crear HTTP API
API_ID=$(aws apigatewayv2 create-api \
  --name "tintorerias-chat-api" \
  --protocol-type HTTP \
  --query 'ApiId' --output text)

# Crear integración Lambda
LAMBDA_ARN="arn:aws:lambda:us-east-1:${ACCOUNT_ID}:function:tintorerias-chatbot"

INTEGRATION_ID=$(aws apigatewayv2 create-integration \
  --api-id $API_ID \
  --integration-type AWS_PROXY \
  --integration-uri $LAMBDA_ARN \
  --payload-format-version "2.0" \
  --query 'IntegrationId' --output text)

# Ruta POST /chat
aws apigatewayv2 create-route \
  --api-id $API_ID \
  --route-key "POST /chat" \
  --target "integrations/$INTEGRATION_ID"

# Stage prod con auto-deploy
aws apigatewayv2 create-stage \
  --api-id $API_ID \
  --stage-name prod \
  --auto-deploy

# Permiso para que API Gateway invoque Lambda
aws lambda add-permission \
  --function-name tintorerias-chatbot \
  --statement-id apigateway-invoke \
  --action lambda:InvokeFunction \
  --principal apigateway.amazonaws.com \
  --source-arn "arn:aws:execute-api:us-east-1:${ACCOUNT_ID}:${API_ID}/*/*/chat"

# URL final del endpoint
aws apigatewayv2 get-api --api-id $API_ID --query 'ApiEndpoint' --output text

El widget de chat (frontend)

El widget es un archivo JS autocontenido que se inyecta en cualquier página HTML con un solo <script>:

<script src="chatbot-wiget.js"></script>

Internamente genera su propio DOM, estilos y lógica sin depender de ninguna librería:

// Configuración mínima necesaria
const CONFIG = {
  apiUrl: 'https://TU_DOMINIO.cloudfront.net/chat',
  requestTimeout: 30000,
  context: 'aquamax',   // identifica qué agente/KB usar en el backend
};

// Cada sesión de navegador tiene su propio UUID
// Bedrock Agent usa este ID para mantener el contexto de conversación
state.sessionId = crypto.randomUUID();

// Llamada al backend
fetch(CONFIG.apiUrl, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    sessionId: state.sessionId,
    message: texto,
    context: CONFIG.context,
  }),
});

Probar el endpoint en producción

# Pregunta simple
curl -X POST https://TU_DOMINIO.cloudfront.net/chat \
  -H "Content-Type: application/json" \
  -d '{"sessionId":"test-1","message":"¿Cuáles son sus servicios?","context":"aquamax"}'

# Pregunta de seguimiento (mismo sessionId — el agente recuerda el contexto)
curl -X POST https://TU_DOMINIO.cloudfront.net/chat \
  -H "Content-Type: application/json" \
  -d '{"sessionId":"test-1","message":"¿Y cuánto tiempo tarda?","context":"aquamax"}'

# Respuesta esperada
# { "response": "Ofrecemos lavado en seco ecológico, lavado de ropa delicada..." }

Actualizar el despliegue

# Backend — reconstruir y subir Lambda
cd tintorerias-chatbot
pip install flask flask-cors boto3 python-dotenv -t package/
cp app.py bedrock_client.py config.py lambda_handler.py package/
cd package && zip -r ../lambda_deployment.zip . && cd ..
aws lambda update-function-code \
  --function-name tintorerias-chatbot \
  --zip-file fileb://lambda_deployment.zip

# Frontend — subir y limpiar caché de CloudFront
aws s3 cp index.html       s3://$BUCKET_NAME/
aws s3 cp chatbot-wiget.js s3://$BUCKET_NAME/
aws cloudfront create-invalidation \
  --distribution-id $DISTRIBUTION_ID \
  --paths "/*"

Por qué este stack es ideal para negocios locales

Costo casi cero en reposo — Lambda y API Gateway cobran por invocación, no por hora. Un chatbot con tráfico moderado cuesta centavos al mes.
Sin mantenimiento de servidores — no hay EC2 que parchear, no hay contenedores que monitorear.
Escala automática — de 0 a miles de usuarios simultáneos sin configuración adicional.
Conocimiento del negocio real — la Knowledge Base RAG garantiza que el asistente responda con información actualizada del negocio, no con datos genéricos del modelo.
Reutilizable — el mismo backend soporta múltiples clientes cambiando solo el campo context en la petición.

Licencia

Completely serverless architecture using AWS services. Part 1

felino33 — Tue, 20 Feb 2024 23:11:40 +0000

Introduction:
Despite its name, serverless does not mean a serverless existence. Rather, it indicates a
change in responsibility: developers no longer need to manage, provision, or view the
underlying servers. This allows them to focus on creating efficient code without the distractions
of server complexities.

By entering serverless computing services, where developers can be freed from server
management.

Serverless means serverless, it is a solution that allows you to create and run applications
quickly and with a lower total cost of ownership, since it is not necessary to provision and
manage infrastructure.

Of course, behind it there are servers to run the applications, but the cloud provider is
in charge of the administration, therefore, on our side we stop worrying about managing
servers, operating systems, software and other resources, and we only focus on the
application code.

Key Services and Features:
Serverless means serverless, it is a solution that allows you to create and run applications
quickly and with a lower total cost of ownership, since it is not necessary to provision and
manage infrastructure.
Let's explore the key services and features of this AWS architecture:

1-AWS Lambda:
AWS Lambda, a pioneer in serverless computing, introduces virtual functions that
eliminate the need for manual server management. Focusing on
For short executions, Lambda operates on demand, ensuring efficient resource
utilization. Its automated scaling feature adapts perfectly to different workloads, ensuring
optimal performance. Lambda is integrated with many programming languages
and a full set of AWS services and can be easily monitored through AWS cloudwatch.
AWS Lambda serves as an ideal solution to run our cloud-native API code
efficiently while maintaining minimal costs.

2-Aurora Serverless:
A powerhouse in the cloud database space, Aurora fully supports Postgres and
MySQL. Positioned as “optimized for the AWS cloud,” Aurora boasts a notable 5x
performance improvement over MySQL on RDS and over 3x the performance over Postgres
on RDS. Offering up to 15 replicas with a faster replication process than MySQL. With instant
failover, it is inherently designed for High Availability (HA), although it has a slightly
higher cost than RDS (20% more), its efficiency and performance make it a compelling
option for storing our API structured data.

3-Amazon Simple Storage Service (S3):
S3 is one of the most popular offerings from AWS. S3 is a highly available, durable objectbased storage service. S3 allows objects (files) to be stored in buckets with a globally
unique name. In this case, we use S3 to store the API binary image data (JPEG, JPG, PNG).

4-API Gateway:
AWS Lambda together with API Gateway presents a hassle-free solution with no
infrastructure management. API Gateway not only supports HTTP and REST protocols
but also WebSocket protocol and also skillfully handles API version control (such as v1,
v2) and various environments (development, test, production). API Gateway also covers
authentication and authorization, along with the ability to create API keys and manage
request throttling. In addition, it excels in transforming and validating requests and
responses, allowing the generation of SDKs and API specifications. With the added
ability to cache API responses, API Gateway offers a comprehensive and efficient
ecosystem for developing and managing APIs.

5-Benefits
AWS Serverless offers significant benefits in terms of scalability, agility, and reduced operating
costs. However, it is essential to perform a detailed cost-benefit analysis specific to
your particular use case and business model. This will allow you to make informed
decisions about adopting AWS Serverless and ensure that your applications are
economically efficient, including providing an efficient, scalable, and cost-effective way to
develop and run applications in the cloud.

These benefits can help organizations optimize their operations, accelerate application
development, and improve the availability and security of their systems.

6-Spectrum of serverless services.
Developers using a serverless architecture don't have to worry about policies for extending their code. The
serverless provider handles all on-demand scaling. As a result, a serverless application will be able to handle an
unusually high number of requests as well as it can process a single request from a single user. A
traditionally structured application with a fixed amount of server space can be overwhelmed by a sudden increase
in usage.

7-What we can do with Serverless

AWS Serverless offers a wide range of services and capabilities that allow you to build
applications without worrying about server management. Here are some of the things you can
do with AWS Serverless:

-Data Stream.
-Chatbots and Virtual Assistants.
-Task Automation.
-Data Processing.
-Automatic Scalability.

Within AWS, Serverless services are highly flexible and allow you to use a combination of services to meet specific needs.
Additionally, you only pay for the amount of resources you actually use, which can result in lower costs compared to traditional server provisioning.

This is a little tour of some AWS serverless services, feel free to comment.
Luis Enrique Aguilar.