Progettare architetture AWS con MCP Server e Strands Agents

Nel panorama in rapida evoluzione dell'architettura cloud e dello sviluppo basato sull'AI, due tecnologie stanno rivoluzionando il modo in cui costruiamo e rilasciamo soluzioni AWS: gli MCP server (Model Context Protocol) e gli Strands agents.

Gli MCP server offrono un modo standardizzato per collegare i Large Language Model (LLM) a fonti di dati e strumenti esterni. Funzionano da ponte tra i modelli AI e i diversi servizi, abilitando un'integrazione fluida con documentazione, API e risorse cloud. In ambito AWS, gli MCP server forniscono accesso diretto alla documentazione AWS, alle API dei servizi e agli strumenti di progettazione architetturale.

Gli Strands agents sono framework di orchestrazione intelligente che sfruttano gli LLM per automatizzare workflow complessi. Sono in grado di ragionare sui task, prendere decisioni ed eseguire processi multi-step con un intervento umano minimo. Combinati con gli MCP server, gli Strands agents diventano strumenti estremamente potenti per l'architettura cloud e l'automazione.

Questa combinazione segna un netto passo avanti rispetto agli approcci tradizionali allo sviluppo degli agent. Invece di scrivere codice prolisso e complesso per gestire chiamate API, error handling e orchestrazione dei workflow, oggi gli sviluppatori possono descrivere le proprie intenzioni in linguaggio naturale e lasciare che siano gli agent intelligenti a occuparsi dei dettagli implementativi. È un cambio di passo che riduce drasticamente i tempi di sviluppo e rende l'architettura cloud accessibile a una platea di sviluppatori molto più ampia.

Di seguito un esempio di diagramma architetturale di un sito web che usa AWS Lambda per un sito statico ospitato su S3, generato combinando MCP server 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"

Vediamo il codice utilizzato per generare il diagramma qui sopra. Mostra le potenzialità degli MCP server combinati con gli Strands agents per la generazione di architetture 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"
    )

Inizializzazione del client MCP:

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

Questa porzione di codice crea un client MCP che si collega al server ufficiale della documentazione AWS. Il comando uvx recupera ed esegue dinamicamente l'ultima versione dell'MCP server della documentazione AWS, garantendo l'accesso costante alla documentazione più aggiornata.

Client per la generazione dei diagrammi:

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

Allo stesso modo, viene creato un client per l'MCP server di generazione dei diagrammi AWS, in grado di produrre rappresentazioni visive delle architetture AWS in modo programmatico.

Configurazione del modello:

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

Questo blocco configura l'LLM sottostante usando il modello Claude 3.5 Haiku di AWS Bedrock. Una temperature di 0.7 garantisce un buon equilibrio tra creatività e coerenza nelle decisioni architetturali. Sebbene gli Strands agents si colleghino di default a Bedrock, è possibile utilizzare diversi provider di terze parti come Gemini, Anthropic e OpenAI.

Orchestrazione dell'agent:

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)

È qui che entrano in gioco gli Strands agents. L'agent rileva automaticamente tutti i tool disponibili da entrambi gli MCP server e li integra in modo trasparente. Il system prompt definisce il ruolo dell'agent come AWS Solutions Architect, fornendogli il contesto necessario per prendere decisioni architetturali consapevoli.

Esecuzione in linguaggio naturale:

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"
)

Una sola riga di codice basta a dimostrare la potenza dell'approccio. Invece di scrivere codice complesso per interrogare le API della documentazione, fare il parsing delle risposte e generare diagrammi, ci limitiamo a descrivere ciò che vogliamo in linguaggio naturale. È l'agent a occuparsi di tutta la complessità sottostante.

Lo sviluppo tradizionale degli agent richiede una notevole quantità di codice boilerplate in diverse aree critiche:

Integrazione manuale delle API: di norma gli sviluppatori dedicano molto tempo a scrivere client HTTP, gestire l'autenticazione, fare il parsing delle risposte e governare i rate limit per ciascun servizio da integrare.

Error handling e retry logic: gli agent affidabili richiedono una sofisticata gestione degli errori, exponential backoff, circuit breaker e meccanismi di retry per garantire un funzionamento robusto.

Orchestrazione dei workflow: coordinare processi multi-step richiede una complessa gestione dello stato, branching condizionali e logiche di scheduling delle attività.

Discovery e gestione dei tool: gli approcci tradizionali costringono a codificare staticamente i tool disponibili e le loro interfacce, rendendo il sistema rigido e difficile da estendere.

L'approccio Strands + MCP, al contrario, offre diversi vantaggi chiave:

Meno boilerplate: il framework si occupa di tutti gli aspetti infrastrutturali di basso livello, lasciando agli sviluppatori la libertà di concentrarsi su business logic e decisioni architetturali.

Discovery dinamica dei tool: gli MCP server pubblicano dinamicamente le proprie capability e gli Strands agents possono individuare e utilizzare nuovi tool senza alcuna modifica al codice.

Interfaccia in linguaggio naturale: invece di scrivere codice procedurale, gli sviluppatori descrivono le proprie intenzioni in linguaggio naturale, rendendo il sistema più accessibile e manutenibile.

Affidabilità integrata: il framework include nativamente una solida gestione degli errori, retry logic e meccanismi di recovery.

Modularità e riusabilità: gli MCP server possono essere condivisi tra progetti e team diversi, favorendo il riuso del codice e la coerenza.

Molteplici opzioni di deployment: gli Strands agents possono essere distribuiti su Lambda, ECS, EKS o istanze EC2.

Questo approccio è in linea con i moderni principi di progettazione cloud-native e serverless: configurazione dichiarativa, scaling automatico e infrastruttura gestita.

Per eseguire lo script mcp_arch_diagram.py è necessario installare i seguenti pacchetti Python:

pip install mcp strands boto3 anthropic

Dettaglio dei pacchetti:

• mcp: implementazione core del Model Context Protocol
• strands: il framework di orchestrazione degli agent
• boto3: AWS SDK per Python (necessario per l'integrazione con Bedrock)
• anthropic: libreria client Python di Anthropic

Requisiti aggiuntivi:

• Verificare di avere uvx installato a livello globale per l'esecuzione dinamica dei pacchetti
• Configurare le credenziali AWS per l'accesso a Bedrock
• Impostare le opportune autorizzazioni IAM per l'utilizzo di AWS Bedrock

La flessibilità degli MCP server uniti agli Strands agents va ben oltre i siti web statici. Ecco alcune altre architetture AWS che questo approccio è in grado di generare:

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

Per generare il diagramma di un'architettura API serverless con autenticazione adeguata e persistenza dei dati.

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

Utile per ottenere il diagramma di workflow di elaborazione dati scalabili che reagiscono a eventi in tempo reale.

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

Per generare il diagramma di architetture multi-tier tradizionali con alta disponibilità e prestazioni ottimizzate.

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

Per costruire il diagramma di workflow di machine learning end-to-end con una corretta gestione dei dati e del monitoring.

Ognuno di questi esempi mostra come una descrizione in linguaggio naturale possa tradursi in architetture AWS complete senza dover scrivere codice infrastrutturale complesso.

Abbiamo visto come creare diagrammi architetturali per nuovi workloads, ma come si individuano le cause profonde di problemi e inefficienze nei workloads già in produzione? Cloud Diagrams visualizza la sua impronta cloud quasi in tempo reale, mette in relazione i diversi servizi e suggerisce insight concreti e azionabili. Il risultato: meno disservizi, meno tempo speso in troubleshooting e costi operativi più bassi.