本文介绍了如何使用Amazon Q Developer CLI和Model Context Protocol (MCP)创建专业的AWS架构图。通过自然语言提示，用户可以在几分钟内生成符合AWS最佳实践的图表，而无需手动绘制。文章详细阐述了解决方案的概述、环境设置、MCP服务器工具的使用以及多种架构图的创建示例，为解决方案架构师、开发人员和技术团队提供了高效的绘图方法。

💡 传统绘制AWS架构图耗时且复杂，而Amazon Q Developer CLI结合MCP提供了一种更高效的解决方案，通过自然语言提示，可在几分钟内生成专业图表。

⚙️ 解决方案的核心是Amazon Q Developer CLI，它利用MCP连接到专门的服务器，如AWS Diagram MCP server，该服务器使用Python diagrams包生成架构图，并访问完整的AWS图标集和最佳实践。

🛠️ 要使用此解决方案，用户需安装Amazon Q Developer CLI、AWS Diagram MCP服务器和AWS Documentation MCP服务器，并配置好环境。文章提供了详细的安装和配置步骤，包括设置MCP服务器。

🖼️ AWS Diagram MCP服务器提供了多种工具，如list_icons（列出图标）、get_diagram_examples（提供示例代码）、generate_diagram（生成图表）。AWS Documentation MCP服务器则提供了search_documentation（搜索文档）、read_documentation（读取文档）等工具，辅助创建符合最佳实践的架构图。

🌐 通过实例演示，用户可以使用自然语言描述所需的架构，Amazon Q CLI将自动搜索AWS文档、生成Python代码并创建图表。用户可以自定义输出目录、格式和样式，以满足特定需求。

Creating professional AWS architecture diagrams is a fundamental task for solutions architects, developers, and technical teams. These diagrams serve as essential communication tools for stakeholders, documentation of compliance requirements, and blueprints for implementation teams. However, traditional diagramming approaches present several challenges:

Time-consuming process – Creating detailed architecture diagrams manually can take hours or even days Steep learning curve – Learning specialized diagramming tools requires significant investment Inconsistent styling – Maintaining visual consistency across multiple diagrams is difficult Outdated AWS icons – Keeping up with the latest AWS service icons and best practices challenging. Difficult maintenance – Updating diagrams as architectures evolve can become increasingly burdensome

Amazon Q Developer CLI with the Model Context Protocol (MCP) offers a streamlined approach to creating AWS architecture diagrams. By using generative AI through natural language prompts, architects can now generate professional diagrams in minutes rather than hours, while adhering to AWS best practices.

In this post, we explore how to use Amazon Q Developer CLI with the AWS Diagram MCP and the AWS Documentation MCP servers to create sophisticated architecture diagrams that follow AWS best practices. We discuss techniques for basic diagrams and real-world diagrams, with detailed examples and step-by-step instructions.

Solution overview

Amazon Q Developer CLI is a command line interface that brings the generative AI capabilities of Amazon Q directly to your terminal. Developers can interact with Amazon Q through natural language prompts, making it an invaluable tool for various development tasks.

Developed by Anthropic as an open protocol, the Model Context Protocol (MCP) provides a standardized way to connect AI models to virtually any data source or tool. Using a client-server architecture (as illustrated in the following diagram), the MCP helps developers expose their data through lightweight MCP servers while building AI applications as MCP clients that connect to these servers.

The MCP uses a client-server architecture containing the following components:

Host – A program or AI tool that requires access to data through the MCP protocol, such as Anthropic’s Claude Desktop, an integrated development environment (IDE), AWS MCP CLI, or other AI applications Client – Protocol clients that maintain one-to-one connections with server Server – Lightweight programs that expose capabilities through standardized MCP or act as tools Data sources – Local data sources such as databases and file systems, or external systems available over the internet through APIs (web APIs) that MCP servers can connect with

As announced in April 2025, MCP enables Amazon Q Developer to connect with specialized servers that extend its capabilities beyond what’s possible with the base model alone. MCP servers act as plugins for Amazon Q, providing domain-specific knowledge and functionality. The AWS Diagram MCP server specifically enables Amazon Q to generate architecture diagrams using the Python diagrams package, with access to the complete AWS icon set and architectural best practices.

Prerequisites

