What can you do with this server?

Blueprint is an MCP server for generating and visualizing C4 software architecture diagrams, scanning codebases, and providing C4 reference documentation. * Create C4 Diagrams Use create_c4_diagram to generate context, container, component, deployment, and dynamic diagrams from structured JSON (elements, relationships, boundaries). Output in Mermaid (default) or PlantUML, with optional SVG rendering via Kroki (supports self-hosted instance). * Scan Codebases Analyze a project with scan_codebase to get a structural overview: detected language, framework, dependencies, entry points, config files, and directory tree (depth configurable). * C4 Reference Look up built-in C4 model documentation using get_c4_reference for element types, diagram types, relationships, or all topics. * AI Assistant Friendly Integrates via MCP; describe architectures in natural language or call tools directly with JSON. * Simple Setup Uses uv for dependency management; no manual virtual environment needed.

How do I use Blueprint?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Blueprint create a C4 context diagram for my e-commerce system" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

Blueprint

by ColOfAbRiX

Overview Schema Related Servers Score Discussions

Python

Local

Blueprint

An MCP server for generating and visualizing C4 software architecture diagrams.

What is Blueprint?

Blueprint is a Model Context Protocol (MCP) server that enables AI assistants to create C4 architecture diagrams. It provides three tools:

Tool	Purpose
`create_c4_diagram`	Build C4 diagrams from structured element/relationship data
`scan_codebase`	Get a structural overview of a project (language, deps, entry points)
`get_c4_reference`	C4 model documentation (element types, diagram types, relationships)

Related MCP server: AI Charts

What are C4 Diagrams?

The C4 model is a lean graphical notation technique for modelling software architecture. It uses a hierarchical set of four diagrams at different abstraction levels:

Context (Level 1) — The big picture: your system, its users, and the external systems it interacts with. Use this to communicate with non-technical stakeholders.
Container (Level 2) — Zooms into a system to show the high-level technical building blocks (web apps, mobile apps, databases, message brokers) and how they interact.
Component (Level 3) — Zooms into a container to show its major structural components (services, repositories, controllers, etc.) and their responsibilities.
Code (Level 4) — Optional: UML class diagrams for individual components. Blueprint does not generate this level.

Blueprint also supports Deployment diagrams (how containers are deployed to infrastructure) and Dynamic diagrams (runtime interactions and data flow between elements).

How to Create C4 Diagrams

There are two ways to direct Blueprint to generate a diagram:

Option 1: Describe Your Architecture in Conversation

Simply describe your system to the AI assistant in natural language. The LLM will extract the relevant C4 elements and relationships, then call create_c4_diagram on your behalf. For example:

"I need a context diagram for an e-commerce platform. There's a customer who browses products and places orders through a web application. The web app talks to a payment service and an inventory database."

The assistant will translate this into the structured JSON that Blueprint expects and return a diagram.

Option 2: Call the Tool Directly with Structured Data

If you prefer precise control, ask the LLM to call create_c4_diagram with explicit JSON. First, optionally use scan_codebase to get a project overview, or get_c4_reference to look up valid element types. Then create the diagram:

{
  "diagram_type": "context",
  "title": "My System",
  "elements": [
    {"type": "Person", "alias": "user", "label": "User", "description": "A system user"},
    {"type": "System", "alias": "myapp", "label": "My Application", "description": "The main system"}
  ],
  "relationships": [
    {"source": "user", "target": "myapp", "label": "Uses", "technology": "HTTPS"}
  ],
  "output_format": "mermaid"
}

Supported diagram types: context, container, component, deployment, dynamic

Use boundaries (EnterpriseBoundary, SystemBoundary, ContainerBoundary) to visually group related elements.

Rendered SVG Output

To get a rendered SVG image alongside the source code, set render_image to true:

{
  "diagram_type": "context",
  "title": "My System",
  "elements": [
    {"type": "Person", "alias": "user", "label": "User"},
    {"type": "System", "alias": "myapp", "label": "My Application"}
  ],
  "relationships": [
    {"source": "user", "target": "myapp", "label": "Uses"}
  ],
  "output_format": "mermaid",
  "render_image": true
}

When render_image is true, the tool returns both the diagram source code and the rendered SVG. SVG is vector-based — it scales to any size without quality loss and renders inline in VS Code, GitHub, and most markdown editors. Rendering is powered by Kroki — no local dependencies required. If rendering fails, the source code is still returned with an error message.

