3 Primeros pasos para crear un agente de IA básico con Amazon Bedrock (ejemplos en Python)

Guía práctica y actualizada para construir tu primer agente de inteligencia artificial usando Amazon Bedrock, con ejemplos de código Python, comparativas, buenas prácticas de seguridad y optimización.

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

1. ¿Qué es Amazon Bedrock?

Amazon Bedrock es el servicio administrado de AWS que permite consumir modelos de lenguaje grande (LLM) y de difusión de imágenes sin necesidad de gestionar infraestructura. Ofrece acceso a modelos de proveedores como Anthropic, AI21, Stability AI y los propios de Amazon (Titan).

Ventajas clave:

  • Escalado automático y facturación por uso.
  • Integración nativa con IAM y VPC Endpoints para seguridad.
  • Compatibilidad con boto3 y AWS SDK for Python.

2. Prerrequisitos

  • Cuenta AWS con permisos bedrock:InvokeModel y bedrock:ListFoundationModels.
  • Python 3.9+ y boto3 (>=1.28). Instálalo con pip install boto3.
  • Credenciales configuradas mediante aws configure o variables de entorno.
  • Un modelo disponible en la región us-east-1 (actualmente Bedrock está limitado a un conjunto de regiones).

3. Configuración del entorno

# Crear un entorno virtual
python -m venv .venv
source .venv/bin/activate

# Instalar dependencias
pip install boto3 python-dotenv

# (Opcional) Guardar credenciales en .env
cat >> .env <<EOF
AWS_ACCESS_KEY_ID=YOUR_KEY
AWS_SECRET_ACCESS_KEY=YOUR_SECRET
AWS_DEFAULT_REGION=us-east-1
EOF

Con la variable de entorno BEDROCK_MODEL_ID podemos parametrizar el modelo que usaremos.

4. Primer agente de IA con Bedrock

Un agente básico se compone de tres partes: entrada del usuario, llamada al modelo y post‑procesamiento de la respuesta.

4.1 Código completo


import os
import json
import boto3
from botocore.exceptions import ClientError
from dotenv import load_dotenv

load_dotenv()

# Parámetros de configuración
MODEL_ID = os.getenv("BEDROCK_MODEL_ID", "google.gemma-3-27b-it")
REGION = os.getenv("AWS_DEFAULT_REGION", "us-east-1")

# Cliente Bedrock Runtime
client = boto3.client('bedrock-runtime', region_name=REGION)

def invoke_model(prompt: dict, temperature: float = 0.7, max_tokens: int = 512) -> str:
    """Invoca el modelo LLM y devuelve la respuesta generada."""
    # --------------------------------------------------------------
    # 1️⃣ Construimos el cuerpo de la petición (ya es un dict)
    # --------------------------------------------------------------
    request_body = prompt

    try:
        response = client.invoke_model(
            modelId=MODEL_ID,
            contentType="application/json",
            accept="application/json",
            body=json.dumps(request_body).encode('utf-8')   # <-- bytes, obligatorio
        )

        # --------------------------------------------------------------
        # 2️⃣ Leemos y decodificamos la respuesta
        # --------------------------------------------------------------
        response_body = json.loads(response["body"].read())

        # Debug opcional (puedes comentar esta línea en producción)
        print("\n=== RESPONSE RAW ===")
        print(json.dumps(response_body, indent=2, ensure_ascii=False))

        # --------------------------------------------------------------
        # 3️⃣ Extraemos el texto generado según el formato de chat
        # --------------------------------------------------------------
        # La respuesta típica tiene: choices[0].message.content
        choices = response_body.get("choices", [])
        if choices:
            content = choices[0].get("message", {}).get("content", "")
            return content
        # Si el modelo devolviera "completion" (modelos no‑chat)
        return response_body.get("completion", "")

    except ClientError as e:
        raise RuntimeError(f"Error invoking Bedrock model: {e}")
    except Exception as e:
        # Capturamos cualquier otro error inesperado y devolvemos una cadena vacía
        print(f"⚠️  Unexpected error: {e}")
        return ""