To implement this solution, you must have an AWS account with appropriate permissions and follow the steps below.

Set up your environment

Before you can start creating diagrams, you need to set up your environment with Amazon Q CLI, the AWS Diagram MCP server, and AWS Documentation MCP server. This section provides detailed instructions for installation and configuration.

Install Amazon Q Developer CLI

Amazon Q Developer CLI is available as a standalone installation. Complete the following steps to install it:

Download and install Amazon Q Developer CLI. For instructions, see Using Amazon Q Developer on the command line. Verify the installation by running the following command: q --version
You should see output similar to the following: Amazon Q Developer CLI version 1.x.x Configure Amazon Q CLI with your AWS credentials: q login Choose the login method suitable for you:
Use for free with AWS Builder ID Use with Pro license

Set up MCP servers

Complete the following steps to set up your MCP servers:

Install uv using the following command: pip install uv Install Python 3.10 or newer: uv python install 3.10 Install GraphViz for your operating system. Add the servers to your ~/.aws/amazonq/mcp.json file:

{  "mcpServers": {    "awslabs.aws-diagram-mcp-server": {      "command": "uvx",      "args": ["awslabs.aws-diagram-mcp-server"],      "env": {        "FASTMCP_LOG_LEVEL": "ERROR"      },      "autoApprove": [],      "disabled": false    },    "awslabs.aws-documentation-mcp-server": {      "command": "uvx",      "args": ["awslabs.aws-documentation-mcp-server@latest"],      "env": {        "FASTMCP_LOG_LEVEL": "ERROR"      },      "autoApprove": [],      "disabled": false    }  }}

Now, Amazon Q CLI automatically discovers MCP servers in the ~/.aws/amazonq/mcp.json file.

Understanding MCP server tools

The AWS Diagram MCP server provides several powerful tools:

list_icons – Lists available icons from the diagrams package, organized by provider and service category get_diagram_examples – Provides example code for different types of diagrams (AWS, sequence, flow, class, and others) generate_diagram – Creates a diagram from Python code using the diagrams package

The AWS Documentation MCP server provides the following useful tools:

search_documentation – Searches AWS documentation using the official AWS Documentation Search API read_documentation – Fetches and converts AWS documentation pages to markdown format recommend – Gets content recommendations for AWS documentation pages

These tools work together to help you create accurate architecture diagrams that follow AWS best practices.

Test your setup

Let’s verify that everything is working correctly by generating a simple diagram:

Start the Amazon Q CLI chat interface and verify the output shows the MCP servers being loaded and initialized: q chat
In the chat interface, enter the following prompt:
Please create a diagram showing an EC2 instance in a VPC connecting to an external S3 bucket. Include essential networking components (VPC, subnets, Internet Gateway, Route Table), security elements (Security Groups, NACLs), and clearly mark the connection between EC2 and S3. Label everything appropriately concisely and indicate that all resources are in the us-east-1 region. Check for AWS documentation to ensure it adheres to AWS best practices before you create the diagram. Amazon Q CLI will ask you to trust the tool that is being used; enter t to trust it.Amazon Q CLI will generate and display a simple diagram showing the requested architecture. Your diagram should look similar to the following screenshot, though there might be variations in layout, styling, or specific details because it’s created using generative AI. The core architectural components and relationships will be represented, but the exact visual presentation might differ slightly with each generation.

If you see the diagram, your environment is set up correctly. If you encounter issues, verify that Amazon Q CLI can access the MCP servers by making sure you installed the necessary tools and the servers are in the ~/.aws/amazonq/mcp.json file.

Configuration options

The AWS Diagram MCP server supports several configuration options to customize your diagramming experience:

Output directory – By default, diagrams are saved in a generated-diagrams directory in your current working directory. You can specify a different location in your prompts. Diagram format – The default output format is PNG, but you can request other formats like SVG in your prompts. Styling options – You can specify colors, shapes, and other styling elements in your prompts.

Now that our environment is set up, let’s create more diagrams.

Create AWS architecture diagrams

In this section, we walk through the process of multiple AWS architecture diagrams using Amazon Q CLI with the AWS Diagram MCP server and AWS Documentation MCP server to make sure our requirements follow best practices.

When you provide a prompt to Amazon Q CLI, the AWS Diagram and Documentation MCP servers complete the following steps:

