AWS Builder Center

Builder Center

Construindo um Agente Inteligente na AWS com Amazon Bedrock: Arquitetura, Código e Implementação Prática

Construindo um Agente Inteligente na AWS com Amazon Bedrock: Arquitetura, Código e Implementação Prática

Aprenda a construir um agente inteligente completo na AWS utilizando Amazon Bedrock, Lambda e DynamoDB, com arquitetura real, código e boas práticas de produção.

Guilherme Benfica

Senior Software Engineer .NET/AWS

Introdução

No artigo anterior Link , exploramos os fundamentos da Generative AI e o Amazon Bedrock.
Agora, vamos dar o próximo passo: sair da teoria e construir um agente inteligente real, utilizando uma arquitetura serverless e escalável.
Aqui, você não vai apenas chamar um modelo — você vai criar um sistema inteligente completo.

🤖 O que é um Agente na AWS?

Um agente vai além de um simples prompt.
Ele combina:
  • 🧠 Modelo (Bedrock)
  • 🔄 Lógica (Lambda)
  • 💾 Memória (DynamoDB)
  • 🌐 Interface (API Gateway)
👉 Ou seja: o agente pensa, lembra e responde com contexto

🏗️ Arquitetura da Solução

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Usuário
│
▼
API Gateway
│
▼
AWS Lambda
│
┌──────────┴──────────┐
▼ ▼
Amazon Bedrock DynamoDB
(LLM) (memória)
│ │
└──────────┬──────────┘
▼
Resposta final

📊 Fluxo do Agente

1
2
3
4
5
6
7
8
1. Usuário envia prompt
2. API Gateway recebe requisição
3. Lambda processa input
4. Lambda busca histórico no DynamoDB
5. Prompt é enriquecido com contexto
6. Bedrock gera resposta
7. Lambda salva histórico
8. Resposta retorna ao usuário

⚙️ Passo a Passo

✅ 1. Criar tabela DynamoDB (memória)

  • Nome: chat-history
  • Chave primária: session_id

✅ 2. Criar Role IAM

Permissões mínimas:
1
2
3
4
5
6
7
8
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel",
"dynamodb:GetItem",
"dynamodb:PutItem"
],
"Resource": "*"
}

✅ 3. Criar função Lambda

Exemplo completo (Python):
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
import json
import boto3

bedrock = boto3.client("bedrock-runtime")
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table("chat-history")

def get_history(session_id):
response = table.get_item(Key={"session_id": session_id})
return response.get("Item", {}).get("history", "")

def save_history(session_id, history):
table.put_item(
Item={
"session_id": session_id,
"history": history
}
)

def lambda_handler(event, context):
body = json.loads(event["body"])

prompt = body.get("prompt")
session_id = body.get("session_id", "default")

history = get_history(session_id)

enriched_prompt = f"""
Conversa anterior:
{history}

Usuário: {prompt}
Assistente:
"""

response = bedrock.invoke_model(
modelId="anthropic.claude-v2",
body=json.dumps({
"prompt": enriched_prompt,
"max_tokens_to_sample": 300
})
)

result = json.loads(response["body"].read())
answer = result.get("completion")

new_history = history + f"\nUsuário: {prompt}\nAssistente: {answer}"

save_history(session_id, new_history)

return {
"statusCode": 200,
"body": json.dumps({
"response": answer
})
}

✅ 4. Criar API Gateway

  • Tipo: HTTP API
  • Rota:
1
POST /chat
  • Integração: Lambda

✅ 5. Testando o Agente

1
2
3
4
5
6
curl -X POST https://seu-endpoint/chat \
-H "Content-Type: application/json" \
-d '{
"session_id": "user123",
"prompt": "Explique o que é AWS Lambda"
}'

🧠 Evoluindo o Agente (Nível Arquitetura)

Agora vem o diferencial.

🔎 1. Implementar RAG (dados internos)

Arquitetura:
1
2
3
4
Usuário → Query
→ OpenSearch (busca)
→ Contexto + Prompt
→ Bedrock
👉 Permite respostas com dados da empresa

🧩 2. Uso de Tools (Function Calling)

Exemplo:
  • Consultar APIs internas
  • Buscar dados em banco
  • Executar ações automatizadas

💾 3. Memória avançada

  • DynamoDB → curto prazo
  • S3 → histórico longo
  • Redis (ElastiCache) → alta performance

🔄 4. Orquestração com Step Functions

Para agentes mais complexos:
  • múltiplas etapas
  • decisões condicionais
  • workflows inteligentes

🔐 Boas Práticas

  • ✅ Least Privilege (IAM)
  • ✅ Limitar tokens
  • ✅ Sanitizar inputs
  • ✅ Logs no CloudWatch
  • ✅ Monitorar custos

💰 Custos

Fatores principais:
  • Tokens de entrada/saída
  • Execuções Lambda
  • Requests de API
📉 Estratégias:
  • Cache de respostas
  • Redução de contexto
  • Uso de modelos menores quando possível

🚀 Conclusão

Criar agentes com Amazon Bedrock não é apenas integrar um modelo de IA.
É projetar uma arquitetura inteligente, capaz de:
  • entender contexto
  • armazenar memória
  • integrar com sistemas
  • escalar automaticamente
👉 Esse é o verdadeiro diferencial no mercado hoje.
# amazon-bedrock# amazon-bedrock-agents# artificial-intelligence
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