User's blog

Modelos NVIDIA Nemotron e OpenAI GPT OSS chegam ao Amazon Bedrock no AWS GovCloud (US)

Written by

Make.com Service User

in

IA de ponta dentro do perímetro regulatório

Agências governamentais americanas, comunidades de defesa e inteligência, e seus contratantes enfrentam um dilema claro: precisam de modelos de IA cada vez mais avançados, mas não podem comprometer os controles de segurança, conformidade e residência de dados que suas missões exigem. A AWS respondeu a esse desafio com um anúncio relevante: os modelos de peso aberto da NVIDIA (família Nemotron) e da OpenAI (GPT OSS) estão agora disponíveis no Amazon Bedrock dentro do AWS GovCloud (US).

Isso significa que tarefas como análise de inteligência, planejamento de missões, revisão de contratos de aquisição, análise de logs de segurança e automação de conformidade podem ser executadas com modelos de última geração — sem que os dados sensíveis precisem sair do ambiente controlado.

Os modelos disponíveis

NVIDIA Nemotron

A família NVIDIA Nemotron combina modelos de linguagem pequenos (SLM) e grandes (LLM), construídos para eficiência computacional e precisão em sistemas de IA agêntica especializada. Dois modelos se destacam:

  • NVIDIA Nemotron 3 Super (120B): modelo híbrido aberto com arquitetura de Mistura de Especialistas (MoE — Mixture of Experts), com 120 bilhões de parâmetros totais, mas que ativa apenas 12 bilhões por token. Esse design entrega até 5 vezes mais throughput que a geração anterior e suporta uma janela de contexto de 1 milhão de tokens — ideal para tarefas longas e com múltiplos passos.
  • NVIDIA Nemotron 3 Nano (30B): modelo com 30 bilhões de parâmetros que ativa aproximadamente 3 bilhões por token, entregando 4 vezes mais throughput que a geração anterior e reduzindo a geração de tokens de raciocínio em até 60%. Também suporta janela de contexto de 1 milhão de tokens.

Para a lista completa de modelos NVIDIA disponíveis no GovCloud, consulte a documentação de modelos NVIDIA no Amazon Bedrock.

OpenAI GPT OSS

Os modelos GPT OSS da OpenAI são modelos de peso aberto texto-para-texto, projetados para raciocínio, tarefas agênticas e desenvolvimento, com esforço de raciocínio ajustável e suporte a integração com ferramentas externas. Dois variantes estão disponíveis:

  • gpt-oss-120b: modelo com 120 bilhões de parâmetros, voltado para uso em produção, propósito geral e casos de raciocínio complexo.
  • gpt-oss-20b: modelo com 20 bilhões de parâmetros, projetado para menor latência e casos de uso locais ou especializados.

Ambos oferecem janela de contexto de 128 mil tokens e até 16 mil tokens de saída, aceitando entrada de texto e gerando saída de texto. Por serem de peso aberto, as organizações podem avaliar independentemente a arquitetura do modelo, revisar o cartão do modelo publicado e executar seus próprios benchmarks. Para equipes governamentais, essa transparência apoia avaliações de risco organizacional e se alinha aos princípios de zero trust que muitas agências americanas estão adotando.

Consulte a lista completa de modelos OpenAI disponíveis no Amazon Bedrock.

Inferência sem servidor dentro do limite de conformidade

Os modelos NVIDIA Nemotron e GPT OSS no Amazon Bedrock são servidos pelo mecanismo de inferência de próxima geração, chamado Mantle. É importante entender a distinção entre o mecanismo e o endpoint: o mecanismo é a infraestrutura de servimento subjacente, projetado com isolamento de conta de implantação de modelo e acesso zero para operadores; já o endpoint bedrock-mantle é a API HTTPS compatível com OpenAI que as aplicações usam para enviar requisições.

O design de acesso zero para operadores significa que nenhum operador — seja da AWS, do cliente ou do provedor do modelo — pode acessar dados do cliente, como prompts ou completions de inferência. Combinado com o isolamento do AWS GovCloud (US), isso oferece uma base sólida de proteção de dados. Para detalhes técnicos, consulte o post Explorando o design de acesso zero para operadores do Mantle. Para mais informações sobre como o Amazon Bedrock trata seus dados, veja a documentação de proteção de dados no Amazon Bedrock.

Não há infraestrutura para provisionar, GPUs para gerenciar ou expertise em implantação de modelos necessária — o serviço é totalmente gerenciado.

Endpoints disponíveis

O Amazon Bedrock oferece dois endpoints para invocar esses modelos:

  • bedrock-mantle: endpoint compatível com a API da OpenAI, que pode ser chamado com os SDKs Python e TypeScript da OpenAI. Suporta as APIs Chat Completions e Responses.
  • bedrock-runtime: utiliza as APIs Converse e InvokeModel via AWS SDK, com acesso a funcionalidades nativas do Amazon Bedrock, como Guardrails.

