AWS Builder Center

Builder Center

Primeiros Passos com o Amazon Bedrock AgentCore Code Interpreter

Primeiros Passos com o Amazon Bedrock AgentCore Code Interpreter

Aprenda a executar código Python em um sandbox seguro e gerenciado usando boto3. Este guia passo a passo cobre gerenciamento de sessões, execução com estado persistente e análise de dados com o AgentCore Code Interpreter.

Series: Primeiros Passos com o Amazon Bedrock AgentCore Code (7 articles)

  1. 1
    Primeiros Passos com Amazon Bedrock AgentCore Harness e Runtime
  2. 2
    Primeiros Passos com o Amazon Bedrock AgentCore Code Interpreter This article
  3. 3
    Primeiros Passos com o Amazon Bedrock AgentCore Gateway

Carlos Biagolini

AWS Solutions Architect

Introdução

Agentes de IA estão se tornando cada vez mais capazes, mas frequentemente enfrentam dificuldades em tarefas que exigem computação precisa, análise de dados ou execução de código. Em vez de depender exclusivamente do raciocínio de um modelo para realizar cálculos (o que pode ser não confiável), você pode dar ao seu agente a capacidade de realmente executar código em um ambiente sandbox seguro e acessar seus dados reais enquanto faz isso.
O Amazon Bedrock AgentCore Code Interpreter  é um serviço gerenciado que fornece ambientes sandbox isolados onde agentes podem escrever e executar código de forma segura. Ele suporta Python, JavaScript e TypeScript, vem com bibliotecas pré-instaladas para análise e visualização de dados, e cuida de toda a infraestrutura para você.
Este artigo faz parte de uma série que estou escrevendo sobre diferentes aspectos do Amazon Bedrock AgentCore. Aqui, focamos em como usar o Code Interpreter para resolver o problema descrito acima. Para uma compreensão mais ampla do AgentCore e seus componentes, confira os outros artigos desta série:

Modos de Rede

Ao criar um Code Interpreter customizado, você escolhe um modo de rede  que determina o que o sandbox pode acessar:
  • Sandbox — Ambiente restrito com acesso de rede limitado apenas ao Amazon S3. Sem internet, sem outros serviços AWS. Esta é a opção mais segura e reduz riscos potenciais.
  • Public — Permite acesso à internet pública e a todos os endpoints de serviços AWS. Use quando seu Code Interpreter precisar interagir com serviços além do S3 (como DynamoDB, APIs ou URLs externas).
  • VPC — Implantação dentro de uma Virtual Private Cloud para comunicação segura e privada com recursos na sua rede.
Neste artigo, exploramos três abordagens:
  • Primeiro, usamos o modo Sandbox para uma demonstração simples e segura. O Code Interpreter acessa um arquivo CSV armazenado no S3, baixa-o para o sandbox usando o AWS CLI e o analisa com Pandas.
  • Em seguida, usamos o modo Public para demonstrar como um Code Interpreter pode acessar serviços AWS além do S3. Neste cenário, o Code Interpreter consulta uma tabela DynamoDB contendo dados de inventário de carros, realiza análise estatística e retorna resultados. Isso se conecta ao cenário do agente de concessionária introduzido em Getting Started with Amazon Bedrock AgentCore Harness and Runtime , onde criamos um Harness para um assistente de vendas de carros usados.
  • Finalmente, integramos o Code Interpreter como uma ferramenta no Harness e deixamos o agente de IA gerar e executar código autonomamente para responder a uma pergunta de um cliente sobre financiamento de veículos.

Importante: Code Interpreter é para Computação, Não para Recuperação de Dados

A documentação da AWS descreve o Code Interpreter como uma ferramenta que estende as capacidades de resolução de problemas  permitindo que agentes "resolvam problemas computacionais difíceis de abordar apenas com raciocínio" e possibilitando "cálculos matemáticos precisos e processamento de dados em escala." Ele foi projetado para complementar o raciocínio de um agente com execução real de código.
Nos exemplos abaixo (Steps 3 e 5), invocamos o Code Interpreter diretamente da nossa máquina local para demonstrar as capacidades do recurso e como diferentes modos de rede funcionam. No entanto, em um cenário de agente em produção (como o assistente de concessionária que estamos construindo ao longo desta série), o padrão recomendado é que a recuperação de dados venha de ferramentas dedicadas (como servidores MCP ou AgentCore Gateway) e o Code Interpreter lide apenas com tarefas computacionais (cálculos, transformação de dados, análise estatística). Essa separação de responsabilidades será explorada em artigos futuros. No Step 7, mostramos uma prévia desse padrão: o agente recebe dados em seu prompt e usa o Code Interpreter exclusivamente para um cálculo de financiamento.

