
MCP na AWS: como conectar agentes de IA a ferramentas sem dar poder demais ao LLM
Entenda o Model Context Protocol, o que mudou no MCP 2026-07-28 e como Amazon Bedrock AgentCore Gateway, IAM, Policy e observabilidade podem ajudar a transformar agentes de IA em sistemas realmente utilizáveis em produção.
Series: Projetos de IA (2 articles)
- 2MCP na AWS: como conectar agentes de IA a ferramentas sem dar poder demais ao LLM This article
O chatbot respondeu. O agente executou.
Durante algum tempo, boa parte das aplicações de IA generativa seguia um fluxo relativamente simples:
Usuário | vPrompt | vLLM | vRespostaO modelo recebia uma pergunta e devolvia texto.
Quando começamos a falar de AI Agents, a situação muda.
Agora o modelo pode decidir consultar uma API, buscar informações em um banco de dados, abrir um ticket, consultar documentação, disparar uma automação ou executar alguma outra ferramenta.
O fluxo começa a se parecer mais com isto:
Usuário | vAgente de IA | +------> ferramenta A | +------> ferramenta B | +------> API interna | +------> dados corporativos | vResposta ou açãoE é exatamente aqui que surge uma pergunta muito mais importante do que:
“Qual modelo devo usar?”
A pergunta passa a ser:
A que esse agente realmente deveria ter acesso?
Porque um modelo que apenas responde incorretamente é um problema.
Um modelo que responde incorretamente e possui permissão para executar ações pode ser um problema muito maior.
MCP entrou justamente nessa conversa
MCP significa Model Context Protocol.
Em termos simples, ele define uma maneira padronizada para aplicações de IA descobrirem e utilizarem recursos externos, como ferramentas, dados e serviços.
A ideia é reduzir integrações construídas especificamente para cada combinação entre agente e sistema.
Sem um protocolo comum, podemos acabar com algo assim:
Agente A ------ integração customizada ------ SalesforceAgente A ------ integração customizada ------ GitHubAgente A ------ integração customizada ------ banco
Agente B ------ outra integração ------------ SalesforceAgente B ------ outra integração ------------ GitHubAgente B ------ outra integração ------------ bancoCom MCP, podemos introduzir uma interface padronizada:
+-----------------+ | MCP Server | +-----------------+ / | \ / | \ CRM GitHub Banco \ | / \ | / +----------------+ | MCP-compatible | | agents | +----------------+Isso ajuda a desacoplar o agente da implementação de cada sistema.
Mas existe uma distinção importante:
MCP padroniza a interação. Ele não elimina a necessidade de segurança.
E talvez essa seja a parte mais importante deste artigo.
O MCP mudou bastante em 2026
Em 28 de julho de 2026 foi publicada uma nova revisão importante da especificação MCP.
Uma das maiores mudanças foi a adoção de um núcleo stateless.
Nas versões anteriores, clientes e servidores dependiam mais do conceito de sessão e de uma etapa inicial de negociação. Na revisão
2026-07-28 , cada requisição passa a carregar as informações necessárias para ser processada de maneira mais independente. Isso facilita balanceamento de carga, escalabilidade e roteamento utilizando infraestrutura HTTP tradicional. ( Model Context Protocol Blog )Em outras palavras, a arquitetura fica mais próxima de algo que equipes de cloud já conhecem bem:
+----------------+ | Load Balancer | +-------+--------+ | +------------+------------+ | | | v v v MCP #1 MCP #2 MCP #3A requisição não precisa necessariamente encontrar a mesma instância que atendeu uma chamada anterior.
Para ambientes distribuídos, isso é uma mudança significativa.
A nova especificação também introduziu melhorias relacionadas a cache, roteamento por headers, extensões e endurecimento do processo de autorização. ( Model Context Protocol Blog )
E a AWS já suporta essa revisão
O Amazon Bedrock AgentCore Gateway suporta diferentes revisões de MCP, incluindo
2026-07-28 .Na revisão mais recente, o Gateway trabalha com o modelo stateless da especificação, enquanto mantém compatibilidade com revisões anteriores que utilizam o processo tradicional de inicialização. ( Documentação AWS )
Isso é importante porque, em ambientes reais, dificilmente todos os clientes e servidores serão atualizados simultaneamente.
Mas afinal, o que é o AgentCore Gateway?
Imagine que uma organização possui vinte agentes.
Cada um deles precisa acessar APIs, funções Lambda, sistemas internos e servidores MCP.
Conectar tudo diretamente pode produzir rapidamente algo difícil de governar:
Agent 1 ---> API AAgent 1 ---> API BAgent 1 ---> API C
Agent 2 ---> API AAgent 2 ---> Lambda XAgent 2 ---> MCP Y
Agent 3 ---> API BAgent 3 ---> MCP ZO Amazon Bedrock AgentCore Gateway pode funcionar como uma camada intermediária para disponibilizar ferramentas aos agentes através de MCP.
Ele pode representar APIs e funções Lambda como ferramentas compatíveis com MCP e também integrar targets MCP existentes. ( Documentação AWS )
A arquitetura passa a ficar mais próxima disto:
Usuário | v +-------------+ | AI Agent | +------+------+ | | MCP v +------------------------+ | AgentCore Gateway | +----------+-------------+ | +------------+-------------+ | | | v v v Lambda APIs MCP ServersEsse desenho traz uma vantagem arquitetural importante:
o agente não precisa conhecer diretamente todos os sistemas existentes.
Mas ainda falta resolver a questão mais difícil.
Quem pode chamar o quê?
Um agente não deveria ganhar as permissões do universo
Existe uma tentação perigosa quando começamos a desenvolver agentes.
Durante o protótipo, algo não funciona.
Então adicionamos mais uma permissão.
Ainda não funciona.
Adicionamos outra.
Até que aparece uma policy parecida com:
Action: *Resource: *Funciona?
Provavelmente.
É uma boa ideia?
Quase nunca.
A AWS recomenda que agentes sejam tratados sob o mesmo princípio de least privilege aplicado a sistemas tradicionais. O ponto torna-se ainda mais relevante porque agentes tomam decisões dinamicamente e podem executar ações em velocidade de máquina. ( Amazon Web Services )
Um princípio que considero útil é:
Se o agente consegue executar uma ação com as credenciais fornecidas, assuma que em algum momento ele poderá tentar executá-la.
Não significa que o agente necessariamente fará isso.
Significa que a segurança não deveria depender exclusivamente da expectativa de que o modelo tomará sempre a decisão correta.
LLM não deveria ser seu mecanismo de autorização
Considere este prompt:
Nunca exclua arquivos do bucket de produção.Isso é uma instrução útil para o modelo.
Mas não é um controle de segurança equivalente a:
o agente não possui s3:DeleteObjectA primeira abordagem depende do comportamento probabilístico do modelo.
A segunda é um limite determinístico aplicado pela infraestrutura.
Esse contraste é central para arquiteturas agentic.
A AWS vem reforçando justamente a ideia de colocar controles determinísticos fora do modelo, complementando guardrails e instruções dentro do processo de IA. ( Amazon Web Services )
Em outras palavras:
Prompt:"não faça isso"
≠
IAM:"você não pode fazer isso"Os dois podem trabalhar juntos.
Mas não desempenham o mesmo papel.
Segurança de agentes precisa acontecer em camadas
Uma arquitetura mais madura pode ser vista como diferentes fronteiras.
Usuário | autenticação | v +-------------+ | Agente | +------+------+ | autorização | v +-------------------+ | AgentCore Gateway | +---------+---------+ | Policy | +--------------+---------------+ | | | v v v Tool A Tool B Tool C | | | +--------------+---------------+ | v AWS IAM | v AWS resourcesCada camada responde a uma pergunta diferente.
Autenticação: quem está fazendo a solicitação?
Autorização: essa identidade pode executar essa ação?
Tool governance: quais ferramentas o agente deveria enxergar?
IAM: quais operações AWS são realmente permitidas?
Observabilidade: o que o agente efetivamente fez?
Essa separação é extremamente importante.
AgentCore Policy: controlar a chamada de ferramentas
O Amazon Bedrock AgentCore possui uma camada de Policy que pode ser associada ao Gateway.
As políticas utilizam Cedar para expressar regras de autorização sobre chamadas de ferramentas. O mecanismo avalia quem está solicitando, qual ferramenta será chamada, qual recurso está envolvido e quais condições devem ser satisfeitas. ( Documentação AWS )
De forma conceitual, podemos imaginar algo como:
permitir:
usuário do departamento financeiro
executar:
consultar_faturas
somente quando:
empresa_id == empresa autorizadaE outra política poderia determinar:
negar:
transferência acima de determinado valor
sem aprovação adicionalIsso é muito diferente de escrever no system prompt:
"Não faça transferências grandes."Novamente, uma instrução influencia comportamento.
Uma policy delimita autorização.
Default deny é seu amigo
O mecanismo de Policy do AgentCore utiliza uma lógica em que a ausência de permissão resulta em negação, e regras explícitas de proibição prevalecem sobre permissões aplicáveis. ( Documentação AWS )
Esse modelo combina bem com agentes.
Começamos com:
não pode fazer nadae adicionamos somente aquilo que realmente é necessário.
Em vez de começar com:
pode fazer tudoe tentar descobrir posteriormente o que deveria ser removido.
O usuário também precisa viajar junto com a requisição
Há outro problema sutil.
Imagine um agente corporativo compartilhado por dois departamentos:
mesmo agente | +------+------+ | | Sales FinanceSe o agente possui acesso a todos os dados, como garantir que um usuário de Sales não veja documentos de Finance?
A solução não deveria ser simplesmente perguntar ao modelo:
"Esse usuário parece autorizado?"A AWS publicou recentemente padrões para propagar o contexto de autorização do usuário através do AgentCore, de modo que a infraestrutura e os sistemas downstream possam aplicar o controle de acesso correspondente. ( Amazon Web Services )
Essa é uma mudança importante de mentalidade:
o agente age em nome de alguém.
Portanto, precisamos preservar a identidade e o escopo daquele usuário durante a execução.
O problema do “agente administrador”
Considere este desenho:
Todos os usuários | v Agente | vIAM Role com acesso totalMesmo que cada pessoa tenha permissões diferentes na organização, o agente se torna uma espécie de superusuário compartilhado.
Agora considere:
Usuário | +--> identidade | vAgente | +--> contexto do usuário | vGateway / Policy / IAM | vSomente recursos autorizadosA segunda arquitetura mantém a autorização próxima à identidade real.
Esse detalhe pode separar uma boa demonstração de uma aplicação empresarial utilizável.
Prompt injection muda de gravidade quando existem ferramentas
Em um chatbot sem ferramentas, uma tentativa de prompt injection pode tentar fazer o modelo ignorar uma instrução.
Quando adicionamos ferramentas, o impacto potencial aumenta.
Agora uma entrada maliciosa pode tentar convencer o agente a:
- acessar dados que não deveria;
- executar uma ferramenta inadequada;
- fornecer argumentos perigosos;
- chamar APIs;
- modificar recursos;
- enviar informações para sistemas externos.
Isso não significa que devemos evitar agentes.
Significa que precisamos tratar tool use como uma fronteira de segurança.
A AWS destaca justamente que agentes possuem comportamento não determinístico, enquanto controles como IAM, políticas e restrições de ferramentas devem ser usados para impor limites determinísticos. ( Amazon Web Services )
MCP não substitui IAM
Esse ponto merece uma seção própria.
MCP pode definir como a ferramenta é descoberta e chamada.
Mas se essa ferramenta acessa AWS, ainda precisamos pensar nas permissões subjacentes.
Imagine:
Agent | vMCP Tool | vAmazon S3Podemos bloquear a ferramenta
delete_file .Ótimo.
Mas e se o mesmo runtime possui shell com credenciais AWS capazes de executar:
aws s3 rm ...Nesse caso, restringir somente a interface MCP não resolve completamente o problema.
A orientação de segurança da AWS destaca esse limite: least privilege sobre a role subjacente continua sendo fundamental, inclusive quando existem outros caminhos para acessar serviços AWS. ( Amazon Web Services )
Minha regra prática é:
a interface pode restringir comportamento; a identidade deve restringir capacidade.
Observabilidade não é opcional quando software começa a decidir
Em aplicações tradicionais, normalmente monitoramos:
CPUmemórialatênciaerrosrequestsAinda precisamos disso.
Mas agentes introduzem novas perguntas:
Qual ferramenta foi escolhida?
Por que determinado fluxo demorou tanto?
Quantas ferramentas foram chamadas?
Onde a execução falhou?
Qual usuário originou a ação?
Qual chamada foi negada?
Quanto tempo foi gasto em cada etapa?O AgentCore envia métricas para Amazon CloudWatch e pode fornecer logs, spans e traces para diferentes recursos do ecossistema, incluindo runtime, memory, gateway e ferramentas. ( Documentação AWS )
Isso permite sair de:
“O agente deu erro.”
para algo mais próximo de:
Sessão | +-- chamada do modelo | +-- tool selection | +-- gateway | +-- chamada da API | +-- resultado | +-- resposta finalEsse nível de visibilidade é essencial para produção.
E agora temos outro conceito importante: AgentCore Runtime
Se o Gateway resolve a exposição e governança das ferramentas, o AgentCore Runtime atua na execução de agentes.
A documentação atual descreve o Runtime como um ambiente serverless específico para executar e escalar agentes, com isolamento de sessão e suporte a diferentes frameworks, modelos e protocolos. Ele não exige que o agente tenha sido construído exclusivamente com uma única biblioteca ou mesmo que utilize somente modelos do Amazon Bedrock. ( Documentação AWS )
Isso permite arquiteturas como:
+----------------------+ | AgentCore Runtime | | |Usuário ----------> | Strands / LangGraph| | outro framework | +----------+-----------+ | v +----------------------+ | AgentCore Gateway | +----------+-----------+ | +-----------+-----------+ | | v v MCP Tools AWS APIsO framework continua responsável pela lógica do agente.
AgentCore fornece componentes operacionais em torno dessa lógica.
Então eu preciso de AgentCore para usar MCP?
Não.
MCP é um protocolo aberto.
É possível executar clientes e servidores MCP sem Amazon Bedrock AgentCore.
Também é possível usar outros frameworks e outras infraestruturas.
Esse é um ponto que vale deixar claro porque evita confundir tecnologia aberta com implementação de um fornecedor.
A pergunta mais útil é:
Em que momento um Gateway gerenciado começa a reduzir trabalho operacional para mim?
Em uma aplicação pequena, talvez não reduza.
Em uma organização com dezenas de ferramentas e diversos agentes, centralizar descoberta, autenticação, autorização, observabilidade e integração pode começar a fazer muito mais sentido.
Um desenho mínimo que eu usaria para produção
Se eu estivesse começando uma aplicação agentic hoje, meu desenho inicial seria próximo deste:
Usuário | v autenticação/OIDC | v +----------------------+ | AgentCore Runtime | | AI Agent | +----------+-----------+ | | MCP v +----------------------+ | AgentCore Gateway | +----------+-----------+ | AgentCore Policy | +-----------+-----------+ | | v v MCP Tool Lambda/API | | +-----------+-----------+ | IAM Role | v AWS servicesAo redor de tudo:
Amazon CloudWatchlogsmetricsspanstracesE eu acrescentaria quatro regras desde o primeiro commit:
1. Nenhuma role com "*" sem justificativa excepcional.
2. Ferramentas destrutivas separadas de ferramentas de leitura.
3. Identidade do usuário propagada sempre que houver dados com diferentes níveis de acesso.
4. Toda chamada relevante de ferramenta precisa ser auditável.Essas quatro decisões provavelmente evitariam muito retrabalho depois.
Read tools e write tools não são a mesma coisa
Existe outra estratégia simples que gosto bastante.
Não trate todas as ferramentas igualmente.
Por exemplo:
Grupo A — leitura
get_invoiceget_customersearch_documentationdescribe_instancelist_bucketse:
Grupo B — alteração
delete_invoiceupdate_customerterminate_instancedelete_objecttransfer_fundsO segundo grupo merece uma barreira maior.
Dependendo do caso, podemos exigir:
- autorização adicional;
- confirmação humana;
- limitação por valor;
- escopo de recurso;
- policy específica;
- identidade mais privilegiada;
- workflow de aprovação.
A autonomia pode ser gradual.
Um agente não precisa sair do primeiro deploy com permissão para modificar produção.
Autonomia deve ser conquistada
Um modelo interessante para agentes é pensar em níveis.
Nível 1 — somente leitura
consultarresumirexplicarNível 2 — sugerir ações
"Encontrei este problema.Deseja que eu execute a correção?"Nível 3 — executar ações reversíveis
criar ticketenviar rascunhoadicionar tagNível 4 — executar ações críticas
alterar infraestruturaremover recursosmovimentar valoresmodificar dados sensíveisQuanto maior o impacto potencial, maior deve ser a evidência de que o agente funciona corretamente e maiores devem ser os controles externos.
A AWS descreve abordagem semelhante ao defender que autonomia de agentes deve ser conquistada por meio de avaliação e controles apropriados, em vez de simplesmente ser concedida desde o início. ( Amazon Web Services )
O que o MCP 2026-07-28 realmente muda para quem constrói na AWS?
Para mim, existem quatro mudanças conceituais importantes.
1. MCP está amadurecendo como infraestrutura
A mudança para um núcleo stateless aproxima servidores MCP de padrões comuns de arquiteturas web escaláveis. ( Model Context Protocol Blog )
Isso reduz a distância entre:
"um plugin rodando no meu notebook"e:
"um serviço distribuído operado em produção"2. Gateway passa a ser uma peça estratégica
Quanto mais ferramentas existem, mais importante se torna ter um ponto onde possamos aplicar controle, identidade, observabilidade e governança.
3. Segurança precisa sair do prompt
System prompts continuam importantes.
Guardrails continuam importantes.
Mas identidade, autorização e privilégios precisam existir independentemente da obediência do modelo.
4. “Meu agente consegue fazer isso?” não é mais suficiente
Precisamos perguntar também:
Ele deveria conseguir?
Em nome de quem?
Em quais recursos?
Em quais condições?
Com qual trilha de auditoria?
E como posso impedir a ação quando ela não for permitida?Essas perguntas provavelmente serão mais importantes para a próxima geração de aplicações de IA do que escolher entre duas pequenas variações de prompt.
O erro mais fácil de cometer
A maior armadilha talvez seja pensar:
“Meu agente nunca faria isso.”
Em sistemas determinísticos já evitamos depender dessa lógica.
Em sistemas baseados em modelos probabilísticos, há ainda menos motivos para depender dela.
Prefiro construir assumindo:
o modelo pode escolher a ferramenta erradae garantir que:
a infraestrutura limite o dano possívelEssa abordagem não reduz a inteligência do agente.
Ela torna a autonomia sustentável.
Conclusão
MCP resolve um problema importante: criar uma linguagem comum para agentes interagirem com ferramentas e fontes de contexto.
A revisão
2026-07-28 mostra que o protocolo está evoluindo em direção a uma infraestrutura mais escalável e apropriada para ambientes distribuídos. ( Model Context Protocol Blog )Mas conectar uma ferramenta é apenas metade do problema.
A outra metade é decidir:
quem pode usá-la, em qual contexto, com quais argumentos e com quais limites.
É nessa parte que serviços e recursos como Amazon Bedrock AgentCore Gateway, AgentCore Policy, IAM e CloudWatch se tornam particularmente interessantes.
O futuro provavelmente terá muito mais agentes executando tarefas por nós.
Por isso, talvez a pergunta mais importante não seja:
“Como fazer meu agente executar mais coisas?”
Talvez seja:
“Como garantir que ele só consiga executar aquilo que deveria?”
E essa é uma pergunta que vale responder antes de colocar o agente em produção.
Referências
Para embasar tecnicamente o artigo, priorizei documentação oficial e fontes primárias: a especificação MCP mantém a revisão
2026-07-28 e descreve o novo núcleo stateless, roteamento e mudanças de autorização; a documentação da AWS confirma suporte dessa revisão pelo AgentCore Gateway; e os materiais de segurança da AWS reforçam least privilege e controles externos determinísticos para agentes. ( Model Context Protocol Blog ) Especificação e novidades do MCP 2026-07-28
Amazon Bedrock AgentCore — visão geral
AgentCore Gateway e MCP
AgentCore Policy — conceitos principais
Segurança de acesso AWS através de MCP
Princípios de segurança para sistemas agentic
Propagação de autorização de usuários no AgentCore
AWS Builder Center FAQ e diretrizes editoriais
Series: Projetos de IA (2 articles)
- 2MCP na AWS: como conectar agentes de IA a ferramentas sem dar poder demais ao LLM This article
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article