def main():
    print("Agente IA básico (Bedrock) – escribe 'salir' para terminar")
    while True:
        user_input = input("\nHuman: ")
        if user_input.lower() in {"exit", "quit", "salir"}:
            break

        # --------------------------------------------------------------
        # 4️⃣ Construimos el prompt con el formato esperado por el modelo
        # --------------------------------------------------------------
        prompt = {
            "messages": [
                {
                    "role": "user",
                    "content": user_input
                }
            ],
            "max_tokens": 512,
            "temperature": 0.7
        }

        answer = invoke_model(prompt)
        print(f"\nAssistant: {answer.strip()}")

if __name__ == "__main__":
    main()


Este script crea un bucle interactivo similar a ChatGPT. El prompt sigue la convención de Claude (Human: / Assistant:) pero puede adaptarse a otros modelos cambiando la estructura.

5. Comparativa rápida: Bedrock vs alternativas líderes

Amazon Bedrock

  • Facturación por token consumido.
  • IAM + VPC Endpoints → seguridad “zero‑trust”.
  • Acceso a modelos de terceros sin licencias adicionales.
  • Escalado automático dentro de la infraestructura de AWS.

OpenAI (ChatGPT / GPT‑4)

  • Modelo propio, alta calidad de generación.
  • Autenticación vía API‑Key, sin integración IAM nativa.
  • Limitado a regiones de OpenAI, latencia variable.
  • Planes de suscripción y límites de cuota.

Ambas opciones son viables; la decisión depende del ecosistema cloud, requisitos de cumplimiento y costes operacionales.

6. Buenas prácticas de seguridad

  • Principio de menor privilegio: Concede únicamente bedrock:InvokeModel al rol o usuario que ejecuta el agente.
  • VPC Endpoints: Usa com.amazonaws..bedrock-runtime para evitar tráfico público.
  • Encriptado en reposo y tránsito: Bedrock cifra automáticamente los datos en tránsito (TLS 1.2) y en reposo (KMS).
  • Gestión de secretos: Almacena AWS_ACCESS_KEY_ID y AWS_SECRET_ACCESS_KEY en AWS Secrets Manager o Parameter Store y recupéralos mediante boto3 en tiempo de ejecución.

7. Resolución de problemas (troubleshooting)

7.1 Error AccessDeniedException

Significa que el rol/usuario no tiene la política adecuada. Solución:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "bedrock:InvokeModel",
        "bedrock:ListFoundationModels"
      ],
      "Resource": "*"
    }
  ]
}

7.2 Latencia alta (> 2 s)

  • Verifica que la llamada se realiza dentro de la misma región que el modelo.
  • Activa ProvisionedThroughput mediante ModelInvocationConfig (solo disponible para algunos modelos).
  • Considera usar async invoke_model con concurrent.futures si tu aplicación requiere alta concurrencia.

8. Optimización de rendimiento y costes

  • Control de max_tokens_to_sample: Limita la longitud de la respuesta a lo necesario (p. ej., 256 tokens para respuestas breves).
  • Temperatura y top‑p: Valores bajos (0.2‑0.5) reducen la variabilidad y, en algunos casos, el número de tokens generados.
  • Batching: Agrupa varias peticiones en un solo invoke_model cuando el modelo lo permite (modelos de embeddings).

9. Próximos pasos

  1. Explorar documentación oficial para usar tool use y function calling con Bedrock.
  2. Integrar el agente con Amazon Lex o Amazon API Gateway para exponerlo como API REST.
  3. Implementar caché de respuestas usando Amazon ElastiCache y reducir costos.
  4. Evaluar modelos de fine‑tuning (cuando estén disponibles) para dominios específicos.

© 2025 BlogTech IA – Todos los derechos reservados.

3 Primeros pasos para crear un agente de IA básico con Amazon Bedrock (ejemplos en Python)
Emiliano Nava 26 de diciembre de 2025
Compartir
Etiquetas
Nuestros blogs
Archivo
2 Configuración inicial del entorno de desarrollo con Python y AWS Bedrock
Guía paso a paso para preparar un entorno de desarrollo Python y conectar con AWS Bedrock, con ejemplos prácticos, mejores prácticas de seguridad, optimización y comparativas con otras plataformas de IA.