O que é o AgentCore Code Interpreter?

O Amazon Bedrock AgentCore é uma plataforma para construir, implantar e operar agentes de IA em escala. Ele inclui múltiplos serviços modulares  que funcionam juntos ou independentemente. O Code Interpreter é um desses serviços.
O Code Interpreter segue um modelo baseado em recursos e sessões :
  • Você cria um recurso de Code Interpreter (customizado ou usa o padrão do sistema)
  • Você inicia uma sessão com um timeout configurável (padrão de 15 minutos)
  • Dentro dessa sessão, você executa código e mantém o estado entre execuções
  • Múltiplas sessões podem rodar simultaneamente, cada uma com seu próprio ambiente isolado
  • Quando terminar, você encerra a sessão para liberar recursos
Ao criar um Code Interpreter customizado, você configura o modo de rede e atribui uma IAM execution role. No modo Sandbox, a execution role define quais buckets S3 o interpretador pode acessar. Após a criação, o console fornece um Code Interpreter Tool ID único que você usa em todas as chamadas de API.

Funcionalidades Principais

  • Execução segura em ambientes containerizados
  • Suporte para Python, JavaScript e TypeScript
  • Bibliotecas pré-instaladas (NumPy, Pandas, Matplotlib e mais)
  • Operações de upload/download de arquivos (até 100 MB inline, até 5 GB via S3)
  • Execução de comandos de terminal
  • Timeout de execução padrão de 15 minutos (extensível até 8 horas)
  • Logging via CloudTrail para auditoria

Pré-requisitos

  • Conta AWS com credenciais configuradas
  • Usuário ou role IAM com permissões para usar o Amazon Bedrock AgentCore Code Interpreter. Para detalhes sobre as ações IAM necessárias, consulte a documentação de permissões IAM do Code Interpreter 
  • Python 3.10+ instalado
  • Git instalado
  • Região AWS onde o AgentCore está disponível (us-east-1, us-west-2, ap-southeast-2 ou eu-central-1)

Step 1: Clonar o Repositório e Instalar Dependências

Clone o repositório complementar e configure o ambiente Python:
1
2
3
4
5
git clone https://github.com/biagolini/PythonAwsBedrockAgentCoreCodeInterpreter.git
cd PythonAwsBedrockAgentCoreCodeInterpreter
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
No Windows, substitua o comando de ativação por .venv\Scripts\activate.

Step 2: Criar um Code Interpreter no Console

Antes de executar código, você precisa criar um Code Interpreter . Neste passo, você usará o console do Amazon Bedrock AgentCore para criar uma ferramenta Code Interpreter customizada.

2.1 Navegar até o Code Interpreter

2.1.1. Abra o console do Amazon Bedrock AgentCore 
2.1.2. No painel de navegação à esquerda, em Built-in tools, clique em Code Interpreter
2.1.3. Clique no botão Create no canto superior direito da lista de Code Interpreters
Tela do console do Amazon Bedrock AgentCore exibindo o menu lateral com a seção Built-in tools expandida, a opção Code Interpreter selecionada e o botão Create destacado no canto superior direito
Primeira etapa da criação da ferramenta, onde localizamos o Code Interpreter no menu Built-in tools e iniciamos a criação de um recurso personalizado

2.2 Configurar a Ferramenta Code Interpreter