Disponibilidade regional e residência de dados

O Amazon Bedrock oferece múltiplas opções para onde as requisições de inferência são processadas:

  • Inferência In-Region: disponível em us-gov-west-1 (AWS GovCloud US-West), mantendo cada requisição dentro de uma única região.
  • Inferência Geo Cross-Region: disponível via um ID de inferência cross-region dedicado ao AWS GovCloud (US), roteando requisições entre us-gov-west-1 e us-gov-east-1. O tráfego permanece dentro do limite do AWS GovCloud (US), com maior resiliência.

A inferência Global Cross-Region, que roteia requisições por regiões comerciais da AWS ao redor do mundo, não está disponível no AWS GovCloud (US). Toda inferência para esses modelos permanece dentro do limite do AWS GovCloud (US).

Níveis de serviço disponíveis

O Amazon Bedrock oferece múltiplos níveis de serviço para atender diferentes requisitos de carga de trabalho. Para todos os modelos mencionados, os níveis Standard, Priority e Flex são suportados:

  • Standard: acesso pago por token, sem compromisso prévio de capacidade.
  • Priority: maior throughput para tráfego sensível a latência.
  • Flex: acesso com menor custo para cargas de trabalho flexíveis e não urgentes, como avaliações de modelos ou sumarizações em lote.

O nível Reserved (throughput dedicado com compromisso de prazo) não está disponível atualmente para esses modelos. Para orientações sobre escalabilidade, consulte as boas práticas de escalabilidade e throughput.

Como começar no AWS GovCloud (US)

Console do Amazon Bedrock

Para testar os modelos diretamente no console:

  • Acesse o console do Amazon Bedrock na sua conta AWS GovCloud (US).
  • Selecione Playground no menu lateral, em seguida Select model.
  • Escolha o provedor (NVIDIA ou OpenAI) e o modelo desejado (por exemplo, NVIDIA Nemotron 3 Super ou gpt-oss-120b).
  • Clique em Apply para carregar o modelo e insira um prompt para testar.

Usando o endpoint bedrock-mantle (recomendado)

Para usar esses modelos via endpoint bedrock-mantle, é necessária uma conta AWS no GovCloud (US) com permissões para invocar modelos do Amazon Bedrock e uma chave de API do Amazon Bedrock ou credenciais AWS padrão. Exemplo de política IAM:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "BedrockMantleInference",
      "Effect": "Allow",
      "Action": [
        "bedrock-mantle:CreateInference",
        "bedrock-mantle:Get*",
        "bedrock-mantle:List*"
      ],
      "Resource": "arn:aws-us-gov:bedrock-mantle:us-gov-west-1:111122223333:project/*"
    },
    {
      "Sid": "BedrockMantleCallWithBearerToken",
      "Effect": "Allow",
      "Action": "bedrock-mantle:CallWithBearerToken",
      "Resource": "*"
    }
  ]
}

Substitua 111122223333 pelo ID da sua conta AWS. Para controlar quais identidades podem gerar ou usar chaves de API do Amazon Bedrock, consulte Controle de permissões para geração e uso de chaves de API do Amazon Bedrock. Para restringir sua organização a modelos aprovados, utilize uma política de controle de serviço (SCP).

O exemplo a seguir usa o SDK Python da OpenAI para chamar o endpoint bedrock-mantle. Para cargas de trabalho em produção, use chaves de API de curto prazo, que expiram automaticamente (máximo de 12 horas):

import boto3
from openai import OpenAI

# Retrieve the Bedrock API key from AWS Secrets Manager
secrets_client = boto3.client("secretsmanager", region_name="us-gov-west-1")
api_key = secrets_client.get_secret_value(SecretId="bedrock-api-key")["SecretString"]

client = OpenAI(
    # Use the AWS GovCloud (US) Region in the base URL, e.g. us-gov-west-1
    base_url="https://bedrock-mantle.us-gov-west-1.api.aws/v1",
    api_key=api_key,
)

response = client.chat.completions.create(
    model="openai.gpt-oss-120b",
    messages=[
        {"role": "user", "content": "Explain the benefits of open-weight models for regulated workloads."}
    ],
    reasoning_effort="medium",  # low | medium | high
    max_completion_tokens=512,
)

print(response.choices[0].message.content)

Nota: os exemplos recuperam a chave de API do Bedrock a partir do AWS Secrets Manager. Para desenvolvimento local, é possível ler a chave de uma variável de ambiente, mas esse padrão deve ser evitado em produção.

