ajibawa-2023/Technical-Architectures-Large

Technical Architectures Large (294k Samples)

---

Overview

Generating complex, syntactically valid diagram code from natural language requirements is a major challenge for AI models. This dataset bridges that gap by providing over 293,000+ distinct enterprise software architectures generated using two cutting-edge models: GPT-OSS-120B and Qwen3-Coder-Next-FP8.

Unlike simple "toy" examples, these architectures model realistic enterprise systems complete with client layers, edge security, API gateways, service meshes, compliance boundaries, and multi-cloud infrastructure topologies.

---

Key Dataset Statistics

Metric	Detail
Total Samples	~210,000 validated architecture diagrams
Generating Models	gpt-oss-120b, qwen3-coder-next-fp8
Data Format	JSON Lines (.jsonl)
Industry Domains	42 categories (FinTech, MLOps, Cyber Security, Healthcare, etc.)
Architecture Styles	8 paradigms (Microservices, Event-Driven, Zero-Trust, CQRS, etc.)
Cloud Infrastructure	6 targets (AWS, Azure, GCP, Multi-Cloud, Hybrid, On-Premises)
Complexity Tiers	Small, Medium, Large, Enterprise
Supported Diagrams	flowchart LR, flowchart TB, sequenceDiagram, stateDiagram-v2, erDiagram, classDiagram, gitGraph, mindmap, timeline

---

Data Schema

Each row in the .jsonl dataset represents a self-contained architecture specification with rich structural and execution metadata:

Field Name	Data Type	Description
id	Integer	Unique sequential identifier for the generation.
domain	String	The industry vertical targeted by the architecture.
style	String	The overarching software engineering design paradigm.
cloud	String	The target deployment infrastructure environment.
target_complexity	String	The intended structural scale (Small, Medium, Large, Enterprise).
constraints	Array[String]	2 to 5 production requirements dynamically injected into the prompt.
model	String	The exact AI model used to generate the sample (gpt-oss-120b or qwen3-coder-next-fp8).
input_tokens	Integer	Total token count of the system and user prompt.
output_tokens	Integer	Total token count of the generated Mermaid code block.
finish_reason	String	Generation termination flag (strictly filtered to "stop").
nodes	Integer	Absolute count of unique architectural entities and subgraphs.
edges	Integer	Total number of directional connections and data flows.
diagram_type	String	The validated standard Mermaid schema declaration.
mermaid	String	The raw, production-grade Mermaid.js source code.

Sample JSON Record

{
  "domain": "Fraud Detection",
  "style": "CQRS",
  "cloud": "AWS",
  "target_complexity": "Large",
  "constraints": [
    "Active-Active Multi-Region",
    "Observability Stack",
    "AI/ML Inference Integration",
    "Feature Flags",
    "Data Lakehouse Pattern"
  ],
  "model": "gpt-oss-120b",
  "input_tokens": 521,
  "output_tokens": 1870,
  "finish_reason": "stop",
  "id": 9,
  "nodes": 95,
  "edges": 112,
  "diagram_type": "flowchart LR",
  "mermaid": "flowchart LR\n  %% Client Layer\n  subgraph CLIENT\n    WebUI[Web UI]\n    MobileApp[Mobile Apps]\n    AdminPortal[Admin Portal]\n    APIConsumers[API Consumers]\n  end\n  %% Network & Edge Layer\n  subgraph NETWORK\n    CDN[CDN] --> WAF[Web Application Firewall]\n    WAF --> APIGW[API Gateway]\n  end\n  CLIENT --> NETWORK\n  %% Core CQRS Read/Write Services\n  subgraph CORE\n    APIGW --> WriteAPI[Command Service]\n    APIGW --> ReadAPI[Query Service]\n    WriteAPI --> Kafka((Apache Kafka))\n  end\n  %% AI & Analytics Lakehouse\n  subgraph AI_ML\n    Kafka --> Flink[Apache Flink Stream]\n    Flink --> VectorDB[(Milvus Vector DB)]\n    VectorDB --> Model[Fraud Scoring Agent]\n  end\n  Model -.->|Scoring Events| ReadAPI"
}

---

Generation & Curation Pipeline