O formulário de criação tem três seções: detalhes da ferramenta, configurações da ferramenta e permissões.
Tela do console mostrando o formulário de criação do Code Interpreter dividido em três seções: detalhes da ferramenta, configurações da ferramenta e permissões
Visão geral do formulário de criação, onde definimos o nome, a descrição, o modo de rede e as permissões da nova ferramenta
2.2.1. No campo Tool name, insira um nome para seu interpretador (exemplo: code_interpreter_tool_demo). Caracteres válidos são a-z, A-Z, 0-9 e _ (underscore). O nome pode ter até 48 caracteres
2.2.2. Opcionalmente, adicione uma descrição no campo Tool description
2.2.3. Em Tool configurations, na seção Security, selecione o modo de rede:
  • Sandbox - Ambiente restrito com acesso de rede limitado ao serviço AWS S3 (recomendado para este tutorial)
  • Public - Permite acesso à internet, adequado para cenários menos sensíveis ou de uso aberto
  • VPC (Virtual Private Cloud) - Implantação dentro de uma VPC para comunicação segura e privada
2.2.4. Em Permissions, na seção IAM permissions, clique em Create new role. Isso abre um diálogo para configurar a role e sua política:
Tela do console exibindo o diálogo de criação de uma nova role IAM, com o campo de nome da role preenchido automaticamente e o editor de política JSON para definir o acesso ao Amazon S3
Configuração da role de execução seguindo o princípio do menor privilégio, concedendo apenas as permissões de leitura necessárias no bucket S3
O console preenche o Role name com um valor padrão. Você pode atualizá-lo seguindo boas práticas de nomenclatura. Por exemplo, AgentCoreCodeInterpreter-S3-ReadOnly transmite claramente o serviço, escopo de recurso e nível de permissão. A trust policy é configurada automaticamente (permitindo que bedrock-agentcore.amazonaws.com assuma a role). Você precisa definir a Policy que determina quais recursos AWS o Code Interpreter pode acessar durante a execução.
Neste tutorial, o Code Interpreter precisa ler um arquivo CSV do S3. Substitua o conteúdo padrão da política pelo seguinte:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "S3ReadAccess",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::<your-bucket-name>",
"arn:aws:s3:::<your-bucket-name>/*"
]
}
]
}
Substitua <your-bucket-name> pelo nome do bucket S3 que você configurou no arquivo .env. Isso segue o princípio do menor privilégio , concedendo apenas as permissões de leitura necessárias para este tutorial.
Clique em Create role para confirmar.
2.2.5. De volta ao formulário principal de criação, clique no botão Create na parte inferior da página

2.3 Copiar o Code Interpreter Tool ID

Após a criação, o console exibe a página de detalhes da ferramenta. Copie o valor do Code interpreter tool ID. Você usará este identificador em todas as chamadas de API.
Tela do console apresentando a página de detalhes do Code Interpreter recém-criado, com destaque para o valor do Code interpreter tool ID que será usado nas chamadas de API
Após a criação, copiamos o identificador da ferramenta, pois ele é necessário em todas as interações via API e scripts

Step 3: Executar Código com Boto3

Todos os scripts neste passo leem o CODE_INTERPRETER_ID do arquivo .env. Certifique-se de ter adicionado o tool ID que você copiou no Step 2.3:
1
CODE_INTERPRETER_ID=<your-code-interpreter-id>

3.1 Hello World Básico

O arquivo code_interpreter_hello.py demonstra a interação mais simples possível: iniciar uma sessão, executar uma instrução print e encerrar a sessão.
1
# code/code_interpreter_hello.py
Execute o script:
1
python code_interpreter_hello.py
Saída esperada:
1
2
3
4
5
Started session: <session-id>

Hello from AgentCore Code Interpreter!

Stopped session: <session-id>

3.2 Analisar Dados do S3

Agora vamos usar o Code Interpreter para acessar dados reais. O arquivo code_interpreter_s3.py baixa um CSV do seu bucket S3 usando o AWS CLI dentro do sandbox e então o analisa com Pandas.
O conceito-chave aqui é que o sandbox tem o AWS CLI disponível e usa a execution role que você configurou no Step 2 para autenticação. Isso significa que você pode usar executeCommand com comandos do AWS CLI para interagir com qualquer recurso AWS ao qual a role tenha acesso.
1
# code/code_interpreter_s3.py
Execute o script completo:
1
python code_interpreter_s3.py

Step 4: Gerenciamento de Sessões com AWS CLI

Em um cenário real, você frequentemente gerenciará sessões a partir do seu terminal usando o AWS CLI. Aqui estão comandos úteis para gerenciamento de sessões.

4.1 Listar Sessões Ativas