Para chamar o NVIDIA Nemotron 3 Super 120B em vez do GPT OSS, basta alterar o parâmetro model para nvidia.nemotron-super-3-120b e remover o parâmetro reasoning_effort (o controle de esforço de raciocínio é específico para os modelos GPT OSS). Nenhuma outra alteração de código é necessária.

Controlando o esforço de raciocínio

Os modelos GPT OSS são modelos de raciocínio que expõem um esforço de raciocínio ajustável. Defina o parâmetro reasoning_effort na chamada Chat Completions como low, medium ou high para equilibrar latência de resposta e profundidade de raciocínio. Use low para tráfego de alto volume e sensível a latência, e high para raciocínio complexo com múltiplos passos ou planejamento agêntico. Para modelos de raciocínio, prefira max_completion_tokens para limitar o tamanho da resposta.

Usando a Responses API

Além do Chat Completions, os modelos GPT OSS suportam a Responses API, a interface da OpenAI para interações no estilo de raciocínio. Ela recebe um único input em vez de um array de mensagens. O NVIDIA Nemotron 3 Super 120B não suporta a Responses API — use Chat Completions, Converse ou Invoke para esse modelo.

import boto3
from openai import OpenAI

# Retrieve the Bedrock API key from AWS Secrets Manager
secrets_client = boto3.client("secretsmanager", region_name="us-gov-west-1")
api_key = secrets_client.get_secret_value(SecretId="bedrock-api-key")["SecretString"]

client = OpenAI(
    base_url="https://bedrock-mantle.us-gov-west-1.api.aws/v1",
    api_key=api_key,
)

response = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Explain the benefits of open-weight models for regulated workloads.",
)

print(response)

Respostas em streaming

Para casos de uso de chat e agentes onde se deseja exibir tokens ao usuário conforme são gerados, defina stream=True:

stream = client.chat.completions.create(
    model="openai.gpt-oss-120b",
    messages=[
        {"role": "user", "content": "Write a short summary of mixture-of-experts architectures."}
    ],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

print()

Tool calling (chamada de ferramentas)

Os modelos NVIDIA Nemotron e GPT OSS de peso aberto são projetados para fluxos de trabalho agênticos, tornando-os adequados para cenários de tool calling. Nesse fluxo, você define funções (ferramentas) que o modelo pode invocar, o modelo decide quando chamá-las com base na solicitação do usuário, e sua aplicação executa a função e retorna o resultado para o modelo incorporar em sua resposta final.

import json
import boto3
from openai import OpenAI

# Retrieve the Bedrock API key from AWS Secrets Manager
secrets_client = boto3.client("secretsmanager", region_name="us-gov-west-1")
api_key = secrets_client.get_secret_value(SecretId="bedrock-api-key")["SecretString"]

client = OpenAI(
    base_url="https://bedrock-mantle.us-gov-west-1.api.aws/v1",
    api_key=api_key,
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a given location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "City and country (e.g., Seattle, US)"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperature unit"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

# Step 1: Send the user request with tool definitions
messages = [
    {"role": "user", "content": "What's the weather like in Seattle?"}
]

response = client.chat.completions.create(
    model="openai.gpt-oss-120b",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

assistant_message = response.choices[0].message

# Step 2: Check if the model wants to call a tool
if assistant_message.tool_calls:
    messages.append(assistant_message)

    for tool_call in assistant_message.tool_calls:
        function_name = tool_call.function.name
        arguments = json.loads(tool_call.function.arguments)

        # Step 3: Validate function name and run it
        if function_name == "get_weather":
            location = arguments.get("location", "Unknown")
            unit = arguments.get("unit", "fahrenheit")
            result = {
                "location": location,
                "temperature": 18 if unit == "celsius" else 64,
                "unit": unit,
                "condition": "Partly cloudy",
                "humidity": 72,
            }
        else:
            result = {"error": f"Unknown function: {function_name}"}

        # Step 4: Return the function result to the model
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(result),
        })

    # Step 5: Get the final response incorporating tool results
    final_response = client.chat.completions.create(
        model="openai.gpt-oss-120b",
        messages=messages,
        tools=tools,
    )
    print(final_response.choices[0].message.content)
else:
    print(assistant_message.content)

No endpoint bedrock-mantle, os modelos GPT OSS suportam tool calling client-side e server-side, enquanto o NVIDIA Nemotron 3 Super 120B suporta apenas client-side. Ambas as famílias também suportam tool calling no endpoint bedrock-runtime via API Converse (usando toolConfig). Consulte o cartão do modelo de cada um para a matriz completa de funcionalidades.

Usando o endpoint bedrock-runtime (boto3)

Para o endpoint bedrock-runtime, são necessárias credenciais AWS configuradas (usuário ou role do Serviço de Gerenciamento de Identidade e Acesso — IAM) com permissão para invocar o modelo. Exemplo de política:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "bedrock:InvokeModel",
        "bedrock:InvokeModelWithResponseStream"
      ],
      "Resource": "arn:aws-us-gov:bedrock:us-gov-west-1::foundation-model/openai.gpt-oss-120b-1:0"
    }
  ]
}