To use a self-hosted Kroki instance, set the BLUEPRINT_KROKI_URL environment variable (defaults to https://kroki.io).

Quick Start

Blueprint uses uv for zero-config setup — no manual virtual environment needed.

# Install uv (if not already installed)

# macOS / Linux
curl -LsSf https://astral.sh/uv/install.sh | sh

# Windows
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# Start the MCP server (dependencies are installed automatically)
uv run blueprint

# Run tests (includes dev dependencies)
uv run --extra dev pytest

MCP Client Configuration

Add to your MCP client settings:

{
  "mcpServers": {
    "blueprint": {
      "command": "uv",
      "args": ["run", "blueprint"]
    }
  }
}

Usage

Scan a Codebase

Use scan_codebase to get a quick structural overview before diagramming:

{
  "project_path": "/path/to/project",
  "max_depth": 3
}

Returns project structure, detected language/framework, dependencies, and entry points.

Look Up C4 Reference

Use get_c4_reference to retrieve documentation on valid element types, diagram types, and relationships:

{
  "topic": "all"
}

Valid topics: elements, diagrams, relationships, all.

Output Formats

Format	Source code	Rendered SVG
Mermaid (default)	✅ Inline in VS Code, GitHub, markdown editors	✅ Via Kroki
PlantUML	✅ Full C4-PlantUML macro support	✅ Via Kroki

Development

# Run tests
uv run --extra dev pytest

# Run tests with verbose output
uv run --extra dev pytest -v

License

MIT

Available Tools

3 tools

create_c4_diagram_toolA

Create a C4 architecture diagram from structured data.

Generates diagram source code (Mermaid or PlantUML) from explicitly defined elements, relationships, and boundaries.

Args: diagram_type: C4 diagram type: context, container, component, deployment, or dynamic title: Diagram title elements: List of C4 elements, each with: type, alias, label, description, technology relationships: List of relationships, each with: source, target, label, technology, direction boundaries: List of grouping boundaries, each with: type, alias, label, element_aliases output_format: Output format: mermaid (default) or plantuml

Returns: Diagram source code in the requested format.

ParametersJSON Schema

Name	Required	Default
`title`	Yes
`elements`	Yes
`boundaries`	No
`diagram_type`	Yes
`output_format`	No	mermaid
`relationships`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.3/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It discloses that it generates source code from explicitly defined elements, relationships, and boundaries. However, it does not mention any side effects, mutation, or limitations (e.g., no image rendering), which would be helpful for an agent to fully understand the tool's behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and well-structured: a one-line summary followed by a clear Args list with parameter details. Every sentence adds value, and the format is front-loaded for quick understanding.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers purpose, parameters, and output format adequately. Since an output schema exists, it doesn't need to detail return values. It could elaborate on diagram type semantics, but given sibling tools may cover that, the description is sufficiently complete for a creation tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 0% description coverage, but the tool's description compensates by explaining each parameter's meaning and structure (e.g., 'elements: List of C4 elements, each with: type, alias, label, description, technology'). This provides significant value beyond the schema's type-only definitions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly identifies the tool's purpose: 'Create a C4 architecture diagram from structured data.' It specifies the output (Mermaid or PlantUML source code) and distinguishes itself from siblings like 'get_c4_reference_tool' and 'scan_codebase_tool' by focusing on creation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context for usage (when you have structured C4 data) and lists supported diagram types. However, it lacks explicit guidance on when not to use it or how to choose between output formats or diagram types, leaving some interpretation to the agent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_c4_reference_toolA

Get C4 model reference documentation.

Returns documentation about C4 element types, diagram types, and relationship conventions. Use this to understand what elements are available and how to structure create_c4_diagram inputs.

Args: topic: Reference topic: elements, diagrams, relationships, or all

Returns: Markdown documentation for the requested topic.

ParametersJSON Schema

Name	Required	Description	Default
`topic`	No		all

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It states the tool returns documentation (Markdown), describes the single parameter, and lists possible values. While it omits mentioning that it is read-only or non-destructive, the nature of a reference lookup implies safety, and the output schema existence adds transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise at four sentences, with the purpose stated in the first line. Every sentence adds value: what it does, what it returns, and how to use the parameter. No fluff or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (one optional parameter), presence of an output schema, and clear sibling differentiation, the description is complete. It explains the return format, parameter options, and usage context, leaving no ambiguity for an AI agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 0% description coverage, but the tool description explicitly documents the parameter 'topic' with its allowed values (elements, diagrams, relationships, all). This adds meaning beyond the schema, compensating for the lack of formal descriptions. The explanation of the parameter's purpose is clear.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool returns C4 model reference documentation, specifying content (element types, diagram types, relationship conventions) and purpose (to aid in structuring create_c4_diagram inputs). It distinguishes itself from sibling tools (create_c4_diagram, scan_codebase) by being a reference lookup.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly states when to use this tool: before using create_c4_diagram to understand available elements. It provides context by explaining the return format (Markdown documentation) and parameter options, though it doesn't explicitly state when not to use or mention alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

scan_codebase_toolA

Scan a project directory and return a structural overview.

Returns information about the project including: detected language, framework, directory tree, dependencies, entry points, and config files. Does NOT interpret code — use this as a starting point for analysis, then read specific files to understand the architecture.

Args: project_path: Absolute or relative path to the project root directory max_depth: Maximum directory depth to scan (default: 3)

Returns: JSON object with project structure information.

ParametersJSON Schema

Name	Required	Description	Default
`max_depth`	No
`project_path`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.7/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It transparently discloses that the tool returns a JSON object with structure information and does not interpret code. However, it omits details about potential errors, performance implications, or edge cases like non-existent paths.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise, using a clear structure: a one-sentence purpose, a bullet list of return contents, and explicit parameter documentation. Every sentence adds value without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's moderate complexity (2 parameters, no nested objects) and the presence of an output schema, the description fully covers the necessary information: what the tool does, what it returns, how to use parameters, and how it fits with sibling tools. No obvious gaps remain.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description adds meaningful context beyond the input schema: it explains that 'project_path' is an absolute or relative path and that 'max_depth' defaults to 3. The schema itself has titles but no descriptions, so the description compensates effectively for the 0% schema description coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses the specific verb 'scan' and resource 'project directory', clearly stating it returns a structural overview. It distinguishes itself from sibling tools like 'create_c4_diagram_tool' and 'get_c4_reference_tool', which focus on diagram generation rather than codebase scanning.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly provides usage guidance: 'use this as a starting point for analysis, then read specific files to understand the architecture.' It also states what the tool does NOT do ('Does NOT interpret code'), helping the agent choose appropriate follow-up actions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

3 tool updatesv0.1.0Jun 26, 2026
- First observedcreate_c4_diagram_tool
- First observedget_c4_reference_tool
- First observedscan_codebase_tool

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.4/5.0

Disambiguation5/5

Each tool has a clearly distinct purpose: one creates diagrams from structured data, one provides reference documentation, and one scans codebases. No overlap in functionality.

Naming Consistency5/5

All tools follow a consistent verb_noun_tool pattern (create_c4_diagram_tool, get_c4_reference_tool, scan_codebase_tool) with snake_case, making them predictable.

Tool Count4/5

Three tools is reasonable for the server's focus on C4 diagrams and codebase scanning, though it feels slightly minimal. Each tool serves a distinct function without bloat.

Completeness3/5

The server covers diagram creation and reference but lacks automatic conversion from code to C4 elements or tools to manage saved diagrams. The codebase scanner provides structure but not interpretation, leaving a gap.

Maintenance

ActivityStale

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

OrgGen AI
ai.orggen
Generate org charts, MCD/ERD data models, and C4 architecture diagrams — pilot OrgGen AI via MCP.
Software Architecture Data Visualization
2
Maplith
com.maplith
Data-ontology maps of your business systems, served to AI agents over MCP.
Knowledge & Memory Data Platforms
1
driflyte-mcp-server
com.driflyte
Driflyte MCP server which lets AI assistants query topic-specific knowledge from web and GitHub.
Search Web Scraping Knowledge & Memory
211
trident A
io.github.alexeibespalov
Create and edit collaborative architecture diagrams with any AI assistant using the Trident 2D DSL.
Software Architecture Developer Tools
232

Related MCP Servers

excalidraw-architect-mcp
Design Tools Software Architecture Developer Tools
BV-Venky
A
license
B
quality
A
maintenance
An MCP server that generates beautiful Excalidraw architecture diagrams with perfect auto-layout, stateful editing, and architecture-aware component styling.
Updated 11 days ago (2026-08-25 19:10 UTC)
26
148
MIT
AI Charts
Software Architecture Developer Tools App Automation
tjameswilliams
A
license
Not graded
quality
D
maintenance
An MCP server that enables AI assistants to programmatically create and manage flowcharts, ERDs, and swimlane diagrams. It provides tools for manipulating diagram structures, performing auto-layouts, and exporting to Mermaid or Markdown formats.
Updated 6 months ago (2026-03-15 21:46 UTC)
12
MIT
Azure Diagram MCP Server
Cloud Platforms Software Architecture
Jah-yee
A
license
A
quality
D
maintenance
An MCP server that generates professional infrastructure diagrams using the Python diagrams DSL, with first-class Azure support and GitHub Copilot integration for natural language diagram generation.
Updated 6 months ago (2026-02-26 17:56 UTC)
4
MIT
noit-mcp-server
Software Architecture Developer Tools
Yuki-az-23
A
license
Not graded
quality
C
maintenance
An MCP server that enables AI agents to manage STAR-pattern architecture diagrams, creating, updating, listing, and building interactive viewers via tool calls.
Updated 2 months ago (2026-07-07 11:57 UTC)
MIT

Appeared in Searches

Architecture document drafting tool with format enforcement and diagram support

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/ColOfAbRiX/blueprint-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server