Use o AWS CLI para listar sessões ativas do seu Code Interpreter:
1
2
3
aws bedrock-agentcore list-code-interpreter-sessions \
--region us-east-1 \
--code-interpreter-id "<your-code-interpreter-id>"
Você verá sessões com status READY (ativas) ou TERMINATED (concluídas/expiradas por timeout).
As sessões terminam automaticamente após o timeout configurado (padrão de 900 segundos = 15 minutos). Você pode confirmar isso verificando o status após o período de timeout, confirmando que a terminação automática  funciona conforme esperado.

4.2 Encerrar uma Sessão via AWS CLI

Se você precisar encerrar uma sessão antes do timeout, use o comando stop-code-interpreter-session :
1
2
3
4
aws bedrock-agentcore stop-code-interpreter-session \
--region us-east-1 \
--code-interpreter-id "<your-code-interpreter-id>" \
--session-id "<your-session-id>"
Esta é a forma recomendada de liberar recursos quando você terminar. Embora as sessões se encerrem automaticamente após o timeout, pará-las imediatamente evita cobranças desnecessárias durante o período de espera.

Step 5: Modo Public com Acesso ao DynamoDB

Nos passos anteriores, usamos um Code Interpreter no modo Sandbox, que restringe o acesso de rede apenas ao S3. Agora introduzimos um segundo cenário usando o modo Public. Neste modo, o sandbox do Code Interpreter tem acesso à internet pública e a todos os endpoints de serviços AWS. Isso permite que o sandbox interaja com serviços como DynamoDB, SQS ou qualquer API externa.
Este exemplo se conecta ao caso de uso do agente de concessionária do artigo anterior desta série , onde criamos um Harness para servir como assistente de vendas. Aqui, demonstramos como um Code Interpreter configurado como ferramenta poderia acessar o banco de dados de inventário da concessionária no DynamoDB e realizar análise de dados. Em uma configuração de produção, este Code Interpreter poderia ser anexado ao Harness como uma ferramenta, permitindo que o agente de IA consulte dados reais de inventário e execute cálculos ao responder perguntas de clientes.

5.1 Criar a Tabela DynamoDB

Para esta demonstração, precisamos de uma tabela DynamoDB com dados de inventário de carros. Em um artigo anterior , construímos um servidor MCP serverless na AWS que expõe um banco de dados DynamoDB de inventário de carros através do API Gateway e Lambda, protegido com autenticação IAM. A infraestrutura completa em Terraform está disponível em https://github.com/biagolini/TerraformAwsMcpServerlessKiroCli . Você pode usar esse código Terraform para provisionar a tabela automaticamente, mas ele também cria recursos adicionais (API Gateway, Lambda, roles IAM para o servidor MCP) que não são necessários para este artigo.
Para criar apenas a tabela DynamoDB, siga estes passos manuais no Console AWS:
5.1.1. Navegue até Amazon DynamoDB > Tables no Console AWS
5.1.2. Clique em Create table
5.1.3. Configure a tabela:
  • Table name: mcp-cars-dev
  • Partition key: car_id (String)
  • Table settings: Selecione Customize settings, depois em Read/write capacity settings, selecione On-demand (serverless, pagamento por requisição)
5.1.4. Clique em Create table
5.1.5. Popule a tabela com dados de exemplo. O script de seed está disponível em https://github.com/biagolini/TerraformAwsMcpServerlessKiroCli/blob/main/seed/seed_cars.sh . Este script insere registros hipotéticos de carros usados com atributos como marca, modelo, ano, preço, cor, tipo de carroceria, quilometragem e status de disponibilidade.

5.2 Criar um Code Interpreter com Modo Public