O exemplo a seguir envia uma requisição de turno único usando o SDK AWS para Python (boto3) com a API Converse. Os IDs de modelo GPT OSS no endpoint bedrock-runtime incluem um sufixo de versão (por exemplo, openai.gpt-oss-120b-1:0). Use o ID exato do cartão de cada modelo:

import boto3

client = boto3.client("bedrock-runtime", region_name="us-gov-west-1")

response = client.converse(
    modelId="openai.gpt-oss-120b-1:0",
    messages=[{
        "role": "user",
        "content": [{"text": "What is a mixture-of-experts architecture?"}]
    }],
    inferenceConfig={"maxTokens": 2048, "temperature": 1.0, "topP": 0.95},
)

content_blocks = response["output"]["message"]["content"]
response_text = next(
    (block["text"] for block in content_blocks if "text" in block), None
)

if response_text:
    print(response_text)
else:
    print("No text response.")

Para chamar o NVIDIA Nemotron 3 Super 120B via bedrock-runtime, use o ID de modelo nvidia.nemotron-super-3-120b (esse modelo não carrega sufixo de versão). Também é possível acessar esses modelos pelo terminal usando a Interface de Linha de Comando da AWS (AWS CLI):

aws bedrock-runtime converse \
  --model-id openai.gpt-oss-120b-1:0 \
  --messages '[{"role":"user","content":[{"text":"Type_Your_Prompt_Here"}]}]' \
  --inference-config '{"maxTokens":512}' \
  --region us-gov-west-1

Escalabilidade e tratamento de erros

A capacidade sob demanda no nível Standard é compartilhada e alocada por região da AWS. Durante períodos de alta demanda, uma requisição pode ser brevemente enfileirada ou limitada. No endpoint bedrock-mantle, não há cota de requisições por minuto — o throughput é governado por limites baseados em tokens.

O Amazon Bedrock expõe dois códigos de erro HTTP que indicam quando uma requisição não pode ser atendida:

  • 429: a requisição foi negada por exceder as cotas da conta. Solicite um aumento de cota pelo console de Service Quotas e aplique throttling no lado do cliente.
  • 503: o serviço está enfrentando alta demanda ou restrições temporárias de capacidade. Faça retry com backoff exponencial e jitter.

Para respostas 503 transitórias, configure retries automáticos no SDK:

import boto3
from botocore.config import Config

config = Config(retries={"total_max_attempts": 6, "mode": "standard"})
client = boto3.client("bedrock-runtime", config=config)

Ao retomar após throttling sustentado, mantenha um estado estável por cerca de 15 minutos entre aumentos, em vez de ir diretamente ao volume alvo. Para mais detalhes, consulte as boas práticas de escalabilidade e throughput no Guia do Usuário do Amazon Bedrock.

Limpeza e custos

Esses modelos utilizam inferência sob demanda, que gera cobranças apenas quando um modelo é invocado — não há endpoint ou infraestrutura para desligar. Para evitar cobranças não intencionais após testes:

  • Se você gerou chaves de API de curto prazo do Bedrock, elas expiram automaticamente (máximo de 12 horas). Para revogar antes disso, exclua-as no console do Amazon Bedrock.
  • Se optou pelo nível Priority para testes, retorne ao preço Standard removendo o parâmetro service_tier das suas invocações.
  • Se armazenou uma chave de API do Bedrock no AWS Secrets Manager para testes, exclua o segredo para evitar cobranças de armazenamento.

Para detalhes de preços por modelo e nível, consulte a página de preços do Amazon Bedrock.

Disponibilidade

Os modelos OpenAI GPT OSS e NVIDIA Nemotron já estão disponíveis no Amazon Bedrock no AWS GovCloud (US). A inferência In-Region está disponível no AWS GovCloud (US-West) (us-gov-west-1), e a inferência Geo Cross-Region roteia requisições entre AWS GovCloud (US-West) e AWS GovCloud (US-East) (us-gov-east-1), mantendo o tráfego dentro do limite do AWS GovCloud (US). Os preços são por token e variam por modelo e nível de serviço. Para as tarifas atuais, consulte a página de preços do Amazon Bedrock.

Recursos adicionais

Fonte

Run NVIDIA Nemotron and OpenAI GPT OSS models on Amazon Bedrock in AWS GovCloud (US) (https://aws.amazon.com/blogs/machine-learning/run-nvidia-nemotron-and-openai-gpt-oss-models-on-amazon-bedrock-in-aws-govcloud-us/)

Comments

Leave a Reply

Your email address will not be published. Required fields are marked *

More posts