Diagrams
MCP ServerFreeA local/remote MCP server for generating infrastructure and architecture diagrams as code using the Python [diagrams](https://diagrams.mingrammer.com/) library ## Features **5 Diagram Tools** for infrastructure, architecture, and flowcharts: - **Infrastructure Diagrams** - 15+ providers (AWS, Azu
Capabilities10 decomposed
infrastructure-diagram-generation-with-multi-provider-support
Medium confidenceGenerates infrastructure and architecture diagrams as Python code that compiles to visual outputs (PNG, PDF, JPG, DOT) using the Graphviz rendering engine. Wraps the diagrams library's node registry (15+ cloud providers: AWS, Azure, GCP, Kubernetes, On-Prem, SaaS) and edge styling system through MCP tool bindings, allowing Claude to construct diagram specifications that are validated and rendered server-side without requiring local Python environments.
Exposes the diagrams library's 500+ pre-built cloud provider node types and multi-provider support through MCP tool bindings, enabling Claude to generate infrastructure diagrams without requiring users to know Python or Graphviz syntax. The server-side validation and rendering approach means diagrams are generated and cached on the MCP server, not in the client.
Provides native support for 15+ cloud providers with 500+ pre-built icons in a single tool, whereas generic diagram tools (Lucidchart, Draw.io) require manual icon selection and lack cloud-specific node types.
flowchart-generation-with-process-shapes
Medium confidenceGenerates flowcharts and process diagrams using a simplified 24-shape vocabulary (decision diamonds, process rectangles, start/end ovals, etc.) that compiles through the same Graphviz backend as infrastructure diagrams. Abstracts away the full diagrams library complexity by providing a focused shape set optimized for business process and workflow visualization, with support for edge labels and styling.
Provides a simplified, opinionated shape vocabulary (24 shapes) specifically for flowcharts and process diagrams, reducing the cognitive load compared to the full diagrams library. The `create_flowchart` tool abstracts away provider-specific node selection and focuses on process logic visualization.
Simpler and faster than generic diagram tools for flowchart creation because it uses a curated shape set optimized for process flows, whereas tools like Lucidchart require manual shape selection from hundreds of options.
custom-icon-diagram-generation-with-url-and-local-file-support
Medium confidenceExtends infrastructure diagram generation to accept custom node icons from HTTPS URLs or local file paths, enabling organizations to use branded or proprietary icons in their diagrams. Implements client-side validation (HTTPS-only, 5MB size limit, 5-second timeout for URLs; file existence checks for local paths), automatic icon caching in ~/.diagrams_mcp/icon_cache, and format validation (PNG, JPG) before passing to the diagrams library for rendering.
Implements a dual-mode icon loading system with client-side validation, caching, and security constraints (HTTPS-only, size limits, timeout protection) that allows diagrams to incorporate custom icons without requiring users to manually embed images or modify the diagrams library. The caching layer (~/.diagrams_mcp/icon_cache) reduces repeated downloads and improves performance for frequently-used custom icons.
Enables branded diagram generation with custom icons in a single tool call, whereas generic diagram tools require manual icon upload and positioning steps for each diagram.
diagram-node-discovery-and-search
Medium confidenceProvides a searchable registry of 500+ available diagram nodes across 15+ cloud providers and categories (compute, database, network, storage, security, etc.). The `list_available_nodes` tool allows filtering by provider name, category, or keyword, returning node type names and metadata that can be used in diagram specifications. This enables Claude to discover available node types without requiring users to consult external documentation.
Exposes the diagrams library's internal node registry (500+ nodes across 15+ providers) as a searchable tool, allowing Claude to discover available node types dynamically without requiring external API calls or documentation lookups. The search is backed by the diagrams library's Python module introspection.
Provides instant, in-context discovery of available cloud provider nodes without leaving the Claude interface, whereas users of generic diagram tools must manually browse provider documentation or icon libraries.
diagram-specification-validation-with-dry-run
Medium confidenceValidates diagram specifications before rendering by executing a dry-run that checks for syntax errors, invalid node types, missing provider definitions, and other issues without generating output files. The `validate_diagram_spec` tool parses the diagram specification, verifies all referenced nodes exist in the provider registries, and reports validation errors with actionable feedback, allowing users to fix issues before committing to full diagram generation.
Implements a pre-rendering validation step that checks diagram specifications against the diagrams library's node registries before attempting full Graphviz rendering, reducing wasted computation and providing early feedback. The dry-run approach mirrors testing patterns in infrastructure-as-code tools like Terraform.
Catches diagram errors before rendering, saving time and resources compared to generic diagram tools that only report errors during final rendering.
multi-format-diagram-output-rendering
Medium confidenceRenders validated diagram specifications to multiple output formats (PNG, PDF, JPG, DOT) using Graphviz as the backend rendering engine. The MCP server abstracts the Graphviz command-line interface and format conversion logic, allowing Claude to specify output format as a parameter and receive the rendered diagram in the requested format without requiring knowledge of Graphviz syntax or command-line tools.
Abstracts Graphviz's multi-format rendering capabilities through MCP tool parameters, allowing Claude to request output format without requiring knowledge of Graphviz command-line syntax or format conversion tools. The server handles format-specific rendering options and optimization.
Provides single-tool access to multiple output formats (PNG, PDF, JPG, DOT) without requiring separate conversion steps or external tools, whereas generic diagram tools often require manual export workflows for each format.
hierarchical-cluster-grouping-with-unlimited-nesting
Medium confidenceSupports logical grouping of diagram nodes into clusters (subgraphs) with unlimited nesting depth, enabling visual organization of infrastructure into logical domains (e.g., VPCs, namespaces, security zones). Clusters are rendered as visual containers in the output diagram, with customizable styling (colors, labels, borders). The implementation leverages Graphviz's subgraph feature, allowing Claude to specify cluster hierarchies in diagram specifications that are automatically rendered with proper visual containment.
Exposes Graphviz's subgraph clustering feature through diagram specifications, enabling unlimited nesting of logical groups without requiring users to understand Graphviz subgraph syntax. The MCP server handles cluster definition parsing and rendering.
Supports unlimited cluster nesting for complex hierarchical infrastructure visualization, whereas many diagram tools limit nesting depth or require manual grouping workarounds.
edge-styling-with-colors-labels-and-line-styles
Medium confidenceCustomizes connections (edges) between diagram nodes with styling options including colors, labels, and line styles (solid, dashed, dotted). Enables visual differentiation of connection types (e.g., secure vs. insecure, synchronous vs. asynchronous) and annotation of connections with labels (e.g., protocol names, bandwidth). The implementation leverages Graphviz edge attributes, allowing Claude to specify edge styling in diagram specifications that are rendered with proper visual styling.
Provides a simplified interface to Graphviz edge attributes (colors, labels, line styles) through diagram specifications, enabling visual differentiation of connection types without requiring knowledge of Graphviz syntax. The MCP server handles edge attribute parsing and rendering.
Supports rich edge styling (colors, labels, line styles) in a single tool parameter, whereas generic diagram tools often require manual styling of each edge through UI interactions.
graphviz-attribute-customization-and-advanced-rendering
Medium confidenceExposes low-level Graphviz attributes for advanced diagram customization, allowing users to fine-tune rendering behavior (layout engine selection, node spacing, font sizes, etc.) beyond the standard diagram options. This enables power users to optimize diagram layout and appearance for specific use cases without requiring direct Graphviz command-line interaction. The MCP server passes custom Graphviz attributes through to the rendering engine.
Provides direct access to Graphviz's attribute system for advanced customization, enabling power users to optimize diagram layout and appearance without forking the diagrams library or using external tools. The MCP server acts as a pass-through for custom Graphviz attributes.
Enables fine-grained control over Graphviz rendering parameters for users who need advanced customization, whereas generic diagram tools often hide Graphviz options behind limited UI controls.
mcp-tool-binding-and-claude-integration
Medium confidenceImplements the Model Context Protocol (MCP) server interface, exposing diagram generation and discovery tools as callable functions within Claude's tool-use system. The MCP server registers 5 tools (`create_diagram`, `create_diagram_with_custom_icons`, `create_flowchart`, `list_available_nodes`, `validate_diagram_spec`) with parameter schemas that Claude can invoke directly. This enables seamless integration of diagram generation into Claude conversations without requiring external API calls or manual tool invocation.
Implements the MCP server protocol to expose diagram generation as native Claude tools, enabling seamless integration into Claude conversations and workflows. The tool schemas are automatically discoverable by Claude clients, eliminating the need for manual API integration or external tool wrappers.
Provides native Claude integration through MCP, whereas alternative diagram tools require external API calls or manual tool invocation outside of Claude's conversation context.
Capabilities are decomposed by AI analysis. Each maps to specific user intents and improves with match feedback.
Related Artifactssharing capabilities
Artifacts that share capabilities with Diagrams, ranked by overlap. Discovered automatically through the match graph.
GitMind AI
Create visually stunning mind maps, flowcharts, and more, anytime,...
Inkdrop
Automate cloud infrastructure visualization and management...
MyMap AI
AI-driven tool for instant, intuitive diagram...
Eraser
Revolutionizes engineering documentation with diagram-as-code, markdown, and GitHub...
Mermaid Diagram Generator
Generate dynamic Mermaid diagrams and charts with AI assistance. Customize styles and export diagrams in multiple formats including PNG, SVG, and Mermaid syntax. Ensure valid Mermaid syntax for multi-round AI interactions to produce accurate visualizations.
Whimsical AI
GPT-powered mind mapping, flowcharts, and visual tools for rapid idea development and process organization.
Best For
- ✓DevOps engineers and cloud architects documenting infrastructure
- ✓Teams using Claude for infrastructure-as-code planning and review
- ✓Organizations needing automated diagram generation from natural language specifications
- ✓Business analysts and process engineers documenting workflows
- ✓DevOps teams visualizing CI/CD pipelines and deployment processes
- ✓Teams needing quick flowchart generation without learning diagram syntax
- ✓Enterprise teams with branded or proprietary system icons
- ✓Organizations documenting custom infrastructure components alongside cloud services
Known Limitations
- ⚠Graphviz must be installed on the system running the MCP server (not available in all cloud environments)
- ⚠Diagram complexity is bounded by Graphviz rendering performance; very large graphs (100+ nodes) may render slowly
- ⚠Limited to 2D hierarchical layouts; cannot generate 3D or custom spatial layouts
- ⚠Icon caching is local to the MCP server instance; no distributed cache for multi-server deployments
- ⚠Limited to 24 predefined shapes; cannot create custom shape types
- ⚠No swimlane support for cross-functional process diagrams
Requirements
Input / Output
UnfragileRank
UnfragileRank is computed from adoption signals, documentation quality, ecosystem connectivity, match graph feedback, and freshness. No artifact can pay for a higher rank.
Repository Details
About
A local/remote MCP server for generating infrastructure and architecture diagrams as code using the Python [diagrams](https://diagrams.mingrammer.com/) library ## Features **5 Diagram Tools** for infrastructure, architecture, and flowcharts: - **Infrastructure Diagrams** - 15+ providers (AWS, Azure, GCP, K8s, On-Prem, SaaS) - **500+ Node Types** - Compute, database, network, storage, security - **Custom Icons** - Web URLs (HTTPS) and local files - **Flowcharts** - 24 shapes for process diagrams - **Validation** - Dry-run before generation **Advanced Capabilities:** - Multiple output formats (PNG, PDF, JPG, DOT) - Cluster grouping with unlimited nesting - Edge styling (colours, labels, line styles) - Graphviz attribute customisation ## Installation **System Requirements:** - Graphviz must be installed: - macOS: `brew install graphviz` - Ubuntu/Debian: `sudo apt-get install graphviz` - Windows: Download from https://graphviz.org/download/ ### IDEs [](vscode:mcp/install?%7B%22name%22%3A%22diagrams%22%2C%22type%22%3A%22stdio%22%2C%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22diagrams-mcp%22%5D%7D) [](https://cursor.com/en-US/install-mcp?name=diagrams&config=eyJjb21tYW5kIjoidXZ4IGRpYWdyYW1zLW1jcCJ9) ### Claude Desktop Add to your `claude_desktop_config.json`: **For published package:** ```json { "mcpServers": { "diagrams": { "command": "uvx", "args": ["diagrams-mcp"] } } } ``` **For local development:** ```json { "mcpServers": { "diagrams:local": { "command": "uv", "args": [ "--directory", "/ABSOLUTE/PATH/TO/diagrams-mcp", "run", "diagrams-mcp" ] } } } ``` ### Claude Code **Quick setup (CLI):** Published package: ```bash claude mcp add --transport stdio math -- uvx diagrams-mcp ``` **Team setup (project-level):** Add `.mcp.json` to your project root: ```json { "mcpServers": { "diagrams": { "command": "uvx", "args": ["diagrams-mcp"] } } } ``` **Verify installation:** ```bash claude mcp list ``` Or check in IDE: View → MCP Servers, or use `/mcp` command. ## Try It Once installed, try these prompts: - "Create an AWS 3-tier web application diagram with Route53, ELB, EC2 instances, and RDS" - "Generate a Kubernetes microservices architecture with ingress, services, and pods" - "Build a flowchart for a CI/CD pipeline with decision points" - "Create a diagram using a custom icon from my company logo URL" - "Show me all available AWS compute nodes" Map to tools: `create_diagram`, `create_diagram_with_custom_icons`, `create_flowchart`, `list_available_nodes`, `validate_diagram_spec` ## Tool Reference All tool parameters and descriptions are available in your IDE's autocomplete. ### Diagram Generation (3 tools) | Tool | Description | | ---------------------------------- | ------------------------------------------------------------ | | `create_diagram` | Full infrastructure/architecture diagrams with all providers | | `create_diagram_with_custom_icons` | Diagrams with custom node icons from URLs or local files | | `create_flowchart` | Simplified flowchart creation with 24 process shapes | ### Discovery & Validation (2 tools) | Tool | Description | | ----------------------- | ------------------------------------------------------------- | | `list_available_nodes` | Search 500+ available nodes by provider, category, or keyword | | `validate_diagram_spec` | Dry-run validation before generation | ## Custom Icons ### Web URL Icons - HTTPS-only (HTTP rejected) - 5MB file size limit - 5-second download timeout - Image format validation (PNG, JPG) - Automatic caching (~/.diagrams_mcp/icon_cache) ### Local File Icons - Path validation (file must exist) - Format validation - Sandboxed execution
Categories
Alternatives to Diagrams
Search the Supabase docs for up-to-date guidance and troubleshoot errors quickly. Manage organizations, projects, databases, and Edge Functions, including migrations, SQL, logs, advisors, keys, and type generation, in one flow. Create and manage development branches to iterate safely, confirm costs
Compare →AI-optimized web search and content extraction via Tavily MCP.
Compare →Scrape websites and extract structured data via Firecrawl MCP.
Compare →Are you the builder of Diagrams?
Claim this artifact to get a verified badge, access match analytics, see which intents users search for, and manage your listing.
Get the weekly brief
New tools, rising stars, and what's actually worth your time. No spam.
Data Sources
Looking for something else?
Search →