Criação eficaz de agentes de IA no AWS Serverless

Por Anton Aleksandrov, Principal SSA, Serverless – ISV e Dhiraj Mahapatro, Principal SSA, Amazon Bedrock.

Imagine um assistente de IA que não responde apenas às solicitações, mas raciocina por meio de planos, age e se integra a sistemas em tempo real. Essa é a promessa da IA agente.

De acordo com o Gartner, até 2028, mais de 33% dos aplicativos corporativos incorporarão recursos agentes — contra menos de 1% atualmente. Enquanto os primeiros esforços generativos de IA se concentravam em GPUs e treinamento de modelos, os sistemas agentes mudam o foco para CPUs, orquestração e integração com dados ao vivo — os lugares onde as organizações estão começando a ver um retorno real sobre o investimento (ROI).

Nesta postagem, você aprenderá a criar e executar agentes de IA Serverless na AWS usando serviços como o Amazon Bedrock AgentCore (versão prévia a partir desta publicação), o AWS Lambda e o Amazon Elastic Container Service (Amazon ECS), que fornecem bases computacionais escaláveis para cargas de trabalho de agentes. Você também explorará padrões de arquitetura, gerenciamento de estado, identidade, observabilidade e uso de ferramentas para dar suporte a implantações prontas para produção.

Visão geral

Os primeiros assistentes de IA eram sem estado e reativos — cada solicitação era processada isoladamente, sem memória de interações anteriores ou consciência de um contexto mais amplo. Gradualmente, os assistentes de IA se tornaram mais capazes injetando solicitações do sistema, preservando o histórico de conversas e incorporando o conhecimento corporativo usando a Retrieval-Augmented Generation (RAG), conforme ilustrado no diagrama a seguir.

Apesar dessas melhorias, os assistentes tradicionais de IA ainda careciam de verdadeira autonomia. Eles não conseguiam raciocinar por meio de metas de várias etapas, tomar decisões por conta própria ou ajustar os fluxos de trabalho dinamicamente com base nos resultados. Como resultado, eles funcionaram bem para perguntas e respostas mais simples ou fluxos de trabalho predefinidos, mas tiveram dificuldades com tarefas dinâmicas, mais complexas e reais que exigem planejamento, uso de ferramentas externas e tomada de decisões ao longo do caminho.

Os sistemas de IA baseados em agentes mudam da geração passiva de conteúdo para um comportamento autônomo e orientado por objetivos. Desenvolvidos por large language models (LLMs) e aprimorados com memória, planejamento e uso de ferramentas, esses sistemas podem dividir tarefas complexas em etapas menores, raciocinar em cada etapa e realizar ações em tempo real, como chamar APIs, executar ferramentas ou interagir com dados ativos. Ao referenciar o LLM em um ciclo de controle que gerencia o contexto, a memória e a tomada de decisões, esses sistemas podem escolher as ferramentas certas, adaptar fluxos de trabalho e integrar-se profundamente aos ambientes corporativos, com casos de uso que vão desde reservas de viagens e análise financeira até automação de DevOps e depuração de código. Isso é chamado de loop agente. Nesse sistema, o agente depende da saída de raciocínio do LLM para executar ferramentas, capturar resultados de ferramentas e fornecer esses resultados ao LLM como contexto atualizado (conforme mostrado no diagrama a seguir). Isso acontece em um loop até que o LLM instrua o agente a retornar a saída final ao chamador.

Embora o agentic loop seja uma abordagem leve para estruturar esses sistemas, outros paradigmas de fluxo de controle, como gráfico, enxame e fluxos de trabalho, também estão disponíveis em estruturas de código aberto como o LangGraph.

Apresentando o Strands Agents SDK

O Strands Agents SDK é uma estrutura que prioriza o código para criar agentes de IA prontos para produção com o mínimo de boilerplate. Ele utiliza o sistema de loop agêntico mencionado acima e abstrai desafios comuns, como gerenciamento de memória, integração de ferramentas e raciocínio em várias etapas, em uma estrutura Python leve e modular. O Strands SDK lida com o estado, a orquestração de ferramentas e o raciocínio em várias etapas para que os agentes possam se lembrar de conversas anteriores, chamar APIs externas, aplicar regras de negócios e se adaptar às mudanças nas entradas. Isso permite que você se concentre na lógica de negócios do aplicativo.

