Modelos de OpenAI en Amazon Bedrock

Amazon Bedrock ejecuta modelos compatibles de OpenAI en infraestructura administrada por AWS. Usa esta guía para comparar la compatibilidad con las funciones de la API de OpenAI y conectarte con el SDK de OpenAI. Para configurar el despliegue, consulta la documentación de AWS enlazada en esta página.

Cómo funciona la disponibilidad en Bedrock

Los modelos de OpenAI están disponibles a través de dos puntos de acceso de Amazon Bedrock: bedrock-runtime y bedrock-mantle. Ambos admiten la API Responses y la API para completar chats, compatibles con OpenAI, para los modelos admitidos, pero las funciones que ofrecen son diferentes.

Elige el punto de acceso según las capacidades que necesite tu aplicación. Por ejemplo, la búsqueda web alojada actualmente requiere Mantle. Consulta las diferencias entre puntos de acceso en esta página y la comparación de puntos de acceso de AWS para conocer las capacidades específicas de Bedrock y elegir un punto de acceso.

Para obtener información sobre el acceso y la configuración, consulta el anuncio de GPT-6 Astra y las instrucciones del punto de acceso de Runtime de AWS.

Realizar solicitudes a la API Responses

Estos ejemplos usan el SDK de OpenAI con el punto de acceso de Mantle. Selecciona la región de AWS y el ID del modelo para tu despliegue:

• Las bibliotecas cliente con un proveedor de Bedrock obtienen una URL base regional de Mantle a partir de la región de AWS. Los proveedores de JavaScript, Python, Go y Java usan https://bedrock-mantle.us-east-2.api.aws/openai/v1 para los ejemplos de esta guía en us-east-2. Los ejemplos de Ruby configuran directamente este punto de acceso /openai/v1 porque la ruta predeterminada /v1 del proveedor no es compatible con este modelo.
• Usa un ID de modelo de Bedrock con el prefijo openai., como openai.gpt-5.6-sol.

Los ejemplos usan openai.gpt-5.6-sol en us-east-2. Para Runtime, sigue las instrucciones del punto de acceso de la API Responses de AWS para seleccionar la URL base y el perfil de inferencia. No reutilices un ID de modelo de Mantle sin verificar los requisitos de Runtime.

El siguiente ejemplo usa una clave de API de Bedrock almacenada como AWS_BEARER_TOKEN_BEDROCK. Consulta Claves de API de Amazon Bedrock para obtener información sobre cómo generar y usar una clave de API de Bedrock.

Instala el proveedor opcional de Bedrock para Java antes de usar cualquiera de los dos ejemplos de Java:

12345<dependency>
  <groupId>com.openai</groupId>
  <artifactId>openai-java-bedrock</artifactId>
  <version>4.57.0</version>
</dependency>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16import OpenAI from "openai";
import { bedrock } from "openai/providers/bedrock";

const client = new OpenAI({
  provider: bedrock({
    region: "us-east-2",
    apiKey: process.env.AWS_BEARER_TOKEN_BEDROCK,
  }),
});

const response = await client.responses.create({
  model: "openai.gpt-5.6-sol",
  input: "Write a haiku about cloud infrastructure.",
});

