Construindo arquitetura AWS com MCP Servers e Strands Agents

No cenário em rápida transformação da arquitetura em nuvem e do desenvolvimento com IA, duas tecnologias estão revolucionando a forma como construímos e implantamos soluções na AWS: os Model Context Protocol (MCP) servers e os Strands agents.

Os MCP servers oferecem uma maneira padronizada de conectar Large Language Models (LLMs) a fontes de dados e ferramentas externas. Eles funcionam como pontes entre modelos de IA e diversos serviços, permitindo integração fluida com documentação, APIs e recursos de nuvem. No contexto da AWS, os MCP servers dão acesso direto à documentação da AWS, às APIs dos serviços e a ferramentas de arquitetura.

Já os Strands agents são frameworks de orquestração inteligentes que usam LLMs para automatizar fluxos de trabalho complexos. Eles raciocinam sobre tarefas, tomam decisões e executam processos de várias etapas com mínima intervenção humana. Combinados com MCP servers, os Strands agents se tornam ferramentas extremamente poderosas para arquitetura e automação em nuvem.

Essa combinação é um grande salto em relação às abordagens tradicionais de desenvolvimento de agentes. Em vez de escrever código verboso e complexo para lidar com chamadas de API, tratamento de erros e orquestração de workflows, agora basta descrever a intenção em linguagem natural e deixar que os agentes inteligentes resolvam os detalhes de implementação. Essa mudança reduz drasticamente o tempo de desenvolvimento e abre a arquitetura em nuvem para um público muito maior de desenvolvedores.

Veja um exemplo de diagrama de arquitetura de um site estático hospedado no S3 que usa AWS Lambda. Ele foi gerado combinando MCP servers e Strands agents.

Prompt: "Get the documentation for AWS Lambda then create a diagram of a website that uses AWS Lambda for a static website hosted on S3"

Vamos analisar o código usado para gerar o diagrama acima. Ele mostra todo o potencial dos MCP servers em conjunto com Strands agents para criar arquiteturas AWS:

from mcp import StdioServerParameters, stdio_client
from strands import Agent
from strands.models import BedrockModel
from strands.tools.mcp import MCPClient

aws_docs_client = MCPClient(
    lambda: stdio_client(
        StdioServerParameters(
            command="uvx", args=["awslabs.aws-documentation-mcp-server@latest"]
        )
    )
)
aws_diag_client = MCPClient(
    lambda: stdio_client(
        StdioServerParameters(
            command="uvx", args=["awslabs.aws-diagram-mcp-server@latest"]
        )
    )
)
bedrock_model = BedrockModel(
    model_id="us.anthropic.claude-3-5-haiku-20241022-v1:0",
    temperature=0.7,
)
SYSTEM_PROMPT = """
You are an expert AWS Certified Solutions Architect. Your role is to help customers understand best practices on building on AWS. You can query the AWS Documentation and generate diagrams. Make sure to tell the customer the full file path of the diagram.
"""
with aws_diag_client, aws_docs_client:
    all_tools = aws_diag_client.list_tools_sync() + aws_docs_client.list_tools_sync()
    agent = Agent(tools=all_tools, model=bedrock_model, system_prompt=SYSTEM_PROMPT)
    response = agent(
        "Get the documentation for AWS Lambda then create a diagram of a website that uses AWS Lambda for a static website hosted on S3"
    )

Inicialização do MCP Client:

aws_docs_client = MCPClient(
    lambda: stdio_client(
        StdioServerParameters(
            command="uvx", args=["awslabs.aws-documentation-mcp-server@latest"]
        )
    )
)

Esse trecho cria um MCP client que se conecta ao servidor oficial de documentação da AWS. O comando uvx baixa e executa dinamicamente a versão mais recente do MCP server de documentação, garantindo acesso sempre à documentação mais atualizada.

Client de geração de diagramas:

aws_diag_client = MCPClient(
    lambda: stdio_client(
        StdioServerParameters(
            command="uvx", args=["awslabs.aws-diagram-mcp-server@latest"]
        )
    )
)

De forma parecida, este trecho cria um client para o MCP server de geração de diagramas da AWS, capaz de produzir representações visuais de arquiteturas AWS de forma programática.

Configuração do modelo:

bedrock_model = BedrockModel(
    model_id="us.anthropic.claude-3-5-haiku-20241022-v1:0",
    temperature=0.7,
)

Aqui configuramos o LLM por trás de tudo, usando o modelo Claude 3.5 Haiku no AWS Bedrock. A temperatura de 0,7 traz um bom equilíbrio entre criatividade e consistência nas decisões de arquitetura. Embora os Strands agents se conectem ao Bedrock por padrão, dá para usar diversos provedores de terceiros, como Gemini, Anthropic e OpenAI.

Orquestração do agente:

with aws_diag_client, aws_docs_client:
    all_tools = aws_diag_client.list_tools_sync() + aws_docs_client.list_tools_sync()
    agent = Agent(tools=all_tools, model=bedrock_model, system_prompt=SYSTEM_PROMPT)