Interpret your requirements. Check for best practices on the AWS documentation. Generate Python code using the diagrams package. Execute the code to create the diagram. Return the diagram as an image.

This process happens seamlessly, so you can focus on describing what you want rather than how to create it.

AWS architecture diagrams typically include the following components:

Nodes – AWS services and resources Edges – Connections between nodes showing relationships or data flow Clusters – Logical groupings of nodes, such as virtual private clouds (VPCs), subnets, and Availability Zones Labels – Text descriptions for nodes and connections

Example 1: Create a web application architecture

Let’s create a diagram for a simple web application hosted on AWS. Enter the following prompt:

Create a diagram for a simple web application with an Application Load Balancer, two EC2 instances, and an RDS database. Check for AWS documentation to ensure it adheres to AWS best practices before you create the diagram

The generated diagram shows the following key components:

An Application Load Balancer as the entry point Two Amazon Elastic Compute Cloud (Amazon EC2) instances for the application tier An Amazon Relational Database Service (Amazon RDS) instance for the database tier Connections showing the flow of traffic

Example 2: Create a multi-tier architecture

Multi-tier architectures separate applications into functional layers (presentation, application, and data) to improve scalability and security. We use the following prompt to create our diagram:

Create a diagram for a three-tier web application with a presentation tier (ALB and CloudFront), application tier (ECS with Fargate), and data tier (Aurora PostgreSQL). Include VPC with public and private subnets across multiple AZs. Check for AWS documentation to ensure it adheres to AWS best practices before you create the diagram.

The diagram shows the following key components:

A presentation tier in public subnets An application tier in private subnets A data tier in isolated private subnets Proper security group configurations Traffic flow between tiers

Example 3: Create a serverless architecture

We use the following prompt to create a diagram for a serverless architecture:

Create a diagram for a serverless web application using API Gateway, Lambda, DynamoDB, and S3 for static website hosting. Include Cognito for user authentication and CloudFront for content delivery. Check for AWS documentation to ensure it adheres to AWS best practices before you create the diagram.

The diagram includes the following key components:

Amazon Simple Storage Service (Amazon S3) hosting static website content Amazon CloudFront distributing content globally Amazon API Gateway handling API requests AWS Lambda functions implementing business logic Amazon DynamoDB storing application data Amazon Cognito managing user authentication

Example 4: Create a data processing diagram

We use the following prompt to create a diagram for a data processing pipeline:

Create a diagram for a data processing pipeline with components organized in clusters for data ingestion, processing, storage, and analytics. Include Kinesis, Lambda, S3, Glue, and QuickSight. Check for AWS documentation to ensure it adheres to AWS best practices before you create the diagram.

The diagram organizes components into distinct clusters:

Data ingestion – Amazon Kinesis Data Streams, Amazon Data Firehose, Amazon Simple Queue Service Data processing – Lambda functions, AWS Glue jobs Data storage – S3 buckets, DynamoDB tables Data analytics – AWS Glue, Amazon Athena, Amazon QuickSight

Real-world examples

Let’s explore some real-world architecture patterns and how to create diagrams for them using Amazon Q CLI with the AWS Diagram MCP server.

Ecommerce platform

Ecommerce platforms require scalable, resilient architectures to handle variable traffic and maintain high availability. We use the following prompt to create an example diagram:

Create a diagram for an e-commerce platform with microservices architecture. Include components for product catalog, shopping cart, checkout, payment processing, order management, and user authentication. Ensure the architecture follows AWS best practices for scalability and security. Check for AWS documentation to ensure it adheres to AWS best practices before you create the diagram.

The diagram includes the following key components:

API Gateway as the entry point for client applications Microservices implemented as containers in Amazon Elastic Container Service (Amazon ECS) with AWS Fargate RDS databases for product catalog, shopping cart, and order data Amazon ElastiCache for product data caching and session management Amazon Cognito for authentication Amazon Simple Queue Service (Amazon SQS) and Amazon Simple Notification Service (Amazon SNS) for asynchronous communication between services CloudFront for content delivery and static assets from Amazon S3 Amazon Route 53 for DNS management AWS WAF for web application security AWS Lambda functions for serverless microservice implementation AWS Secrets Manager for secure credential storage Amazon CloudWatch for monitoring and observability

Intelligent document processing solution

