Integrando modelos SageMaker AI con Amazon Bedrock AgentCore para flujos agenticos

Resumen ejecutivo

Combinar modelos administrados (foundation models) con modelos propios optimizados por costo o especializados es un reto frecuente al diseñar flujos de trabajo agenticos. En este artículo explico una arquitectura práctica que integra endpoints OpenAI‑compatibles de Amazon SageMaker AI con el runtime Amazon Bedrock AgentCore, usando Strands Agents como framework de agentes. El resultado: agentes especializados que colaboran en tareas complejas usando el modelo más apropiado para cada trabajo, con beneficios de costos, residencia de datos y flexibilidad de modelo.

Qué resuelve esta integración

La arquitectura permite que un orquestador distribuya tareas entre agentes que llaman a modelos alojados en diferentes rutas: Bedrock (modelos administrados) y SageMaker AI (endpoints en tiempo real con API OpenAI‑compatible). Esto evita reescribir su framework de agentes para cambiar modelos y facilita aprovechar modelos más económicos o con requisitos de residencia de datos, sin sacrificar la capacidad de usar modelos gestionados cuando convenga.

Beneficios clave:

• Especialización: cada agente usa el modelo mejor adaptado a su propósito (ej. análisis financiero vs clasificación de intención).
• Optimización de costos: modelos ligeros en SageMaker para tareas intensivas con presupuesto, Bedrock para capacidades avanzadas.
• Residencia de datos y control: elegir dónde hospedar los modelos según requisitos regulatorios.
• Producción lista: despliegue en Amazon Bedrock AgentCore para ejecución consistente.

Arquitectura propuesta

La solución conecta tres vías de alojamiento de modelos dentro de un único contenedor de Amazon Bedrock AgentCore:

• Orquestador (Claude Haiku 4.5 en Bedrock): clasifica la intención del usuario y enruta la petición.
• Agente de presupuesto (Claude Sonnet 4.6 en Bedrock): genera desgloses de presupuesto con salida estructurada (p. ej. Pydantic).
• Agente de análisis financiero (Qwen 3.5 9B en Amazon SageMaker AI): realiza análisis de acciones y construcción de portafolios, incluyendo llamadas a herramientas (tool‑calling).

El flujo básico: el usuario envía una petición al orquestador en el runtime de AgentCore; el orquestador utiliza el patrón “agents as tools” de Strands para enviar la tarea al agente de presupuesto o al agente financiero; cada agente invoca su modelo correspondiente (Bedrock o SageMaker AI) y devuelve la respuesta al orquestador, que entrega el resultado al usuario.

Tenga en cuenta que la disponibilidad de modelos de Bedrock varía por región; consulte la documentación de Amazon Bedrock para ver modelos soportados por región.

Requisitos previos

Antes de seguir los pasos técnicos necesitará:

• Cuenta AWS con permisos para Amazon SageMaker AI, Amazon Bedrock y AgentCore.
• Rol IAM con permisos sagemaker:InvokeEndpoint y sagemaker:CallWithBearerToken.
• Acceso a modelos de Bedrock requeridos (Claude Haiku 4.5 y Claude Sonnet 4.6).
• Python 3.12+.
• Paquetes Python sugeridos: sagemaker-core, openai, httpx, strands-agents[otel], yfinance, pydantic, bedrock-agentcore (puede instalar con pip).

Además, hay un repositorio con el código de muestra que complementa esta guía (consulte el repo en GitHub asociado al artículo original).

Paso 1 — Desplegar Qwen 3.5 9B en SageMaker AI

Para ejecutar Qwen 3.5 9B en tiempo real se usa la imagen vLLM como contenedor de inferencia. Un ejemplo de configuración incluye:

• Imagen de inferencia: 763104351884.dkr.ecr.<region>.amazonaws.com/vllm:0.22.1-gpu-py312-cu130-ubuntu22.04-sagemaker
• Instancia: ml.g6e.2xlarge (1x L40S, 48 GB VRAM)
• Variables de entorno relevantes: SM_VLLM_MODEL (ej. “Qwen/Qwen3.5-9B”), SM_VLLM_TENSOR_PARALLEL_SIZE, SM_VLLM_MAX_MODEL_LEN