É aqui que os Strands agents entram em cena. O agente descobre automaticamente todas as ferramentas disponíveis nos dois MCP servers e as integra de forma fluida. O system prompt define o papel do agente como AWS Solutions Architect, dando o contexto necessário para tomar decisões de arquitetura inteligentes.

Execução em linguagem natural:

response = agent(
    "Get the documentation for AWS Lambda then create a diagram of a website that uses AWS Lambda for a static website hosted on S3"
)

Essa única linha mostra o poder da abordagem. Em vez de escrever código complexo para consultar APIs de documentação, processar respostas e gerar diagramas, basta descrever o que queremos em linguagem natural. O agente cuida de toda a complexidade nos bastidores.

O desenvolvimento tradicional de agentes exige bastante código boilerplate em várias frentes críticas:

Integração manual de APIs: normalmente os desenvolvedores gastam um tempão escrevendo clients HTTP, lidando com autenticação, processando respostas e administrando rate limits para cada serviço que querem integrar.

Tratamento de erros e lógica de retry: agentes robustos exigem tratamento sofisticado de erros, exponential backoff, circuit breakers e mecanismos de retry para uma operação confiável.

Orquestração de workflows: coordenar processos de várias etapas exige gerenciamento de estado complexo, ramificações condicionais e lógica de agendamento de tarefas.

Descoberta e gerenciamento de ferramentas: nas abordagens tradicionais, as ferramentas disponíveis e suas interfaces ficam fixadas no código, deixando o sistema rígido e difícil de estender.

Em contraste, a abordagem Strands + MCP traz vários benefícios importantes:

Menos boilerplate: o framework cuida de toda a infraestrutura de baixo nível, deixando os desenvolvedores livres para focar na lógica de negócio e nas decisões de arquitetura.

Descoberta dinâmica de ferramentas: os MCP servers anunciam suas capacidades dinamicamente, e os Strands agents conseguem descobrir e usar novas ferramentas sem alterações no código.

Interface em linguagem natural: em vez de escrever código procedural, os desenvolvedores descrevem suas intenções em linguagem natural, deixando o sistema mais acessível e fácil de manter.

Confiabilidade nativa: o framework já traz tratamento robusto de erros, lógica de retry e mecanismos de recuperação prontos para uso.

Modularidade e reuso: os MCP servers podem ser compartilhados entre projetos e equipes, promovendo reuso de código e consistência.

Diversas formas de implantação: os Strands agents podem rodar em Lambda, ECS, EKS ou instâncias EC2.

Essa abordagem se alinha aos princípios modernos de design cloud-native e serverless, com ênfase em configuração declarativa, escalabilidade automática e infraestrutura gerenciada.

Para rodar o script mcp_arch_diagram.py, você precisa instalar os seguintes pacotes Python:

pip install mcp strands boto3 anthropic

Detalhamento dos pacotes:

• mcp: implementação principal do Model Context Protocol
• strands: o framework de orquestração de agentes
• boto3: AWS SDK para Python (necessário para integrar com o Bedrock)
• anthropic: biblioteca client em Python da Anthropic

Requisitos adicionais:

• Tenha o uvx instalado globalmente para a execução dinâmica de pacotes
• Configure as credenciais da AWS para acessar o Bedrock
• Defina as permissões IAM apropriadas para usar o AWS Bedrock

A flexibilidade dos MCP servers com Strands agents vai muito além de sites estáticos. Veja a seguir outras arquiteturas AWS que essa abordagem é capaz de gerar:

response = agent(
    "Create a diagram for a RESTful API using API Gateway, Lambda functions, and DynamoDB with proper security using IAM roles"
)

Para gerar um diagrama de arquitetura de API serverless com autenticação adequada e persistência de dados.

response = agent(
    "Design an event-driven pipeline that processes files uploaded to S3, triggers Lambda functions via EventBridge, and stores results in RDS"
)

Útil para diagramar workflows escaláveis de processamento de dados que reagem a eventos em tempo real.

response = agent(
    "Create a diagram for a three-tier web application with ALB, EC2 instances in multiple AZs, RDS with read replicas, and ElastiCache"
)

Para diagramar arquiteturas tradicionais em múltiplas camadas, com alta disponibilidade e desempenho otimizado.

response = agent(
    "Generate a diagram for an ML pipeline using SageMaker for training, Lambda for inference, S3 for data storage, and CloudWatch for monitoring"
)

Para criar um diagrama de workflows completos de machine learning, com gerenciamento de dados e monitoramento adequados.

Cada um desses exemplos mostra como descrições em linguagem natural se transformam em arquiteturas AWS completas, sem precisar escrever código complexo de infraestrutura.

Vimos como criar diagramas de arquitetura para um novo workload, mas como descobrir a causa raiz de problemas e ineficiências no workload que você já tem em produção? O Cloud Diagrams visualiza seu cloud footprint praticamente em tempo real, conecta os pontos entre os diversos serviços e recomenda insights acionáveis. O resultado: menos indisponibilidades, menos esforço de troubleshooting e queda nos custos operacionais.