A principios de 2026, AWS tiene varios componentes relacionados pero distintos que conforman sus abstracciones agentes y LLM.
Bedrock es la capa de modelo que permite el acceso a modelos de lenguaje grandes. Agents for Bedrock es la capa de aplicación administrada. En otras palabras, AWS ejecuta los agentes por usted según sus requisitos. Bedrock AgentCore es una capa de infraestructura que permite a AWS ejecutar agentes que usted desarrolle utilizando marcos de trabajo de terceros como CrewAI y LangGraph.
Además de estos tres servicios, AWS también tiene Strands, una biblioteca Python de código abierto para crear agentes fuera del servicio Bedrock, que luego se puede implementar en otros servicios de AWS como ECS y Lambda.
Puede resultar confuso porque los tres servicios basados en agentes tienen el término "Bedrock" en sus nombres, pero en este artículo, me centraré en el servicio Bedrock estándar y mostraré cómo y por qué debería usarlo. servicio estándar de Bedrock y muestre cómo y por qué lo utilizaría.
Como servicio, Bedrock solo ha estado disponible en AWS desde principios de 2023. Eso debería darle una idea de por qué se introdujo. Amazon pudo ver claramente el surgimiento de los modelos de lenguajes grandes y su impacto en la arquitectura de TI y el proceso de desarrollo de sistemas. Esa es la carne y las patatas de AWS, y estaban interesados en que nadie se comiera su almuerzo.
Y aunque AWS ha desarrollado algunos LLM propios, se dio cuenta de que, para seguir siendo competitivo, necesitaría poner a disposición de los usuarios los mejores modelos, como los de Anthropic. Y ahí es donde interviene Bedrock. Como dijeron en su propia propaganda en su sitio web,
… Bedrock es un servicio totalmente administrado que ofrece una selección de modelos básicos (FM) de alto rendimiento de empresas líderes en IA como AI21 Labs, Anthropic, Cohere, Meta, Stability AI y Amazon a través de una única API, junto con un amplio conjunto de capacidades que necesita para crear aplicaciones de IA generativas, simplificando el desarrollo y manteniendo la privacidad y la seguridad.
¿Cómo accedo a Bedrock?
Bien, esa es la teoría detrás del por qué de Bedrock, pero ¿cómo accedemos a él y realmente lo usamos? No es sorprendente que lo primero que necesite sea una cuenta de AWS. Voy a asumir que ya tienes esto, pero si no, haz clic en el siguiente enlace para configurar uno.
https://aws.amazon.com/account
De manera útil, después de registrarse para obtener una nueva cuenta de AWS, una buena cantidad de los servicios que utilice se incluirán en el llamado "nivel gratuito" en AWS, lo que significa que sus costos deberían ser mínimos durante un año después de la creación de su cuenta, suponiendo que no se vuelva loco y comience a encender enormes servidores informáticos y cosas por el estilo.
Hay tres formas principales de utilizar los servicios de AWS.
A través de la consola. Si es principiante, esta probablemente será su ruta preferida, ya que es la forma más fácil de comenzar a través de una API. Si es hábil codificando, puede acceder a todos los servicios de AWS a través de una API. Por ejemplo, para los programadores de Python, AWS proporciona la biblioteca boto3. Existen bibliotecas similares para otros lenguajes, como JavaScript, etc. A través de la interfaz de línea de comandos (CLI). La CLI es una herramienta adicional que puede descargar desde AWS y le permite interactuar con los servicios de AWS directamente desde su terminal.
Tenga en cuenta que, para utilizar los dos últimos métodos, debe tener las credenciales de inicio de sesión configuradas en su sistema local.
¿Qué puedo hacer con Bedrock?
La respuesta corta es que puedes hacer la mayoría de las cosas que puedes hacer con los modelos de chat habituales de OpenAI, Anthropic, Google, etc. Detrás de Bedrock hay una serie de modelos de cimientos que puede usar con él, como: –
Kimi K2 pensando. Un modelo de razonamiento profundo Claude Opus 4.5. Para muchas personas, este es el mejor LLM disponible hasta la fecha. GPT-OSS. LLM de código abierto de OpenAI
Y muchos, muchos otros además. Para obtener una lista completa, consulte el siguiente enlace.
https://aws.amazon.com/bedrock/model-choice
¿Cómo uso Bedrock?
Para usar Bedrock, usaremos una combinación de AWS CLI y la API de Python proporcionada por la biblioteca boto3. Asegúrese de tener la siguiente configuración como requisito previo
Una cuenta de AWS. La AWS CLI se ha descargado e instalado en su sistema. Un usuario de Gestión de identidad y acceso (IAM) está configurado con los permisos y claves de acceso adecuados. Puede hacerlo a través de la consola de AWS. Configure sus credenciales de usuario a través de la CLI de AWS de esta manera. En general, es necesario proporcionar tres datos. Todo lo cual obtendrás del paso anterior. Se le pedirá que ingrese información relevante, $ aws configure ID de clave de acceso de AWS [Ninguno]: AKIAIOSFODNN7EXAMPLE Clave de acceso secreta de AWS [Ninguno]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY Nombre de región predeterminado [Ninguno]: us-west-2 Formato de salida predeterminado [Ninguno]:
Dar acceso a Bedrock a un modelo
En el pasado (¡hace unos meses!), tenías que usar la consola de administración de AWS para solicitar acceso a modelos particulares de Bedrock, pero ahora el acceso se otorga automáticamente cuando invocas un modelo por primera vez.
Tenga en cuenta que, para los modelos Anthropic, es posible que los usuarios nuevos deban enviar detalles del caso de uso antes de poder acceder al modelo. También tenga en cuenta que el acceso a los mejores modelos de Anthropic y otros proveedores generará costos, así que asegúrese de controlar su facturación con regularidad y elimine cualquier acceso a modelos que ya no necesite.
Sin embargo, todavía necesitamos saber el nombre del modelo que queremos usar. Para obtener una lista de todos los modelos compatibles con Bedrock, podemos utilizar el siguiente comando de AWS CLI.
AWS Bedrock List-Fundación-Modelos
Esto devolverá un conjunto de resultados JSON que enumera varias propiedades de cada modelo, como este.
{ "modelSummaries": [ { "modelArn": "arn:aws:bedrock:us-east-2::foundation-model/nvidia.nemotron-nano-12b-v2", "modelId": "nvidia.nemotron-nano-12b-v2", "modelName": "NVIDIA Nemotron Nano 12B v2 VL BF16", "providerName": "NVIDIA", "inputModalities": [ "TEXTO", "IMAGEN" ], "outputModalities": [ "TEXTO" ], "responseStreamingSupported": verdadero, "personalizacionesSupported":[], "inferenceTypesSupported": [ "ON_DEMAND" ], "modelLifecycle": { "status": "ACTIVE" } }, { "modelArn": "arn:aws:bedrock:us-east-2::foundation-model/anthropic.claude-sonnet-4-20250514-v1:0", … … …
Elija el modelo que necesita y anote su ID de modelo en la salida JSON, ya que lo necesitaremos en nuestro código Python más adelante. Una advertencia importante a este respecto es que a menudo verá lo siguiente en la descripción de un modelo:
… … "inferenceTypesSupported": [ "INFERENCE_PROFILE" ] … …
Esto está reservado para modelos que:
Son grandes o tienen una gran demanda Requieren capacidad reservada o administrada Necesitan controles explícitos de costos y rendimiento
Para estos modelos, no podemos simplemente hacer referencia al ID del modelo en nuestro código. En lugar de ello, necesitamos hacer referencia a un perfil de inferencia. Un perfil de inferencia es un recurso de Bedrock vinculado a uno o más LLM fundamentales y una región.
Hay dos formas de obtener un perfil de inferencia que puede utilizar. La primera es crear uno usted mismo. Estos se denominan perfiles de aplicación. La segunda forma es utilizar uno de los perfiles admitidos por AWS. Esta es la opción más sencilla, ya que está prediseñada para usted y solo necesita obtener el ID de perfil relevante asociado con el perfil de inferencia para usarlo en su código.
Si desea tomar la ruta de crear su perfil de aplicación, consulte la documentación de AWS correspondiente, pero usaré un perfil compatible en mi código de ejemplo.
Para obtener una lista de perfiles admitidos en AWS, consulte el siguiente enlace:
https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html#inference-profiles-support-system
Para mi primer ejemplo de código, quiero usar el modelo Sonnet 3.5 V2 de Claude, así que hice clic en la línea de arriba y vi la siguiente descripción.
Tomé nota del ID del perfil ( us.anthropic.claude-3–5-sonnet-20241022-v2:0 ) y una de las regiones de origen válidas ( us-east-1 )
Para mis dos segundos fragmentos de código de ejemplo, usaré el LLM de código abierto de OpenAI para salida de texto y el generador Titan Image de AWS para imágenes. Ninguno de estos modelos requiere un perfil de inferencia, por lo que puedes usar el ID de modelo normal para ellos en tu código.
NB: Cualquiera que sea el modelo que elija, asegúrese de que su región de AWS esté configurada con el valor correcto para cada uno.
Configurar un entorno de desarrollo
Como estaremos codificando un poco, es mejor aislar su entorno para no interferir con ninguno de nuestros otros proyectos. Así que hagámoslo ahora. Estoy usando Windows y el administrador de paquetes UV para esto, pero usa la herramienta con la que te sientas más cómodo. Mi código se ejecutará en un cuaderno Jupyter.
uv init bedrock_demo –python 3.13 cd bedrock_demo uv add boto3 jupyter # Para ejecutar el cuaderno, escriba esto en uv run jupyter notebook
Usando Bedrock de Python
Veamos Bedrock en acción con algunos ejemplos. El primero será sencillo y poco a poco iremos aumentando la complejidad a medida que avancemos.
Ejemplo 1: una pregunta y respuesta sencillas utilizando un perfil de inferencia
Este ejemplo utiliza el modelo Claude Sonnet 3.5 V2 del que hablamos anteriormente. Como se mencionó, para invocar este modelo, utilizamos una ID de perfil asociada con su perfil de inferencia.
importar json importar boto3 brt = boto3.client("bedrock-runtime", region_name="us-east-1") perfil_id = "us.anthropic.claude-3-5-sonnet-20241022-v2:0" body = json.dumps({ "anthropic_version": "bedrock-2023-05-31", "max_tokens": 200, "temperature": 0.2, "messages": [ { "role": "user", "content": [ {"type": "text", "text": "¿Cuál es la capital de Francia?"} ] } ] }) resp = brt.invoke_model( modelId=profile_id, body=body, Accept="application/json", contentType="application/json" ) data = json.loads(resp["body"].read()) # Las respuestas de Claude regresan como una matriz de "contenido", no como "opciones" de OpenAI print(data["content"][0]["texto"]) # # Salida # La capital de Francia es París.
Tenga en cuenta que al invocar este modelo (y otros similares) se crea una suscripción implícita entre usted y el mercado de AWS. Este no es un cargo regular recurrente. Sólo le cuesta cuando el modelo se utiliza realmente, pero es mejor controlarlo para evitar facturas inesperadas. Debería recibir un correo electrónico que describa el acuerdo de suscripción, con un enlace para administrar y/o cancelar cualquier modelo de suscripción existente que esté configurado.
Ejemplo 2: crear una imagen
Una creación de imágenes sencilla utilizando el modelo Titan propio de AWS. Este modelo no está asociado con un perfil de inferencia, por lo que podemos hacer referencia a él utilizando su ID de modelo.
import json import base64 import boto3 brt_img = boto3.client("bedrock-runtime", region_name="us-east-1") model_id_img = "amazon.titan-image-generator-v2:0" Prompt = "Un hipopótamo andando en bicicleta". body = json.dumps({ "taskType": "TEXT_IMAGE", "textToImageParams": { "text": solicitud }, "imageGenerationConfig": { "numberOfImages": 1, "height": 1024, "width": 1024, "cfgScale": 7.0, "seed": 0 } }) resp = brt_img.invoke_model( modelId=model_id_img, body=body, Accept="application/json", contentType="application/json" ) data = json.loads(resp["body"].read()) # Titan devuelve imágenes codificadas en base64 en la matriz "imágenes" img_b64 = data["images"][0]img_bytes = base64.b64decode(img_b64) out_path = "titan_output.png" con open(out_path, "wb") como f: f.write(img_bytes) print("Guardado:", out_path)
En mi sistema, la imagen de salida se veía así.
Ejemplo 3: un asistente de clasificación de soporte técnico que utiliza el modelo OSS de OpenAI
Este es un ejemplo más complejo y útil. Aquí, configuramos un asistente que tomará los problemas reportados por usuarios no técnicos y generará preguntas adicionales que quizás desee que el usuario responda, así como las causas más probables del problema y los pasos adicionales a seguir. Como nuestro ejemplo anterior, este modelo no está asociado con un perfil de inferencia.
importar json importar re importar boto3 desde pydantic importar BaseModel, campo al escribir import Lista, literal, opcional # —————————- # Bedrock setup # —————————- REGION = "us-east-2" MODEL_ID = "openai.gpt-oss-120b-1:0" brt = boto3.client("bedrock-runtime", region_name=REGION) # —————————- # Esquema de salida # —————————- Gravedad = Literal["bajo", "medio", "alto"] Categoría = Literal["cuenta", "facturación", "dispositivo", "red", "software", "seguridad", "otro"] clase TriageResponse(BaseModel): categoría: Categoría gravedad: Resumen de gravedad: str = Campo(descripción="Reformulación del problema en una frase.") causas_probables: Lista[cadena] = Campo(descripción="Principales causas plausibles, conciso.") claring_questions: List[str] = Field(description="Pregunte solo lo que sea necesario para continuar.") safe_next_steps: List[str] = Field(description="Acciones paso a paso seguras para un usuario no técnico.") stop_and_escalate_if: List[str] = Field(description="Elimine las señales de alerta que requieren un profesional/servicio de asistencia técnica.") recomendado_escalation_target: Opcional[str] = Field( predeterminado=Ninguno, descripción="Si la gravedad es alta, a quién contactar (p. ej., administrador de TI, banco, ISP)". ) # —————————- # Ayudantes # —————————- def invoke_chat(messages, max_tokens=800, Temperature=0.2) -> dict: body = json.dumps({ "messages": mensajes, "max_tokens": max_tokens, "temperature": temperatura }) resp = brt.invoke_model( modelId=MODEL_ID, cuerpo=cuerpo, aceptar="aplicación/json", contentType="aplicación/json" ) return json.loads(resp["body"].read()) def extract_content(data: dict) -> str: devuelve datos["opciones"][0]["message"]["content"] def extract_json_object(text: str) -> dict: """ Extrae el primer objeto JSON de la salida del modelo. Maneja casos comunes como bloques o texto adicional. """ text = re.sub(r".*?", "", text, flags=re.DOTALL).strip() start = text.find("{") if start == -1: rise ValueError("No se encontró ningún objeto JSON.") profundidad = 0 para i en rango(inicio, len(texto)): if text[i] == "{": profundidad += 1 elif text[i] == "}": profundidad -= 1 if profundidad == 0: return json.loads(text[start:i+1]) rise ValueError("Llaves JSON desequilibradas; no se pudo analizar.") # —————————- # La función útil # —————————- def triage_issue(user_problem: str) -> TriageResponse: mensajes = [ { "role": "system", "content": ( "Usted es un cuidadoso asistente de clasificación de soporte técnico para usuarios no técnicos. " "Debe ser conservador y priorizar la seguridad. " "Devolver SÓLO JSON válido que coincida con el esquema dado. Sin texto adicional." ) }, { "role": "user", "content": f""" Problema de usuario: {user_problem} Devolver JSON que coincida con este esquema: {TriageResponse.model_json_schema()} """.strip() } ] raw = invoke_chat(messages) text = extract_content(raw) parsed = extract_json_object(text) return TriageResponse.model_validate(parsed) # —————————- # Ejemplo # —————————- if __name__ == "__main__": problema = "Mi computadora portátil está conectada a Wi-Fi pero hay sitios web no se carga y Zoom sigue diciendo conexión inestable". resultado = triage_issue(problema) print(result.model_dump_json(sangría=2))
Aquí está el resultado.
"category": "network", "severity": "medium", "summary": "La computadora portátil muestra una conexión Wi-Fi pero no puede cargar sitios web y Zoom informa una conexión inestable.", "likely_causes": [ "Mal funcionamiento del enrutador o módem", "Error en la resolución de DNS", "Interferencia de Wi-Fi local o señal débil", "Conflicto de dirección IP en la red", "Firewall o software de seguridad que bloquea el tráfico", "Corte o limitación del ISP" ], "clarifying_questions": [ "¿Pueden otros dispositivos en la misma red Wi-Fi acceder a Internet?", "¿El problema comenzó después de algún cambio reciente (por ejemplo, nuevo software, actualización del sistema operativo, instalación de VPN)?", "¿Has intentado acercarte al enrutador o usar una conexión Ethernet por cable?", "¿Ves algún código o mensaje de error en el navegador o Zoom además de "conexión inestable"?" ], "safe_next_steps": [ "Reinicie el enrutador y el módem desconectándolos durante 30 segundos, luego vuelva a encenderlos.", "En la computadora portátil, olvide la red Wi-Fi, luego vuelva a conectarse y vuelva a ingresar la contraseña.", "Ejecute el solucionador de problemas de red integrado de Windows (Configuración → Red e Internet → Estado → Solucionador de problemas de red)", "Desactive cualquier VPN o proxy temporalmente y pruebe la conexión nuevamente.", "Abra un símbolo del sistema y ejecute `ipconfig /release` seguido de `ipconfig /renew`.", "Vacia la caché DNS con `ipconfig /flushdns`.", "Intenta acceder a un sitio web simple (p. ej., http://example.com) y observa si se carga.", "Si es posible, conecta la computadora portátil al enrutador a través de Ethernet para ver si el problema persiste". ], "stop_and_escalate_if": [ "La computadora portátil aún no puede acceder a ningún sitio web después de completar todos los pasos.", "Otros dispositivos en la misma red tampoco pueden acceder a Internet.", "Recibe mensajes de error que indican una falla de hardware (por ejemplo, no se encontró el adaptador Wi-Fi)", "El enrutador se reinicia repetidamente o muestra luces de error", "Zoom continúa informando una conexión deficiente o inestable a pesar de una prueba de Internet que funciona". ], "recommended_escalation_target": "Administrador de TI" }
Resumen
Este artículo presentó AWS Bedrock, la puerta de enlace administrada de AWS para fundamentar grandes modelos de lenguaje, explicando por qué existe, cómo encaja en la pila más amplia de IA de AWS y cómo utilizarlo en la práctica. Cubrimos el descubrimiento de modelos, la configuración de regiones y credenciales, y la distinción clave entre modelos bajo demanda y aquellos que requieren perfiles de inferencia, una fuente común de confusión para los desarrolladores.
A través de ejemplos prácticos de Python, demostramos la generación de texto e imágenes utilizando modelos estándar bajo demanda y aquellos que requieren un perfil de inferencia.
En esencia, Bedrock refleja la filosofía de larga data de AWS: complejidad de infraestructura abstracta sin eliminar el control. En lugar de impulsar un único “mejor” modelo, Bedrock trata los modelos básicos como componentes de infraestructura gestionados: intercambiables, gobernables y con reconocimiento regional. Esto sugiere un futuro en el que Bedrock evolucione menos como una interfaz de chat y más como una capa de orquestación de modelos, estrechamente integrada con IAM, redes, controles de costos y marcos de agentes.
Con el tiempo, podríamos esperar que Bedrock avance hacia contratos de inferencia estandarizados (suscripciones) y una separación más clara entre la experimentación y la capacidad de producción. Y con sus servicios Agent y AgentCore, ya estamos viendo una integración más profunda de los flujos de trabajo agentes con Bedrock, posicionando los modelos no como productos en sí mismos, sino como bloques de construcción duraderos dentro de los sistemas AWS.
Para evitar dudas, aparte de ser un usuario ocasional de sus servicios, no tengo conexión ni afiliación con Amazon Web Services.