3 Primeros pasos para crear un agente de IA básico con Amazon Bedrock usando Python

Guía completa y práctica para iniciar el desarrollo de un agente de IA con Amazon Bedrock, incluye configuración, ejemplos de código en Python, buenas prácticas, seguridad y comparativas con otras plataformas.

Primeros pasos para crear un agente de IA básico con Amazon Bedrock

En este artículo aprenderás a configurar tu entorno, conectar con Bedrock mediante Python y diseñar un agente sencillo capaz de responder preguntas, con ejemplos de código, buenas prácticas y comparativas con otras soluciones del mercado.

1. ¿Qué es Amazon Bedrock?

Amazon Bedrock es el servicio gestionado de AWS que permite acceder a modelos fundacionales (Foundation Models) de proveedores como Anthropic, AI21, Stability AI y Amazon Titan. Ofrece una API unificada, control de acceso granular y una capa de prompt‑tuning que simplifica la creación de agentes de IA sin gestionar infraestructura.

Modelo bajo demanda: paga por token consumido.
Seguridad integrada: cifrado en reposo y en tránsito, IAM fine‑grained.
Escalabilidad automática: el backend de AWS dimensiona los recursos según la carga.

2. Prerrequisitos técnicos

Antes de escribir código, verifica lo siguiente:

Cuenta AWS con AmazonBedrockFullAccess (o política personalizada).
Python >= 3.9 y pip actualizado.
Instalación del SDK boto3 y botocore (versión 1.34+).
Configuración de credenciales mediante aws configure o variables de entorno (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_DEFAULT_REGION).

Opcional pero recomendado: crear un virtual environment para aislar dependencias.

3. Configuración del entorno Python

# Crear y activar venv
python -m venv bedrock‑env
source bedrock‑env/bin/activate  # Linux/macOS
# Windows: bedrock‑env\Scripts\activate

# Instalar dependencias
pip install --upgrade pip
pip install boto3 botocore tqdm

4. Conexión básica a Bedrock

El siguiente fragmento muestra cómo inicializar el cliente y enviar un prompt al modelo google.gemma-3-27b-it (uno de los modelos más versátiles).


import boto3, json

# Cliente Bedrock (región us-east-1 por ejemplo)
bedrock = boto3.client(
    service_name='bedrock-runtime',
    region_name='us-east-1'  # Cambia según tu región
)

prompt = "Responde en una frase: ¿Cuál es la capital de Japón?"
payload = {
     "messages": [
                {
                    "role": "user",
                    "content": prompt
                }
            ],
    "max_tokens": 50,
    "temperature": 0.0,
    
}

response = bedrock.invoke_model(
    modelId='google.gemma-3-27b-it',
    body=json.dumps(payload)
)
print(json.loads(response['body'].read())['choices'][0]['message']['content'])

Este ejemplo es la base de cualquier agente: envías un prompt y recibes una respuesta estructurada.

5. Arquitectura mínima de un agente de IA

Componente de entrada

Interfaz de usuario (CLI, API REST, Slack, etc.)
Validación y sanitización de texto
Enriquecimiento opcional (contexto, historial)

Motor de inferencia (Bedrock)

Selección de modelo (Claude, Titan, etc.)
Parámetros de generación: temperature, top_p, max_tokens
Gestión de "prompt‑engineering" para guiar al modelo

Componente de salida

Formateo (texto plano, JSON, markdown)
Post‑procesamiento (filtrado de contenido, detección de toxicidad)
Entrega al cliente (HTTP response, mensaje de chat, etc.)

Observabilidad y control

Logs estructurados en CloudWatch
Métricas de latencia y tokens consumidos
Políticas de IAM y etiquetas de recursos para gobernanza

6. Implementación de un agente conversacional simple

Este script muestra un bucle REPL (Read‑Eval‑Print Loop) que mantiene el historial de la conversación y aplica prompt‑chaining para dar contexto al modelo.


import boto3, json, os