Agora crie um segundo Code Interpreter configurado para acesso de rede Public e permissões no DynamoDB.
5.2.1. Navegue até Amazon Bedrock AgentCore > Built-in tools > Code Interpreter
5.2.2. Clique em Create
5.2.3. No campo Tool name, insira code_interpreter_public_dynamo
5.2.4. Em Tool configurations > Security, selecione Public como o modo de rede
5.2.5. Em Permissions, clique em Create new role. Nomeie a role como AgentCoreCodeInterpreter-DynamoDB-ReadOnly e use a seguinte política:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DynamoDBReadAccess",
"Effect": "Allow",
"Action": [
"dynamodb:Scan",
"dynamodb:Query",
"dynamodb:GetItem",
"dynamodb:DescribeTable"
],
"Resource": [
"arn:aws:dynamodb:us-east-1:<your-account-id>:table/mcp-cars-dev",
"arn:aws:dynamodb:us-east-1:<your-account-id>:table/mcp-cars-dev/index/*"
]
}
]
}
5.2.6. Clique em Create role, depois em Create para criar o Code Interpreter
5.2.7. Copie o Code interpreter tool ID da página de detalhes. Adicione ao seu arquivo .env:
1
2
CODE_INTERPRETER_PUBLIC_ID=<your-public-code-interpreter-id>
DYNAMODB_TABLE_NAME=mcp-cars-dev

5.3 Consultar DynamoDB a partir do Code Interpreter

O arquivo code_interpreter_dynamodb.py demonstra como um Code Interpreter no modo Public pode consultar o DynamoDB, fazer scan na tabela de inventário de carros e realizar análise estatística. O código dentro do sandbox usa boto3 para conectar ao DynamoDB utilizando as credenciais da execution role.
1
# code/code_interpreter_dynamodb.py
Execute o script:
1
python code_interpreter_dynamodb.py
Saída esperada:
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
Started session: <session-id>

--- Querying DynamoDB Car Inventory ---
Total cars in inventory: 10

=== Car Inventory Summary ===
Brand Model Year Price Color Body Type Available
--------------------------------------------------------------------------------
Chevrolet Tahoe 2018 $29,000 white suv yes
Ford Mustang 2019 $27,500 red coupe yes
Ford F-150 2019 $29,000 gray truck yes
...

--- Performing Price Analysis ---
=== Price Analysis ===
Average price: $24,580.00
Lowest price: $13,500
Highest price: $32,000

=== Inventory by Body Type ===
suv : 3 car(s), avg price $28,333.33
sedan : 3 car(s), avg price $16,600.00
coupe : 1 car(s), avg price $27,500.00
...

=== Availability ===
Available: 9
Sold: 1

Stopped session: <session-id>
A diferença principal em relação ao exemplo no modo Sandbox é que o Code Interpreter agora pode acessar qualquer serviço AWS que a execution role permita. O sandbox usa a IAM execution role para autenticar chamadas de API. Neste caso, ele chama dynamodb:Scan na tabela mcp-cars-dev, recupera todos os itens e os processa com Python.
Esse padrão permite casos de uso poderosos onde um agente de IA pode:
  • Consultar bancos de dados ao vivo para responder perguntas de clientes com dados reais
  • Realizar cálculos sobre inventário real (análise de preços, resumos de disponibilidade)
  • Gerar relatórios a partir de fontes de dados de produção sem expor credenciais brutas de banco de dados

Step 6: Limpeza e Criação de um Code Interpreter Sandbox para o Harness

Antes de integrar o Code Interpreter ao nosso Harness, vamos limpar os Code Interpreters customizados criados nos passos anteriores. Em seguida, criaremos um novo especificamente projetado para o caso de uso do agente: um Code Interpreter no modo Sandbox sem acesso ao S3 ou DynamoDB. Na nossa arquitetura, os dados virão de outras ferramentas (servidores MCP, Gateway) em artigos futuros. A função do Code Interpreter é puramente computacional.

6.1 Excluir Code Interpreters Anteriores

6.1.1. Navegue até Amazon Bedrock AgentCore > Built-in tools > Code Interpreter
6.1.2. Selecione os Code Interpreters criados nos passos anteriores (ex: code_interpreter_tool_demo e code_interpreter_public_dynamo)
6.1.3. Clique em Delete e confirme

6.2 Criar um Novo Code Interpreter Sandbox (Sem Acesso Externo)

6.2.1. Clique em Create
6.2.2. No campo Tool name, insira code_interpreter_sandbox_ci
6.2.3. Em Tool configurations > Security, selecione Sandbox como o modo de rede
6.2.4. Deixe todas as configurações restantes com seus valores padrão
6.2.5. Clique em Create para criar o Code Interpreter
Este novo Code Interpreter é um sandbox de computação pura. Ele pode executar código Python, JavaScript ou TypeScript, mas não pode acessar nenhum recurso externo. Isso é exatamente o que queremos para a integração com o Harness: o agente o usará exclusivamente para cálculos e processamento de dados.