To achieve enterprise-grade quality across 200,000+ samples without degradation or repetition, the dataset was synthesized using an advanced generation architecture:

1. High-Throughput Continuous Batching

• Hardware: 2× NVIDIA H100 NVL (94GB VRAM) GPUs connected via NVLink.
• Inference Engine: Powered by vLLM using tensor_parallel_size=2 and bfloat16 precision.
• Memory Optimization: Configured with GPU_MEMORY_UTIL = 0.92 and a compact max_model_len = 8192. This aggressive memory allocation enabled concurrent batching of 512 prompts simultaneously per generation step without out-of-memory crashes.

2. Dynamic Constraint Injection

To avoid structural repetition, every prompt dynamically combines weighted selections from:

• 42 Industry Verticals: Covering specialized domains like Autonomous Vehicles, Digital Twins, Cyber Security, FinTech, and Agentic AI.
• 8 Architectural Styles: Forcing distinct topologies (e.g., Event-Driven, Hexagonal, Data Mesh).
• Randomized Technical Constraints: Injecting 2 to 5 real-world engineering hurdles per prompt (e.g., 100k+ TPS High Throughput, Strict Network Segmentation, GraphRAG Integration, Zero-Trust Perimeter).

3. Rigorous Multi-Stage Validation

Generated outputs passed through an automated quality filter before being committed to the dataset:

• Syntax & Truncation Verification: Rejection of diagrams with mismatched brackets ({}, [], ()), unclosed subgraphs, or missing end declarations.
• Density Thresholds: Enforcement of strict minimums (at least 4 unique nodes and 2 directional edges per diagram).
• Length Guard: Any sequence terminated by token exhaustion (finish_reason == "length") was automatically discarded.
• True Retry Queue: Failed or truncated outputs were dynamically re-queued with fallback sampling parameters (higher temperature and top_p) to encourage structural resolution.

---

How to Use the Dataset

Loading with Hugging Face datasets

You can stream or load the dataset directly in Python using the official Hugging Face datasets library:

from datasets import load_dataset

# Load the dataset
dataset = load_dataset("ajibawa-2023/Technical-Architectures-Large", split="train")

# Print the first sample
print(dataset[0]["domain"])
print(dataset[0]["mermaid"])

Filtering by Complexity and Domain

Because the metadata is stored as tabular fields, you can easily filter samples for targeted SFT or RAG tasks:

# Filter for complex Enterprise Cyber Security or MLOps diagrams
enterprise_ai = dataset.filter(
    lambda x: x["target_complexity"] == "Enterprise" 
    and x["domain"] in ["MLOps", "Cyber Security", "Agentic AI"]
    and x["nodes"] > 50
)

print(f"Found {len(enterprise_ai)} enterprise-grade AI architectures.")

Exporting for Supervised Fine-Tuning (SFT)

To train an LLM to act as an automated software architect, map the schema into standard instruction-response pairs:

def format_for_sft(example):
    prompt = (
        f"Design a {example['target_complexity']}-scale {example['style']} "
        f"enterprise architecture for the {example['domain']} domain hosted on {example['cloud']}.\n"
        f"Key requirements: {', '.join(example['constraints'])}."
    )
    return {
        "instruction": prompt,
        "response": f"```mermaid\n{example['mermaid']}\n```"
    }

sft_dataset = dataset.map(format_for_sft)

---

Intended Use Cases

• Code LLM Fine-Tuning: Training base code models to master standard Mermaid diagram syntax and complex spatial graph relationships.
• Automated System Design: Building AI co-pilots capable of translating PRDs (Product Requirement Documents) or cloud RFP specifications into visual architecture diagrams.
• Benchmarking & Evaluation: Testing LLM reasoning capabilities by evaluating whether generated graphs properly respect strict topological constraints (e.g., verifying that a "Zero-Trust" prompt correctly isolates public web traffic from internal databases).

---

Citation & License

If you use this dataset in your research, training runs, or open-source projects, please credit the repository:

@misc{technical_architectures_large_2026,
  author       = {ajibawa-2023},
  title        = {Technical Architectures Large},
  year         = {2026},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/datasets/ajibawa-2023/Technical-Architectures-Large}}
}