bedrock = boto3.client('bedrock-runtime', region_name=os.getenv('AWS_DEFAULT_REGION', 'us-east-1'))
model_id = 'google.gemma-3-27b-it'
# Historial limitado a los últimos 5 intercambios para evitar límite de tokens
history = []
MAX_TURNS = 5
context = []
def build_prompt(prompt):
    # Construye un prompt con historial
    context.append({
                    "role": "user",
                    "content": prompt
                }
                )


    return context  # El modelo completará la respuesta

while True:
    user_input = input('\n\nYou: ')
    if user_input.lower() in ('exit', 'quit'):
        break

    prompt = build_prompt(user_input)
    payload = {
     "messages": prompt,
    "max_tokens": 500,
    "temperature": 0.0,
    
}
    response = bedrock.invoke_model(modelId=model_id, body=json.dumps(payload))
    answer = json.loads(response['body'].read())['choices'][0]['message']['content'].strip()
    print(f"Assistant: {answer}")
    context.append({
                    "role": "assistant",
                    "content": answer
                }
                )   
    # Actualizar historial
    history.append({"human": user_input, "assistant": answer})
    if len(history) > MAX_TURNS:
        history.pop(0)

Consejo de rendimiento: ajusta max_tokens_to_sample y temperature según la naturaleza de la tarea (informativa vs creativa).

7. Buenas prácticas de seguridad y cumplimiento

Principio de menor privilegio: otorga a la función Lambda o EC2 solo bedrock:InvokeModel para el modelo específico.
Cifrado de datos sensibles: utiliza AWS KMS para encriptar cualquier dato de cliente antes de enviarlo a Bedrock.
Filtrado de salida: integra Amazon GuardDuty o Amazon Comprehend para detectar contenido ofensivo o PII.
Auditoría: habilita CloudTrail para registrar cada InvokeModel con el ID de solicitud y número de tokens.

8. Solución de problemas (troubleshooting)

Problema	Causa típica	Acción correctiva
403 Forbidden	Política IAM insuficiente	Añadir `bedrock:InvokeModel` al rol o usuario
Timeout	Latencia de red o modelo sobrecargado	Aumentar `read_timeout` en cliente Boto3 y habilitar retries
Respuesta truncada	Valor `max_tokens` muy bajo	Incrementar el límite según el uso previsto
Contenido inesperado (hallucinations)	Prompt poco estructurado	Aplicar técnicas de prompt‑engineering (instrucciones claras, ejemplos)

9. Comparativa rápida con otras plataformas LLM

Amazon Bedrock

Integración nativa con IAM, CloudWatch, KMS.
Facturación por token, sin cargos de infraestructura.
Amplio catálogo (Claude, Titan, AI21, Stability).

OpenAI (ChatGPT, GPT‑4)

API robusta, pero gestión de credenciales externa a AWS.
Modelos de última generación, pero costos por token más altos.
Menor integración directa con servicios AWS.

Azure OpenAI

Integrado con Azure AD, buen para entornos híbridos.
Opciones de aislamiento de red (VNet).
Modelo limitado a los que Azure licencia.

Google Vertex AI PaLM

Fuerte en razonamiento y traducción.
Requiere configuración de pipelines de ML más compleja.
Costos variables y menos control de políticas de datos.

10. Escalabilidad y performance

Para cargas en producción, considera:

Lambda + API Gateway: latencia < 300 ms para respuestas breves, ideal para micro‑servicios.
ECS/EKS: contenedores con aws-sdk y asyncio para procesamiento concurrente.
Batch inference: agrupa varias peticiones en un solo invoke_model usando prompt concatenation para reducir tokens.

Monitorea InvocationCount y TokensConsumed en CloudWatch para detectar picos y ajustar presupuestos.

en Programación

ASIMOV Ingeniería S. de R.L. de C.V., Emiliano Nava 31 de diciembre de 2025

Nuestros blogs

Iniciar sesión dejar un comentario

2 Configuración Inicial del Entorno de Desarrollo con Python y AWS Bedrock

Guía paso a paso para montar un entorno de desarrollo Python listo para usar AWS Bedrock, con ejemplos prácticos, buenas prácticas, seguridad y comparativas.