Como os agentes criados com o Strands SDK são essencialmente aplicativos Python, eles são portáteis e podem ser executados em diferentes opções de computação, como o Bedrock AgentCore Runtime, funções Lambda, tarefas (tasks / containers) do ECS ou até mesmo localmente. Isso faz do Strands Agents SDK uma base poderosa para a criação de sistemas de IA escaláveis e orientados por objetivos. As seções a seguir pressupõem que você esteja executando seus agentes de IA criados com o SDK Strands Agents em funções do Lambda.

Criando seu primeiro agente de IA Serverless

Imagine que você esteja criando um assistente de viagens corporativas com inteligência artificial na AWS e tenha os seguintes requisitos técnicos:

Defina os prompts do sistema, a memória e o modelo que você deseja usar
Integre ferramentas para chamadas de API, lógica de negócios e bases de conhecimento
Garanta a autenticação e a observabilidade

O SDK Strands gerencia o trabalho pesado, permitindo que você se concentre na construção de agentes inteligentes e responsivos com overhead mínimo. O trecho de código a seguir cria um agente simples, de acordo com sua configuração.

from strands import Agent

agent = Agent(
    system_prompt=
      """You're a travel assistant that helps 
         employees book business trips 
         according to policy.""",
    model=my_model,
    tools=[get_policies, get_hotels, get_cars, book_travel]
)

response = agent("Book me a flight to NYC next Monday.")

É isso mesmo. Seu agente agora tem personalidade, memória e capacidade de usar ferramentas externas. A classe Agent no SDK Strands abstrai a lógica agêntica, como manter o histórico de conversas, lidar com interações de LLM, orquestrar ferramentas e fontes externas de conhecimento e executar todo o ciclo agente.

Gerenciamento do estado da sessão

O gerenciamento do estado da sessão é fundamental para fluxos de trabalho com agentes. Ele permite que os agentes rastreiem as metas em todas as interações, possibilitando conversas coerentes, mantendo o contexto e fornecendo experiências personalizadas. Sem o gerenciamento do estado, cada solicitação é tratada isoladamente, impossibilitando que o agente faça referência ao contexto anterior ou acompanhe as tarefas em andamento. Em ambientes de nuvem, nos quais os aplicativos precisam ser escaláveis e sem estado, a solução é externalizar o estado da sessão para um armazenamento persistente, como o Amazon Simple Storage Service (Amazon S3). Isso permite que qualquer instância do agente reconstrua o histórico de conversas sob demanda, oferecendo uma experiência de usuário perfeita e estável, ao mesmo tempo em que mantém o próprio aplicativo agente sem estado para escalabilidade e resiliência.

Agentes de IA criados com Strands armazenam o histórico de conversas na propriedade agent.messages (consulte a documentação). Para oferecer suporte a ambientes computacionais sem estado, você pode externalizar o estado do agente, persistindo-o após cada interação e restaurando-o antes da próxima. Isso preserva a continuidade entre as invocações e, ao mesmo tempo, mantém suas instâncias de agente sem estado. Em aplicativos agentes com reconhecimento de usuário, você deseja manter o estado de cada usuário, normalmente associado à ID exclusiva do usuário. O exemplo a seguir ilustra como você pode fazer isso com a classe S3SessionManager integrada ao executar seu agente em um ambiente sem estado, como uma função Lambda:

session_manager = S3SessionManager(
        session_id=f"session_for_user_{user.id}",
        bucket=SESSION_STORE_BUCKET_NAME,
        prefix="agent_sessions"
    )

    agent = Agent(
        session_manager=session_manager
    )

Ao usar o Bedrock AgentCore, use a primitiva de memória AgentCore totalmente gerenciada e Serverless para gerenciar sessões e memória de longo prazo. Ele fornece contexto relevante aos modelos e, ao mesmo tempo, ajuda os agentes a aprender com as interações passadas. Você pode fazer com que o gerenciador de sessões do Strands funcione com a memória AgentCore semelhante ao S3SessionManager.

Autenticação e autorização

Para que os agentes corporativos de IA operem com segurança, eles precisam saber quem é o usuário e o que eles têm permissão para fazer. Isso vai além da validação básica de identidade — os agentes de IA geralmente agem em nome dos usuários, portanto, talvez precisem aplicar controles de acesso baseados em funções, apoiar a auditoria e cumprir as políticas corporativas.