Step 7: Integrando o Code Interpreter com o Harness

Agora conectamos o Code Interpreter como uma ferramenta ao Harness que criamos no primeiro artigo desta série . O agente (nosso assistente de concessionária) decidirá autonomamente escrever e executar código Python quando precisar realizar cálculos precisos. Nós não escrevemos o código. A IA o gera, envia para o sandbox do Code Interpreter para execução, lê o resultado e formula uma resposta.
Neste exemplo, o agente não precisa de acesso ao banco de dados porque os dados (preços dos carros) são fornecidos diretamente na pergunta do usuário. Em artigos futuros, exploraremos como combinar ferramentas de recuperação de dados (como servidores MCP ou AgentCore Gateway) com o Code Interpreter, onde uma ferramenta busca dados e a outra realiza cálculos.

7.1 Editar o Harness para Adicionar o Code Interpreter

7.1.1. Abra o console do Amazon Bedrock AgentCore Harness 
7.1.2. Clique no nome do seu Harness (car_agent) para abrir a página de detalhes. Se você o excluiu após o artigo anterior, crie um novo seguindo os mesmos passos daquele artigo.
7.1.3. Na página de detalhes do Harness, clique no botão Edit na área superior direita
Tela do console exibindo a página de detalhes do Harness car_agent, com o botão Edit destacado na área superior direita
Ponto de partida para integrar o Code Interpreter ao Harness, acessando a edição do agente já criado em artigos anteriores
7.1.4. Na página de edição do Harness, role para baixo até a seção Tools e expanda-a
7.1.5. Ative o toggle Code interpreter tool. No dropdown que aparece, selecione o Code Interpreter que você criou no Step 6 (code_interpreter_sandbox_ci). Você também pode selecionar o AgentCore Code Interpreter padrão do sistema se preferir não criar um customizado.
7.1.6. Clique em Save Harness na parte inferior da página. Quando a atualização for concluída, você verá uma mensagem de confirmação:
1
car_agent, Version 2 was successfully updated. A default endpoint is also in progress and will be associated with Version 2.
Tela do console exibindo a mensagem de confirmação de que a versão do Harness car_agent foi atualizada com sucesso e que um endpoint padrão está sendo associado
Confirmação de que a nova versão do Harness foi salva, indicando que devemos aguardar o status voltar para Ready antes de prosseguir
Aguarde o status retornar para Ready antes de prosseguir.

7.2 Testar com um Cálculo de Financiamento

7.2.1. Quando o Harness estiver Ready, clique no botão Test Harness no canto superior direito
7.2.2. Na interface de chat, insira o seguinte prompt:
1
2
3
4
5
6
7
8
A customer is deciding between three cars from our inventory:
1. Honda Civic 2019 - $17,800
2. Mazda Mazda3 2021 - $22,500
3. Toyota RAV4 2021 - $28,500

A bank offered a financing rate of 7.5% per year (compound interest). The customer wants to finance the car over 3 years (36 monthly payments). They said their maximum budget is $700 per month for the installment.

Please calculate the monthly payment for each car and determine which ones fit within the customer's budget. Show the total amount paid over the financing period for each option.
7.2.3. Observe a resposta do agente. A interface de teste mostrará indicadores como "Code Interpreter x3", confirmando que o agente invocou o Code Interpreter múltiplas vezes para realizar os cálculos. Na resposta, você pode ver o agente raciocinando sobre a fórmula de juros compostos e calculando a parcela mensal de cada carro. No final, ele apresenta uma resposta elaborada indicando quais carros cabem no orçamento do cliente e quais não cabem.
7.2.4. Se os resultados não forem satisfatórios (cálculos incorretos, raciocínio incompleto ou muitas tentativas do Code Interpreter), você pode voltar à página de edição do Harness e selecionar um modelo diferente. Neste teste, usamos amazon.nova-micro-v1:0, que é a opção mais econômica com menor latência, mas capacidades de raciocínio limitadas. Modelos maiores como Nova Pro ou Claude Sonnet produzem código mais preciso na primeira tentativa e requerem menos retentativas, mas custam mais por token e podem ter maior latência. Escolha o modelo que melhor equilibre custo, precisão e tempo de resposta para o seu caso de uso.

