Diagram Generator (Python diagrams)

Generate architecture diagrams using the Python `diagrams` library. Convert user descriptions into visual diagrams by analyzing system architectures, selecting appropriate components, and producing executable Python code.

What This Skill Does

This skill enables you to create architecture diagrams programmatically by:

Converting natural language architecture descriptions into visual diagrams

Selecting appropriate diagram nodes from available provider libraries

Generating executable Python code using the `diagrams` library

Following established patterns and best practices from repository templates

Instructions

1. Understand the Architecture

**Review Documentation**: Check `architectures/README.md` for system overviews, components, and data flows

**Identify Components**: Determine what services, databases, networks, and infrastructure elements are involved

**Analyze Relationships**: Understand how components connect and interact

2. Select Appropriate Nodes

**Reference Node Classes**: Consult `docs/*.md` files for available nodes by provider (AWS, GCP, Azure, on-prem, etc.)

**Match Technologies**: Find nodes that correspond to the technologies mentioned in the architecture

- Example: `diagrams.onprem.analytics.Spark` for Apache Spark

- Example: `diagrams.aws.compute.EC2` for AWS EC2 instances

**Use Generics When Needed**: If specific nodes don't exist, use generic placeholders:

- `diagrams.generic.os.LinuxGeneral`

- `diagrams.generic.blank.Blank`

3. Generate Python Code

Follow this structure:

```python

from diagrams import Diagram, Cluster, Edge

from diagrams.onprem.database import Postgresql

from diagrams.onprem.network import Nginx

Import other nodes as needed

with Diagram("Architecture Name", show=False, direction="LR"):

# Use Clusters to group related components

with Cluster("Service Layer"):

web = Nginx("Web Server")

app = LinuxGeneral("App Server")

# Define standalone components

db = Postgresql("Database")

# Create connections with edges

web >> Edge(label="forwards") >> app

app >> Edge(label="queries") >> db

```

**Key Patterns:**

Use `with Cluster("name"):` to group related components

Create edges with `>>` operator: `nodeA >> nodeB`

Add labels to edges: `nodeA >> Edge(label="description") >> nodeB`

Set diagram direction: `direction="LR"` (left-to-right) or `direction="TB"` (top-to-bottom)

Use `show=False` to prevent automatic display and save to file instead

4. Validate and Execute

**Check Imports**: Ensure all imports match exactly what's available in `docs/` files

**Note Aliases**: Some nodes have different names (e.g., `Fluentbit` instead of Fluentd, `CouchDB` instead of Couchdb)

**Test Syntax**: Verify code is syntactically correct before suggesting

**Run Command**: Execute with `python diagram.py` to generate PNG in `gen/` directory

5. Important Constraints

**Only use documented architectures**: Base diagrams on architectures described in `architectures/` directory

**Do not fabricate designs**: Don't invent or create system architectures that aren't documented

**Use accurate node references**: All node classes must exist in `docs/` files

**Follow repository patterns**: Reference `diagram.py` (root) and `templates/*.py` for established patterns

Examples

Basic Web Application

```python

from diagrams import Diagram, Cluster, Edge

from diagrams.onprem.network import Nginx

from diagrams.onprem.compute import Server

from diagrams.onprem.database import Postgresql

with Diagram("Web App Architecture", show=False):

with Cluster("Frontend"):

lb = Nginx("Load Balancer")

with Cluster("Application"):

app = Server("App Server")

db = Postgresql("Database")

lb >> Edge(label="routes") >> app

app >> Edge(label="queries") >> db

```

Microservices with Message Queue

```python

from diagrams import Diagram, Cluster, Edge

from diagrams.onprem.queue import Kafka

from diagrams.onprem.database import MongoDB

from diagrams.generic.os import LinuxGeneral

with Diagram("Microservices", show=False, direction="LR"):

with Cluster("Services"):

svc1 = LinuxGeneral("Service A")

svc2 = LinuxGeneral("Service B")

queue = Kafka("Message Queue")

db = MongoDB("Document Store")

svc1 >> Edge(label="publishes") >> queue

queue >> Edge(label="consumes") >> svc2

svc2 >> Edge(label="stores") >> db

```

Event Processing Pipeline

```python

from diagrams import Diagram, Cluster, Edge

from diagrams.onprem.analytics import Spark

from diagrams.onprem.queue import Kafka

from diagrams.onprem.database import Cassandra

with Diagram("Event Processing", show=False):

ingestion = Kafka("Event Ingestion")

with Cluster("Processing"):

processor = Spark("Stream Processor")

storage = Cassandra("Time Series DB")

ingestion >> Edge(label="streams") >> processor

processor >> Edge(label="writes") >> storage

```

Tips

**Start Simple**: Begin with core components, then add details

**Use Clusters Wisely**: Group related services for clarity

**Label Edges**: Descriptive edge labels improve diagram readability

**Check Templates**: Review `templates/*.py` for patterns matching your use case (AWS workers, clustered services, event processing)

**Iterate**: Generate, review output, refine code if needed

Notes

Output diagrams are saved as PNG files in the `gen/` directory

The `show=False` parameter prevents automatic display (useful for CI/CD)

Direction parameter controls layout: `"LR"` (horizontal), `"TB"` (vertical)

For complex diagrams, break into logical clusters for better organization

Diagram Generator (Python diagrams)

Diagram Generator (Python diagrams)

What This Skill Does

Instructions

1. Understand the Architecture

2. Select Appropriate Nodes

3. Generate Python Code

Import other nodes as needed

4. Validate and Execute

5. Important Constraints

Examples

Basic Web Application

Microservices with Message Queue

Event Processing Pipeline

Tips

Notes

Reviews (0)