Serviços da AWS, como Amazon Cognito, Amazon Identity and Access Management (IAM) e Amazon API Gateway, fornecem uma base sólida para autenticação e autorização. Por exemplo, você pode usar o Cognito para autenticar usuários por meio de grupos de usuários ou provedores de identidade federados, combinados com o API Gateway e o autorizador Lambda para validar as permissões de acesso do usuário antes de encaminhar as solicitações ao agente, conforme mostrado no diagrama anterior. As políticas do IAM definem o que o agente tem permissão para fazer. Depois que o usuário é autenticado e autorizado, o agente pode extrair o contexto de identidade, por exemplo, de um JSON Web Token (JWT), para personalizar solicitações, aplicar regras ou restringir ações dinamicamente.

O trecho de código a seguir ilustra a recuperação da identidade do usuário a partir do cabeçalho de autorização e sua transmissão para um agente:

def handler(event: dict, ctx):
    user_id = extract_user_id(event["headers"]["Authorization"])
    user_prompt: dict = json.loads(event["body"])["prompt"]
    agent_response = agent.prompt(user_id, user_prompt)
  
    return {
        "statusCode": 200,
        "body": json.dumps({"text": agent_response.text})
    }

O contexto de identidade pode se tornar parte do ciclo de execução do agente. Um agente pode verificar o departamento do usuário antes de reservar uma viagem ou restringir o acesso a ferramentas confidenciais, a menos que o usuário tenha as permissões apropriadas. Ao integrar a autenticação antecipada, você não apenas aprimora a segurança, mas também desbloqueia recursos avançados de personalização e auditoria que tornam os agentes prontos para a empresa desde o primeiro dia.

Ao usar o Bedrock AgentCore, o AgentCore Identity primitive permite que seus agentes de IA acessem com segurança os serviços da AWS e ferramentas de terceiros em nome dos usuários ou como eles mesmos, com o consentimento pré-autorizado do usuário. Ele fornece provedores gerenciados compatíveis com OAuth 2.0 para autenticação de entrada e saída. Durante a fase de pré-visualização, o AgentCore Identity oferece suporte a provedores de identidade como Amazon Cognito, Auth0 da Okta, Microsoft Entra ID, GitHub, Google, Salesforce e Slack. Consulte os exemplos para obter detalhes de implementação.

Construindo agentes Strands portáteis na AWS

O SDK do Strands Agents é independente de computação. Os agentes que você cria são aplicativos Python padrão, que podem ser executados em qualquer tipo de computação.

Para portabilidade e facilidade de manutenção, separe a lógica de negócios do seu agente da camada de interface. Ao fazer isso, você pode reutilizar o mesmo código de agente principal em todos os ambientes, seja invocado por meio de funções do API Gateway e Lambda, acessado por meio do Application Load Balancer e Amazon ECS, executado no AgentCore Runtime ou até mesmo executado localmente durante o desenvolvimento, conforme mostrado na figura a seguir.

Os trechos de código a seguir ilustram essa técnica.

Código do handler Lambda:

def handler(event: dict, ctx):
     user_id = extract_user_id(event)
     user_prompt = json.loads(event["body"])["prompt"]
     agent_response = call_agent(user_id, user_prompt)
     return {
          "statusCode":200,
          "body": json.dumps({
               "text": agent_response.mesage
          })
     }

Código AgentCore:

@app.entrypoint
def invoke(payload):
     user_id = extract_user_id(payload)
     user_prompt = payload.get("prompt")
     agent_response = call_agent(user_id, user_prompt)
     return {"result": agent_response.message)

Código do handler HTTP:

@app.post("/prompt")
async def prompt(request: Request, prompt_request: PromptRequest):
    user_id=extract_user_id(request)
    user_prompt = prompt_request.prompt
    agent_response = call_agent(user_id, user_prompt)
    return {"text": agent_response.message)

Para teste local:

if __name__ == "__main__":
     user_id="local-testing-user"
     user_prompt="book me a trip to NYC"
     agent_response = call_agent(user_id, user_prompt)
     return agent_response.message

Código do agente:

def call_agent(user_id, user_prompt):
     agent = Agent(
          system_prompt="You’re a travel agent…",
          model=my_model,
          session_manager = my_session_manager,    
      )
     agent_response = agent(user_prompt)
     return agent_response

Estendendo a funcionalidade do agente com ferramentas