7.3 Verificar na Observabilidade

Você pode confirmar que o Code Interpreter foi realmente invocado verificando as métricas de observabilidade. Navegue até Amazon Bedrock AgentCore > Built-in tools > Code Interpreter, selecione seu Code Interpreter e verifique a seção de observabilidade. Após alguns minutos, as métricas mostrarão a atividade de invocação.
Note que os dados de observabilidade podem levar alguns minutos para aparecer. Se você não vir as métricas imediatamente após o teste, aguarde e recarregue a página.
Tela do console exibindo o painel de observabilidade do Code Interpreter, com gráficos e métricas que confirmam a atividade de invocação após a execução do teste
Verificação de que o Code Interpreter foi realmente acionado pelo agente, com as métricas de invocação aparecendo alguns minutos após o teste
O insight principal aqui é que você nunca escreveu o código de cálculo de financiamento. O agente decidiu que precisava executar código, gerou um script Python com a fórmula padrão de amortização, executou-o no sandbox e usou os resultados para responder à pergunta do cliente com precisão. Esta é a diferença entre usar o Code Interpreter como um mecanismo de execução direta (Steps 3-5) versus usá-lo como uma ferramenta autônoma para um agente de IA.

Conclusão

Neste artigo, você explorou três formas de usar o Amazon Bedrock AgentCore Code Interpreter:
  • Modo Sandbox com invocação direta (Steps 2-4): Um ambiente restrito onde o Code Interpreter pode acessar apenas o S3. Você criou um Code Interpreter customizado, configurou uma IAM execution role para acesso de leitura ao S3 e usou comandos de terminal dentro do sandbox para baixar e analisar um arquivo CSV com Pandas.
  • Modo Public com invocação direta (Step 5): Um ambiente aberto onde o Code Interpreter pode acessar qualquer serviço AWS ou a internet pública. Você criou um segundo Code Interpreter com permissões de leitura no DynamoDB e o usou para consultar uma tabela de inventário de carros ao vivo, realizando análise estatística sobre os dados.
  • Integração com Harness com geração autônoma de código (Steps 6-7): O padrão mais poderoso. Você criou um sandbox de computação pura (sem acesso externo), anexou-o ao Harness via Console AWS e deixou o agente de IA escrever e executar autonomamente um cálculo de financiamento para responder à pergunta de um cliente.
Os pontos-chave são:
  • Invocação direta (Steps 3-5) é útil para pipelines com scripts onde você controla qual código é executado. Você escreve o código, o sandbox o executa.
  • Integração com Harness (Step 7) é o padrão agêntico. A IA decide quando e qual código escrever. O Code Interpreter fornece precisão computacional que complementa as capacidades de raciocínio do modelo.
  • O modo de rede determina o raio de impacto. Use Sandbox quando nenhum acesso externo é necessário (ou quando os dados vêm de outras ferramentas). Use Public quando o próprio sandbox precisa alcançar serviços AWS ou a internet.
  • Recuperação de dados e computação são preocupações separadas. Em produção, use ferramentas dedicadas (servidores MCP, Gateway) para buscar dados e o Code Interpreter para cálculos. O Code Interpreter foi projetado para computação, não para recuperação de dados. Essa separação segue boas práticas de segurança e será explorada em artigos futuros.

Referências

Fique Conectado

Se você achou este artigo útil e quer aprender mais sobre AWS, arquitetura cloud, IA, infraestrutura como código e segurança na nuvem, siga o autor para conteúdos futuros e tutoriais:
Fique ligado para mais walkthroughs práticos e soluções para desafios de infraestrutura cloud e DevOps.
Happy building on AWS! 🚀☁️
# ai# amazon-bedrock-agentcore# amazon-bedrock# agents# ai-agents

Series: Primeiros Passos com o Amazon Bedrock AgentCore Code (7 articles)

  1. 1
    Primeiros Passos com Amazon Bedrock AgentCore Harness e Runtime
  2. 2
    Primeiros Passos com o Amazon Bedrock AgentCore Code Interpreter This article
  3. 3
    Primeiros Passos com o Amazon Bedrock AgentCore Gateway
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article