console.log(response.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18import os

from openai import OpenAI
from openai.providers import bedrock

client = OpenAI(
    provider=bedrock(
        region="us-east-2",
        api_key=os.environ["AWS_BEARER_TOKEN_BEDROCK"],
    )
)

response = client.responses.create(
    model="openai.gpt-5.6-sol",
    input="Write a haiku about cloud infrastructure.",
)

print(response.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32package main

import (
	"context"
	"fmt"
	"os"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/bedrock"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client, err := bedrock.NewClient(context.Background(), bedrock.Config{
		AWSRegion: "us-east-2",
		APIKey:    os.Getenv("AWS_BEARER_TOKEN_BEDROCK"),
	})
	if err != nil {
		panic(err)
	}

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "openai.gpt-5.6-sol",
		Input: responses.ResponseNewParamsInputUnion{
			OfString: openai.String("Write a haiku about cloud infrastructure."),
		},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.BedrockOpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;

public final class AmazonBedrockCreateResponseExample {
  private AmazonBedrockCreateResponseExample() {}

  public static void main(String[] args) {
    OpenAIClient client =
        BedrockOpenAIOkHttpClient.builder()
            .awsRegion("us-east-2")
            .apiKey(System.getenv("AWS_BEARER_TOKEN_BEDROCK"))
            .build();

    ResponseCreateParams params =
        ResponseCreateParams.builder()
            .model("openai.gpt-5.6-sol")
            .input("Write a haiku about cloud infrastructure.")
            .build();

    client.responses().create(params).output().stream()
        .flatMap(item -> item.message().stream())
        .flatMap(message -> message.content().stream())
        .flatMap(content -> content.outputText().stream())
        .forEach(text -> System.out.println(text.text()));
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24using System.ClientModel;
using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("AWS_BEARER_TOKEN_BEDROCK")!;
ResponsesClient client = new(
    new ApiKeyCredential(key),
    new ResponsesClientOptions
    {
        Endpoint = new Uri("https://bedrock-mantle.us-east-2.api.aws/openai/v1"),
    }
);

CreateResponseOptions options = new()
{
    Model = "openai.gpt-5.6-sol",
};
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("Write a haiku about cloud infrastructure.")
);

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16require "openai"

client = OpenAI::Client.new(
  provider: OpenAI::Providers.bedrock(
    region: "us-east-2",
    base_url: "https://bedrock-mantle.us-east-2.api.aws/openai/v1",
    api_key: ENV.fetch("AWS_BEARER_TOKEN_BEDROCK")
  )
)

response = client.responses.create(
  model: "openai.gpt-5.6-sol",
  input: "Write a haiku about cloud infrastructure."
)

puts(response.output_text)

1
2
3
4
5
6
7curl "https://bedrock-mantle.us-east-2.api.aws/openai/v1/responses" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AWS_BEARER_TOKEN_BEDROCK" \
  -d '{
    "model": "openai.gpt-5.6-sol",
    "input": "Write a haiku about cloud infrastructure."
  }'

Para aplicaciones de larga duración, usa preferentemente la cadena de credenciales estándar de AWS en lugar de un token de portador estático. Los proveedores de los SDK de JavaScript, Python, Go, Java y Ruby obtienen credenciales actualizadas de AWS y firman cada intento de solicitud con SigV4. La cadena puede incluir credenciales configuradas con aws login, perfiles compartidos, roles de cargas de trabajo y credenciales de instancias o contenedores.

Instala las dependencias opcionales de los ejemplos de la cadena de credenciales de AWS antes de usar esta opción:

1234npm install @aws-sdk/credential-provider-node @smithy/hash-node @smithy/signature-v4
pip install 'openai[bedrock]'
go get github.com/openai/openai-go/v3/bedrock
bundle add aws-sdk-core

Actualmente, el SDK de .NET no ofrece un proveedor equivalente de Bedrock ni una política de autenticación SigV4 de AWS. Usa una clave de API de Bedrock con .NET o envía una solicitud HTTP firmada a través de un cliente compatible con AWS cuando tu aplicación requiera la cadena de credenciales de AWS.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18import OpenAI from "openai";
import { defaultProvider } from "@aws-sdk/credential-provider-node";
import { bedrock } from "openai/providers/bedrock/aws";

const client = new OpenAI({
  provider: bedrock({
    region: "us-east-2",
    endpoint: "mantle",
    credentialProvider: defaultProvider(),
  }),
});

const response = await client.responses.create({
  model: "openai.gpt-5.6-sol",
  input: "Write a haiku about cloud infrastructure.",
});

console.log(response.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16from openai import OpenAI
from openai.providers import bedrock

client = OpenAI(
    provider=bedrock(
        region="us-east-2",
        api_key=None,
    )
)

response = client.responses.create(
    model="openai.gpt-5.6-sol",
    input="Write a haiku about cloud infrastructure.",
)

print(response.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37package main

import (
	"context"
	"fmt"

	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/bedrock"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	awsConfig, err := config.LoadDefaultConfig(context.Background())
	if err != nil {
		panic(err)
	}

	client, err := bedrock.NewClient(context.Background(), bedrock.Config{
		AWSRegion:              "us-east-2",
		AWSCredentialsProvider: awsConfig.Credentials,
	})
	if err != nil {
		panic(err)
	}

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "openai.gpt-5.6-sol",
		Input: responses.ResponseNewParamsInputUnion{
			OfString: openai.String("Write a haiku about cloud infrastructure."),
		},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.BedrockOpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;

public final class AmazonBedrockCreateResponseWithAwsCredentialsExample {
  private AmazonBedrockCreateResponseWithAwsCredentialsExample() {}

  public static void main(String[] args) {
    OpenAIClient client =
        BedrockOpenAIOkHttpClient.builder()
            .awsRegion("us-east-2")
            .awsCredentialsProvider(DefaultCredentialsProvider.create())
            .build();

    ResponseCreateParams params =
        ResponseCreateParams.builder()
            .model("openai.gpt-5.6-sol")
            .input("Write a haiku about cloud infrastructure.")
            .build();

    client.responses().create(params).output().stream()
        .flatMap(item -> item.message().stream())
        .flatMap(message -> message.content().stream())
        .flatMap(content -> content.outputText().stream())
        .forEach(text -> System.out.println(text.text()));
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16require "openai"

client = OpenAI::Client.new(
  provider: OpenAI::Providers.bedrock(
    region: "us-east-2",
    base_url: "https://bedrock-mantle.us-east-2.api.aws/openai/v1",
    api_key: nil
  )
)

response = client.responses.create(
  model: "openai.gpt-5.6-sol",
  input: "Write a haiku about cloud infrastructure."
)

puts(response.output_text)

Disponibilidad de funciones de la API Responses

Usa esta matriz para identificar las diferencias respecto de la API de OpenAI. La disponibilidad depende del modelo y del punto de acceso; la compatibilidad con una API no implica que se admitan todas las herramientas o todos los modos de respuesta.

Las llamadas asíncronas a herramientas (async: true) y las actualizaciones de razonamiento (elementos de entrada configuration_update) no son compatibles con Amazon Bedrock. La orientación durante el turno requiere WebSockets y no está disponible a través de ninguno de los dos puntos de acceso de Bedrock.

La función tool_search del lado del cliente es distinta de las herramientas alojadas y de la compatibilidad con servidores MCP remotos. La búsqueda web alojada está disponible a través de Mantle; la búsqueda de archivos alojada y los servidores MCP remotos no están disponibles.

El uso de la computadora está disponible en Runtime y Mantle para los modelos compatibles. Tu aplicación ejecuta acciones en la computadora y devuelve los resultados al modelo; esta capacidad no requiere un entorno de ejecución alojado en Bedrock.

En Amazon Bedrock, GPT-5.4 y GPT-5.5 admiten una ventana de contexto de 1 millón de tokens; GPT-5.6 Sol, Terra, Luna y GPT-6 Astra admiten 1 050 000 tokens. Consulta las tarjetas de los modelos de OpenAI en AWS para conocer los límites específicos de cada modelo.

Diferencias entre puntos de acceso

Estas diferencias de la API Responses se aplican al elegir entre Runtime y Mantle:

Runtime requiere model incluso cuando proporcionas previous_response_id. El modo en segundo plano es independiente de la transmisión continua y no se refiere a las llamadas asíncronas a funciones. Consulta la documentación de la API Responses de AWS para conocer el contrato completo del punto de acceso. Para los permisos y la configuración de la búsqueda web, consulta la guía de búsqueda web de AWS.

Disponibilidad y operaciones

AWS administra las opciones de implementación y la disponibilidad de Amazon Bedrock. Usa estas referencias para seleccionar y configurar tu implementación:

Una región de AWS no es una jurisdicción de residencia de datos de OpenAI. Si tu carga de trabajo tiene requisitos de ubicación, revisa las regiones de destino de tu perfil de inferencia y los términos aplicables de AWS, no solo la región en la URL de tu punto de acceso.

Acceso y retención de datos

Amazon Bedrock usa controles separados para el acceso de los operadores y la retención de datos:

• Acceso cero de operadores (ZOA) significa que los operadores de AWS no tienen ningún mecanismo técnico para iniciar sesión en los sistemas de cómputo subyacentes de Mantle ni acceder a los datos de los clientes que se encuentran allí. Consulta el diseño de ZOA de AWS.
• Retención cero de datos (ZDR) significa que AWS no escribe datos de solicitudes ni de respuestas en almacenamiento duradero cuando el modo de retención efectivo es none.

Establecer store: false no garantiza ZDR. Para las solicitudes a la API Responses con un modo de retención efectivo de none, AWS rechaza store: true y el modo en segundo plano no está disponible.

Para los modelos de OpenAI en Amazon Bedrock, AWS no comparte el contenido de las solicitudes ni de las respuestas con OpenAI cuando el modo de retención efectivo es default o none. Consulta la documentación sobre retención de datos de AWS para conocer los modos disponibles, los requisitos de elegibilidad y la configuración de la cuenta o del proyecto. Consulta la detección de abuso de Amazon Bedrock para conocer los requisitos y las excepciones de retención específicos de cada modelo.

Autenticación y operaciones

Tu administrador de AWS controla el acceso a la cuenta, los modelos y las funciones. Consulta la documentación sobre claves de API de AWS para la creación y el ciclo de vida de las credenciales, y la documentación de IAM para las identidades y los permisos. Los ejemplos del SDK de OpenAI en esta página muestran cómo proporcionar esas credenciales; no configuran los permisos de AWS.

Precios

El uso de Amazon Bedrock se factura a través de AWS. Los precios de Bedrock en las regiones comerciales coinciden con los precios directos de OpenAI para servicios equivalentes. Ten en cuenta que usar un servicio específico de una región en Bedrock tendrá la misma tarifa que el procesamiento regional en la API de OpenAI. Los términos comerciales de Amazon se aplican al uso de Bedrock.

Consulta los precios de la API para conocer los precios directos de la API de OpenAI. Para conocer las tarifas de Bedrock, los niveles de servicio compatibles y las opciones de facturación, consulta los precios de Amazon Bedrock y la tarjeta del modelo correspondiente.

Próximos pasos

Para la configuración en ChatGPT Work y Codex, consulta Usa ChatGPT Work y Codex con Amazon Bedrock.