Um ponto forte dos sistemas agentes é sua capacidade de invocar ferramentas que realizam ações ou recuperam dados em tempo real, permitindo que os agentes interajam com o mundo exterior, não apenas gerem texto. O SDK do Strands Agents inclui ferramentas integradas e permite que você defina suas próprias ferramentas personalizadas, como funções Python em processo ou ferramentas externas acessíveis por HTTP usando o Model Context Protocol (MCP). Essas ferramentas podem buscar dados, chamar APIs ou acionar fluxos de trabalho e podem ser registradas para o agente raciocinar e usar durante a execução.

O trecho a seguir ilustra a criação de uma ferramenta em andamento. Consulte a documentação para obter mais exemplos.

from strands import tool 

@tool
def get_weather(city: str) -> str:
    weather = call_weather_api(city)
    return f"The current weather in {city} is {weather}"

Integração com servidores MCP remotos

O Model Context Protocol (MCP) é um padrão aberto que separa agentes de ferramentas usando um modelo cliente-servidor. Em vez de incorporar a lógica da ferramenta diretamente no agente, seu agente se torna um cliente MCP que se conecta a um ou mais servidores MCP — cada um expondo ferramentas, recursos e solicitações reutilizáveis.

A execução de servidores MCP remotos é especialmente valiosa quando as ferramentas abrangem vários domínios de negócios ou são fornecidas por fornecedores terceirizados, assim como os microsserviços separam as responsabilidades entre equipes e sistemas. Essa separação permite que cada equipe de domínio gerencie suas próprias ferramentas de forma independente, ao mesmo tempo em que expõe uma interface consistente e padronizada aos agentes. Ele também permite a reutilização, o controle de versões e a governança centralizada sem acoplar fortemente a lógica ao próprio agente. Ao dissociar as ferramentas dos agentes, o MCP libera a capacidade de composição, a escalabilidade e o crescimento do ecossistema a longo prazo.

O trecho a seguir ilustra a configuração de um cliente MCP para se conectar a um servidor MCP remoto, recuperando a lista de ferramentas e integrando essas ferramentas a um agente.

mcp_client = MCPClient(lambda: streamablehttp_client(
    url=mcp_endpoint,
    headers={"Authorization": f"Bearer {token}"},
))

with mcp_client:
  tools = mcp_client.list_tools_sync()
  agent = Agent(tools=tools)

Ao usar o Bedrock AgentCore, você pode operar o MCP em grande escala por meio do AgentCore Gateway. Ele fornece uma maneira fácil e segura para os desenvolvedores criarem, implantarem, descobrirem e se conectarem a ferramentas remotas, como as descritas acima, em grande escala. Com o AgentCore Gateway, os desenvolvedores podem converter APIs, funções Lambda e serviços existentes em ferramentas compatíveis com o Model Context Protocol (MCP) e disponibilizá-las aos agentes por meio de endpoints do Gateway com apenas algumas linhas de código.

Monitoramento e observabilidade

A observabilidade é essencial ao executar agentes de IA. Além das métricas tradicionais, como tempo de atividade e latência, os sistemas agentes introduzem novas dimensões de telemetria, como latência de LLM, consumo de tokens e ciclos de raciocínio de rastreamento. Essas novas métricas são essenciais para entender o desempenho e o custo de seus sistemas agentes.

Ao implantar agentes usando serviços da AWS, como Bedrock AgentCore, Lambda ou ECS, você herda os recursos de observabilidade incorporados, como a integração perfeita com o Amazon CloudWatch para métricas, logs e rastreamento distribuído. Isso simplifica o rastreamento de contagens de invocações, erros, duração da solicitação e simultaneidade, conforme mostrado na figura a seguir — essencial para operar aplicativos agentes confiáveis e escaláveis.

Além disso, o SDK do Strands Agents fornece recursos integrados de observabilidade de agentes. Ele usa o OpenTelemetry (OTEL) para rastrear automaticamente cada interação do agente, incluindo períodos para chamadas LLM, uso de ferramentas e atualizações de contexto. Ele também exporta métricas detalhadas, como contagens de tokens, runtimes de ferramentas e durações do ciclo de decisão. Essas métricas podem ser enviadas para qualquer backend compatível com o Otel, oferecendo visibilidade profunda e em tempo real de como seus agentes raciocinam, agem e se adaptam. O trecho a seguir mostra métricas de uso de tokens incorporadas:

{
  "accumulated_usage": {
    "inputTokens": 1539,
    "outputTokens": 122,
    "totalTokens": 1661
  },
  "average_cycle_time": 0.881234884262085,
  "total_cycles": 2,
  "total_duration": 1.881234884262085,
  ... redacted ...
}

Saiba mais sobre observabilidade e avaliação dos agentes Strands neste código de exemplo.

Ao usar o Bedrock AgentCore, a primitiva AgentCore Observability ajuda você a registrar e capturar métricas e rastreabilidade de outras primitivas do AgentCore, como tempo de execução, memória e gateway, conforme descrito neste tutorial.

Considerações de segurança

Você deve criar camadas seguras de comunicação e controle de acesso implantando agentes de IA que se integrem a servidores MCP remotos. Todas as interações cliente-servidor devem ser criptografadas usando TLS, de preferência com TLS mútuo para autenticação bidirecional. O acesso às ferramentas deve ser validado por meio de verificações de autorização com permissões refinadas para impor o acesso com privilégios mínimos. A implantação de servidores MCP por trás de um API Gateway fornece camadas de segurança adicionais, como proteção contra DDoS, WAF e autenticação centralizada. Use os recursos de logging do API Gateway para capturar a identidade do chamador e os resultados da execução. O uso de repositórios MCP confiáveis e com controle de versão ajuda a proteger contra ataques à cadeia de suprimentos e garante uma governança consistente das ferramentas em todas as equipes. Protocolos como o MCP estão evoluindo rapidamente. Você deve sempre usar as versões mais recentes para minimizar possíveis riscos de vulnerabilidades de segurança.

Além disso, você deve aproveitar as melhores práticas de segurança descritas no pilar de segurança do AWS Well-Architected Framework, como impor um escopo estrito de funções do IAM, integrar-se com provedores de identidade para o contexto do usuário, criptografar todos os dados em trânsito e em repouso e usar VPC endpoints e PrivateLink para limitar a exposição da rede. Para se proteger contra ataques de injeção imediata, higienize as entradas e garanta a manutenção de registros de auditoria abrangentes para conformidade e governança.

Projeto de exemplo

Siga as instruções neste repositório do GitHub para implantar um projeto de exemplo, implementando as práticas descritas nesta postagem usando a computação Serverless da AWS. O repositório inclui um agente de viagens implementado com o SDK do Strands Agents e um servidor MCP remoto, ambos executados como funções Lambda.

Conclusão

A IA agêntica vai além das simples interações de resposta rápida para permitir fluxos de trabalho dinâmicos e orientados por metas. Nesta postagem, você aprendeu a criar agentes escaláveis e prontos para produção na AWS usando o SDK Strands Agents e serviços Serverless, como Lambda e Amazon ECS.

Ao externalizar o estado, integrar a autenticação e adicionar observabilidade, os agentes podem operar com segurança e em grande escala. Com o suporte para ferramentas remotas e em processo por meio do MCP, você pode separar claramente as responsabilidades e criar sistemas compostos e prontos para uso corporativo. Você pode combinar esses padrões para fornecer agentes de IA inteligentes e adaptáveis que se encaixam naturalmente nas arquiteturas modernas de nuvem e orientadas por eventos.

Recursos úteis

Para saber mais sobre arquiteturas Serverless, consulte Serverless Land.

Este conteúdo foi traduzido da postagem original do blog, que pode ser encontrada aqui.

Biografia dos Autores

	Anton Aleksandrov, Principal SSA, Serverless – ISV
	Dhiraj Mahapatro, Principal SSA, Amazon Bedrock

Biografia do Tradutor

Rodrigo Peres é Arquiteto de Soluções na AWS, com mais de 20 anos de experiência trabalhando com arquitetura de soluções, desenvolvimento de sistemas e modernização de sistemas legados.

Biografia do Revisor

Daniel Abib é arquiteto de soluções sênior na AWS, com mais de 25 anos trabalhando com gerenciamento de projetos, arquiteturas de soluções escaláveis, desenvolvimento de sistemas e CI/CD, microsserviços, arquitetura Serverless & Containers e segurança. Ele trabalha apoiando clientes corporativos, ajudando-os em sua jornada para a nuvem.

https://www.linkedin.com/in/danielabib/

O blog da AWS