El despliegue en SageMaker sigue el flujo estándar: crear el modelo, crear la configuración del endpoint con la producción variants y finalmente crear el endpoint. Estos pasos habilitan un endpoint en tiempo real que expone la API OpenAI‑compatible para inferencia.

Paso 2 — Construir el sistema multi‑agente con Strands

Strands Agents facilita implementar el patrón “agents as tools”, donde cada agente se construye como una unidad que puede ser llamada por otros agentes. En este escenario, el agente financiero necesita llamar al endpoint de SageMaker usando la API OpenAI‑compatible.

Un detalle técnico importante: la API OpenAI‑compatible de SageMaker AI exige un token bearer que expira regularmente. Para sesiones de agente de larga duración es necesario refrescar ese token en cada petición. La solución propuesta usa un httpx.Auth personalizado que invoca generate_token del paquete sagemaker.core.token_generator para obtener tokens frescos en cada request.

Ejemplo (concepto):

import httpx
from openai import AsyncOpenAI
from sagemaker.core.token_generator import generate_token

class SageMakerAuth(httpx.Auth):
    def __init__(self, region):
        self.region = region
    def auth_flow(self, request):
        request.headers["Authorization"] = f"Bearer {generate_token(region=self.region)}"
        yield request

strands_client = AsyncOpenAI(
    base_url=f"https://runtime.sagemaker.{REGION}.amazonaws.com/endpoints/{ENDPOINT_NAME}/openai/v1",
    api_key="sagemaker",
    http_client=httpx.AsyncClient(auth=SageMakerAuth(region=REGION)),
)

Luego se define un modelo OpenAI dentro de Strands que apunta a ese cliente y se crea un agent fresh por invocación para evitar estados compartidos entre llamadas.

Paso 3 — Despliegue en Bedrock AgentCore runtime

Con los agentes definidos localmente, puede empaquetar y desplegar el flujo completo usando el kit bedrock-agentcore-starter-toolkit. El runtime se configura indicando el entrypoint del agente, dependencias (requirements.txt), la región de despliegue y variables de entorno necesarias (por ejemplo el nombre del endpoint SageMaker y la región).

Un ejemplo de flujo de lanzamiento (concepto):

from bedrock_agentcore_starter_toolkit import Runtime

agentcore_runtime = Runtime()
agentcore_runtime.configure(
    entrypoint="main.py",
    auto_create_execution_role=True,
    auto_create_ecr=True,
    requirements_file="requirements.txt",
    region="ap-south-1",
    agent_name="personal_finance_agent",
)

launch_result = agentcore_runtime.launch(env_vars={
    "SAGEMAKER_ENDPOINT_NAME": "qwen35-9b-...",
    "SAGEMAKER_REGION": "ap-south-1",
})

El runtime de AgentCore ejecuta el orquestador y permite que los agentes llamen a Bedrock y a SageMaker según sea necesario.

Observabilidad y consideraciones operativas

• Token‑level observability: obtener trazas a nivel de tokens desde endpoints SageMaker no siempre es automático en frameworks de agente; en este caso la integración incluye mecanismos para recoger información de token usage mediante las opciones de streaming y métricas del cliente OpenAI‑compatible.
• Regiones: la disponibilidad de modelos en Bedrock varía por región; valide dónde puede ejecutar cada modelo antes de diseñar el flujo.
• Seguridad y permisos: asegúrese de los roles IAM adecuados para invocar endpoints y para que AgentCore cree sus recursos.

Conclusión y próximos pasos

Esta arquitectura permite combinar lo mejor de ambos mundos: modelos administrados de Bedrock para capacidades avanzadas y modelos propios en SageMaker AI para optimización de costos y requisitos de residencia de datos. Es una base sólida para workflows agenticos en producción que necesitan flexibilidad y control.

Para implementarlo en su organización en América Latina, evalúe las regiones AWS disponibles, el cumplimiento local de datos y costos de infraestructura. El código de referencia y notebooks asociados facilitan reproducir el ejemplo y adaptarlo a casos de uso como analítica financiera, asistentes internos o automatización de decisiones.

Para más detalles técnicos y el código completo, consulte el repositorio de ejemplo que acompaña a la guía original.