Concevoir une architecture AWS avec les serveurs MCP et les agents Strands

Dans un univers en pleine mutation où l'architecture cloud croise le développement piloté par l'IA, deux technologies puissantes redéfinissent la conception et le déploiement des solutions AWS : les serveurs Model Context Protocol (MCP) et les agents Strands.

Les serveurs MCP offrent une méthode standardisée pour relier les Large Language Models (LLM) à des sources de données et à des outils externes. Ils font office de passerelles entre les modèles d'IA et différents services, et permettent une intégration fluide avec la documentation, les API et les ressources cloud. Côté AWS, les serveurs MCP donnent un accès direct à la documentation, aux API des services et aux outils d'architecture.

Les agents Strands sont des frameworks d'orchestration intelligents qui s'appuient sur les LLM pour automatiser des workflows complexes. Ils raisonnent sur les tâches, prennent des décisions et exécutent des processus en plusieurs étapes avec une intervention humaine minimale. Combinés aux serveurs MCP, ils deviennent des outils redoutablement efficaces pour l'architecture cloud et l'automatisation.

Cette combinaison constitue une avancée majeure par rapport aux approches traditionnelles de développement d'agents. Plus besoin d'écrire du code verbeux et complexe pour gérer les appels d'API, les erreurs et l'orchestration des workflows : il suffit désormais de décrire ses intentions en langage naturel et de laisser les agents intelligents s'occuper des détails d'implémentation. Ce changement réduit considérablement les délais de développement et rend l'architecture cloud accessible à un public bien plus large de développeurs.

Voici un exemple de diagramme d'architecture pour un site web utilisant AWS Lambda et hébergé en statique sur S3. Il a été produit en combinant serveurs MCP et agents Strands.

Prompt : Récupère la documentation d'AWS Lambda puis crée un diagramme d'un site web qui utilise AWS Lambda pour un site statique hébergé sur S3

Examinons le code utilisé pour produire le diagramme ci-dessus. Il illustre toute la puissance des serveurs MCP associés aux agents Strands pour la génération d'architectures 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"
    )

Initialisation du client MCP :

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

Cette section crée un client MCP qui se connecte au serveur officiel de documentation AWS. La commande uvx récupère et exécute dynamiquement la dernière version du serveur MCP de documentation AWS, garantissant ainsi un accès permanent à la documentation la plus à jour.

Client de génération de diagrammes :

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

Sur le même principe, ce code instancie un client pour le serveur MCP de génération de diagrammes AWS, capable de produire des représentations visuelles d'architectures AWS de manière programmatique.

Configuration du modèle :

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

Ce bloc configure le LLM sous-jacent en s'appuyant sur le modèle Claude 3.5 Haiku via AWS Bedrock. Une température de 0,7 offre un bon équilibre entre créativité et cohérence pour les choix d'architecture. Les agents Strands se connectent par défaut à Bedrock, mais vous pouvez aussi recourir à de nombreux fournisseurs tiers comme Gemini, Anthropic ou OpenAI.

Orchestration de l'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)

C'est ici que les agents Strands entrent en scène. L'agent découvre automatiquement tous les outils disponibles sur les deux serveurs MCP et les intègre de façon transparente. Le system prompt définit son rôle d'AWS Solutions Architect et lui fournit le contexte nécessaire pour prendre des décisions d'architecture pertinentes.

Exécution en langage naturel :

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

Cette unique ligne illustre toute la force de l'approche. Plutôt que d'écrire un code complexe pour interroger des API de documentation, parser les réponses et générer des diagrammes, il suffit de décrire ce que l'on souhaite en langage naturel. L'agent gère toute la complexité en coulisses.

Le développement d'agents traditionnel impose une quantité importante de code répétitif dans plusieurs domaines critiques :

Intégration manuelle des API : les développeurs passent généralement beaucoup de temps à écrire des clients HTTP, à gérer l'authentification, à parser les réponses et à respecter les limites de débit pour chaque service à intégrer.

Gestion des erreurs et logique de reprise : des agents robustes exigent une gestion fine des erreurs, des stratégies d'exponential backoff, des circuit breakers et des mécanismes de reprise pour fonctionner de façon fiable.

Orchestration des workflows : coordonner des processus en plusieurs étapes implique une gestion d'état complexe, des branchements conditionnels et de la planification de tâches.

Découverte et gestion des outils : les approches traditionnelles imposent de coder en dur les outils disponibles et leurs interfaces, ce qui rend le système rigide et difficile à étendre.

L'approche Strands + MCP offre, à l'inverse, plusieurs avantages clés :

Moins de code répétitif : le framework prend en charge l'ensemble des préoccupations d'infrastructure de bas niveau, ce qui permet aux développeurs de se concentrer sur la logique métier et les choix d'architecture.

Découverte dynamique des outils : les serveurs MCP exposent leurs capacités dynamiquement, et les agents Strands peuvent découvrir et utiliser de nouveaux outils sans la moindre modification de code.

Interface en langage naturel : au lieu d'écrire du code procédural, les développeurs décrivent leurs intentions en langage naturel, ce qui rend le système plus accessible et plus simple à maintenir.

Fiabilité native : le framework intègre nativement une gestion des erreurs robuste, une logique de reprise et des mécanismes de récupération.

Modularité et réutilisabilité : les serveurs MCP se partagent entre projets et équipes, ce qui favorise la réutilisation du code et la cohérence.

Options de déploiement variées : les agents Strands se déploient sur Lambda, ECS, EKS ou des instances EC2.

Cette approche s'inscrit dans les principes modernes de conception cloud-native et serverless, en mettant l'accent sur la configuration déclarative, la mise à l'échelle automatique et l'infrastructure managée.

Pour exécuter le script mcp_arch_diagram.py, vous devrez installer les packages Python suivants :

pip install mcp strands boto3 anthropic

Détail des packages :

• mcp : implémentation principale du Model Context Protocol
• strands : framework d'orchestration des agents
• boto3 : SDK AWS pour Python (requis pour l'intégration Bedrock)
• anthropic : bibliothèque cliente Python d'Anthropic

Prérequis supplémentaires :

• Vérifiez que uvx est installé globalement pour l'exécution dynamique des packages
• Configurez les identifiants AWS pour accéder à Bedrock
• Mettez en place les autorisations IAM appropriées pour l'utilisation d'AWS Bedrock

La flexibilité des serveurs MCP associés aux agents Strands va bien au-delà des sites statiques. Voici plusieurs autres architectures AWS que cette approche peut générer :

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

Pour générer un diagramme d'architecture d'API serverless avec une authentification solide et une persistance des données.

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

Idéal pour obtenir un diagramme représentant des workflows de traitement de données scalables qui réagissent à des événements en temps réel.

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

Pour obtenir un diagramme d'architectures multi-tier traditionnelles alliant haute disponibilité et performances optimisées.

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

Pour bâtir un diagramme de workflows de machine learning de bout en bout, avec une gestion des données soignée et un monitoring approprié.

Chacun de ces exemples montre comment de simples descriptions en langage naturel se transforment en architectures AWS complètes, sans une seule ligne de code d'infrastructure complexe.

Nous venons de voir comment créer des diagrammes d'architecture pour un nouveau workload. Mais comment identifier les causes racines des incidents et des inefficacités dans vos workloads existants ? Cloud Diagrams visualise votre empreinte cloud quasiment en temps réel, relie les différents services entre eux et propose des recommandations actionnables. À la clé : moins d'incidents, moins d'efforts de troubleshooting et une réduction des coûts opérationnels.