We use the following prompt to create a diagram for an intelligent document processing (IDP) architecture:

Create a diagram for an intelligent document processing (IDP) application on AWS. Include components for document ingestion, OCR and text extraction, intelligent data extraction (using NLP and/or computer vision), human review and validation, and data output/integration. Ensure the architecture follows AWS best practices for scalability and security, leveraging services like S3, Lambda, Textract, Comprehend, SageMaker (for custom models, if applicable), and potentially Augmented AI (A2I). Check for AWS documentation related to intelligent document processing best practices to ensure it adheres to AWS best practices before you create the diagram.

The diagram includes the following key components:

Amazon API Gateway as the entry point for client applications, providing a secure and scalable interface Microservices implemented as containers in ECS with Fargate, enabling flexible and scalable processing Amazon RDS databases for product catalog, shopping cart, and order data, providing reliable structured data storage Amazon ElastiCache for product data caching and session management, improving performance and user experience Amazon Cognito for authentication, ensuring secure access control Amazon Simple Queue Service and Amazon Simple Notification Service for asynchronous communication between services, enabling decoupled and resilient architecture Amazon CloudFront for content delivery and static assets from S3, optimizing global performance Amazon Route53 for DNS management, providing reliable routing AWS WAF for web application security, protecting against common web exploits AWS Lambda functions for serverless microservice implementation, offering cost-effective scaling AWS Secrets Manager for secure credential storage, enhancing security posture Amazon CloudWatch for monitoring and observability, providing insights into system performance and health.

Clean up

If you no longer need to use the AWS Cost Analysis MCP server with Amazon Q CLI, you can remove it from your configuration:

Open your ~/.aws/amazonq/mcp.json file. Remove or comment out the MCP server entries. Save the file.

This will prevent the server from being loaded when you start Amazon Q CLI in the future.

Conclusion

In this post, we explored how to use Amazon Q CLI with the AWS Documentation MCP and AWS Diagram MCP servers to create professional AWS architecture diagrams that adhere to AWS best practices referenced from official AWS documentation. This approach offers significant advantages over traditional diagramming methods:

Time savings – Generate complex diagrams in minutes instead of hours Consistency – Make sure diagrams follow the same style and conventions Best practices – Automatically incorporate AWS architectural guidelines Iterative refinement – Quickly modify diagrams through simple prompts Validation – Check architectures against official AWS documentation and recommendations

As you continue your journey with AWS architecture diagrams, we encourage you to deepen your knowledge by learning more about the Model Context Protocol (MCP) to understand how it enhances the capabilities of Amazon Q. When seeking inspiration for your own designs, the AWS Architecture Center offers a wealth of reference architectures that follow best practices. For creating visually consistent diagrams, be sure to visit the AWS Icons page, where you can find the complete official icon set. And to stay at the cutting edge of these tools, keep an eye on updates to the official AWS MCP Servers—they’re constantly evolving with new features to make your diagramming experience even better.

---

About the Authors

Joel Asante, an Austin-based Solutions Architect at Amazon Web Services (AWS), works with GovTech (Government Technology) customers. With a strong background in data science and application development, he brings deep technical expertise to creating secure and scalable cloud architectures for his customers. Joel is passionate about data analytics, machine learning, and robotics, leveraging his development experience to design innovative solutions that meet complex government requirements. He holds 13 AWS certifications and enjoys family time, fitness, and cheering for the Kansas City Chiefs and Los Angeles Lakers in his spare time.

Dunieski Otano is a Solutions Architect at Amazon Web Services based out of Miami, Florida. He works with World Wide Public Sector MNO (Multi-International Organizations) customers. His passion is Security, Machine Learning and Artificial Intelligence, and Serverless. He works with his customers to help them build and deploy high available, scalable, and secure solutions. Dunieski holds 14 AWS certifications and is an AWS Golden Jacket recipient. In his free time, you will find him spending time with his family and dog, watching a great movie, coding, or flying his drone.

Varun Jasti is a Solutions Architect at Amazon Web Services, working with AWS Partners to design and scale artificial intelligence solutions for public sector use cases to meet compliance standards. With a background in Computer Science, his work covers broad range of ML use cases primarily focusing on LLM training/inferencing and computer vision. In his spare time, he loves playing tennis and swimming.