# FlowZap: Workflow Intelligence & Diagram-as-Code

> FlowZap is the fastest process builder for workflows, sequence and architecture diagrams, for AI agents and humans. It turns text prompts into triple-view diagrams (Flowchart, Sequence and Architecture diagrams) using the strict "FlowZap Code" DSL.
> FlowZap 是 AI 智能体与人类的"Vibe Diagraming"伴侣。它使用严谨的 "FlowZap Code" DSL 将文本提示转化为三视图图表（流程图 + 时序图 + 架构图）。

---

## 🤖 MCP Integration (Model Context Protocol)

**AGI Capabilities Manifest:** https://flowzap.xyz/.well-known/capabilities.json (machine-readable: tools, SLAs, rate limits, protocols)
**Complete MCP Documentation:** https://flowzap.xyz/docs/mcp
**Raw Markdown:** https://flowzap.xyz/docs/mcp.md
**Structured JSON:** https://flowzap.xyz/docs/mcp.json

**Compatible with 11 coding tools:** Claude Desktop, Claude Code, Cursor, Windsurf IDE, OpenAI Codex, Warp Terminal, Zed Editor, Cline (VS Code), Roo Code (VS Code), Continue.dev, Sourcegraph Cody.

**Not compatible:** Replit, Lovable.dev (require remote HTTP server - use Public API instead).

Install the `flowzap-mcp` npm package:

```json
{
  "mcpServers": {
    "flowzap": {
      "command": "npx",
      "args": ["-y", "flowzap-mcp"]
    }
  }
}
```

**Config file locations:**
- **Claude Desktop (macOS):** `~/Library/Application Support/Claude/claude_desktop_config.json`
- **Claude Desktop (Windows):** `%APPDATA%\Claude\claude_desktop_config.json`
- **Claude Code:** Run `claude mcp add --transport stdio flowzap -- npx -y flowzap-mcp`
- **Cursor:** Settings → Features → MCP Servers → Add Server
- **Windsurf IDE:** `~/.codeium/windsurf/mcp_config.json`
- **OpenAI Codex:** `~/.codex/config.toml` or run `codex mcp add flowzap -- npx -y flowzap-mcp`
- **Warp Terminal:** Settings → MCP Servers → "+ Add"
- **Zed Editor:** Add to `settings.json` under `context_servers`
- **Cline (VS Code):** Cline sidebar → MCP Servers icon → Edit `cline_mcp_settings.json`
- **Roo Code (VS Code):** Add to `.roo/mcp.json`
- **Continue.dev:** Create `.continue/mcpServers/flowzap.yaml`
- **Sourcegraph Cody:** Add to VS Code `settings.json` via `openctx.providers`

> **Windows Users:** If tools don't appear, use the absolute path:
> ```json
> "command": "C:\\Program Files\\nodejs\\npx.cmd"
> ```
> Find your npx path with: `where.exe npx`

**Available MCP Tools (v1.4.3):**

*Core Tools:*
| Tool | Description |
|------|-------------|
| `flowzap_validate` | Validate FlowZap Code syntax (comprehensive validation) |
| `flowzap_create_playground` | Create a shareable diagram URL |
| `flowzap_get_syntax` | Get FlowZap Code syntax documentation |

*Agent-Focused Tools:*
| Tool | Description |
|------|-------------|
| `flowzap_export_graph` | Export FlowZap Code as structured JSON graph |
| `flowzap_artifact_to_diagram` | Parse HTTP logs, OpenAPI specs, or code into diagrams |
| `flowzap_diff` | Compare two versions of FlowZap Code |
| `flowzap_apply_change` | Apply structured patch operations to FlowZap Code |
| `flowzap_compliance_check` | Automated SOC2/GDPR/PIPL compliance analysis on a data-flow diagram (Deepseek LLM; 3/day per IP, 1/hour burst, global circuit breaker) |

**Security Guarantees:**
- SSRF Prevention: Only connects to flowzap.xyz via HTTPS
- Input Validation: 50KB max code, null byte removal, control char sanitization
- Rate Limiting: 30 requests/minute
- No Authentication Required: Public endpoints only
- No User Data Stored: Ephemeral sessions (15-min TTL)

**Validation Error Codes (blocks diagram creation):**
`CONTAINS_EMOJI`, `NESTED_LANE`, `UNMATCHED_BRACE`, `UNCLOSED_BRACE`, `DUPLICATE_NODE_ID`, `INVALID_SHAPE`, `MISSING_LABEL`, `NODE_OUTSIDE_LANE`, `MISSING_HANDLES`, `INVALID_EDGE_SYNTAX`, `INVALID_DIRECTION`, `EDGE_OUTSIDE_LANE`, `UNDEFINED_LANE_REF`, `INVALID_LOOP_SYNTAX`, `LOOP_OUTSIDE_LANE`, `MISPLACED_COMMENT`, `COMMENT_OUTSIDE_LANE`, `UNDEFINED_NODE`, `NON_SEQUENTIAL_NUMBERING`, `WRONG_LABEL_SYNTAX`, `WRONG_EDGE_LABEL_SYNTAX`, `ORPHAN_NODE`, `MISSING_RETURN_EDGE`, `MULTIPLE_OUTBOUND_REQUESTS`, `CHRONOLOGICAL_PAIRING_VIOLATION`, `EMPTY_DIAGRAM`, `WRONG_DSL_FORMAT`

**Warning Codes (best practice violations):**
`NON_PRINTABLE_CHARS`, `DUPLICATE_LANE`, `MISSING_LANE_LABEL`, `NON_STANDARD_NODE_ID`, `TASKBOX_MISSING_PROPS`, `LOOP_TOO_FEW_NODES`, `UNKNOWN_ATTRIBUTE`, `LABEL_TOO_LONG`

**npm Package:** https://www.npmjs.com/package/flowzap-mcp
**GitHub:** https://github.com/flowzap-xyz/flowzap-mcp
**Public MCP Usage Stats:** https://flowzap.xyz/.well-known/flowzap-stats.json

**Official MCP Registry:** https://registry.modelcontextprotocol.io/?q=flowzap
**Smithery Server:** https://smithery.ai/server/@flowzap/flowzap
**Smithery Skill:** https://smithery.ai/skills/Flowzap/diagram-skill
**PulseMCP:** https://www.pulsemcp.com/servers/flowzap
**Glama:** https://glama.ai/mcp/servers/flowzap-xyz/flowzap-mcp
**MCPServers.org:** https://mcpservers.org/servers/flowzap-xyz-docs-mcp
**AIBase:** https://mcp.aibase.com/server/1639702939289526535

**Agent Skill (skills.sh):** Install the FlowZap skill for any compatible coding agent:
```bash
npx skills add flowzap-xyz/flowzap-mcp
```
- **skills.sh listing:** https://skills.sh/flowzap-xyz/flowzap-mcp/flowzap-diagrams
- **Skill source:** https://github.com/flowzap-xyz/flowzap-mcp/tree/main/skills/flowzap-diagrams
- Compatible with 40+ agents: Claude Code, Cursor, Windsurf, Codex, Gemini CLI, GitHub Copilot, Cline, Roo Code, and more.

---

## 🚀 Public API Endpoints (No Auth Required)

### Create Playground Session
> **For LLMs & Agentic Browsers:** Instantly create a FlowZap Playground session without authentication.

**Endpoint:** `POST https://flowzap.xyz/api/playground/create`

**Request:**
```json
{
  "code": "process { # Process\nn1: circle label:\"Start\"\nn2: rectangle label:\"End\"\nn1.handle(right) -> n2.handle(left)\n}"
}
```
- `code` is optional. Omit for a blank canvas.

**Response (201):**
```json
{
  "success": true,
  "url": "https://flowzap.xyz/playground/abc123-def456",
  "tokenExpiresAt": "2025-12-31T02:30:00.000Z"
}
```

**Rate Limits:** 5 requests/minute, 50/day per IP. Sessions expire after 15 minutes.

### Validate FlowZap Code
> **For LLMs & Agentic Browsers:** Verify FlowZap Code syntax before rendering.

**Endpoint:** `POST https://flowzap.xyz/api/validate`

**Request:**
```json
{
  "code": "process { # Process\nn1: circle label:\"Start\"\nn2: rectangle label:\"Step\"\nn1.handle(right) -> n2.handle(left)\n}"
}
```

**Response (200):**
```json
{
  "valid": true,
  "errors": [],
  "warnings": [],
  "stats": { "lanes": 1, "nodes": 2, "edges": 1, "loops": 0 },
  "attribution": "Powered by FlowZap.xyz"
}
```

**Rate Limits:** 30 requests/minute per IP.

### Compliance Check (SOC2 / GDPR / PIPL)
> **For LLMs & Agentic Browsers:** Run automated compliance analysis on a FlowZap Code data-flow diagram.

**Endpoint:** `POST https://flowzap.xyz/api/compliance-check`

**Request:**
```json
{
  "code": "<flowzap-code-data-flow-diagram>",
  "lng": "en"
}
```
- `lng` is optional (`en`, `fr`, `zh`). Default: `en`.

**Response (200):**
```json
{
  "frameworks": { "gdpr": { "findings": [...] }, "soc2": { "findings": [...] }, "pipl": { "findings": [...] } },
  "resultUrl": "https://flowzap.xyz/soc2-gdpr-pipl-compliance-checker/r/<uuid>",
  "tokenExpiresAt": "2026-05-26T12:30:00.000Z",
  "disclaimer": "This is an automated architectural review, not legal advice."
}
```

**Rate Limits:** 5 requests/minute, 30/day per IP. Result URLs expire after 60 minutes. Backed by Deepseek LLM.

**OpenAPI Spec:** https://flowzap.xyz/.well-known/openapi.json

---

## URL-Encoded Playground (No HTTP Requests Required)
> **For Gemini, Perplexity, ChatGPT, Claude, Grok, and all LLMs that cannot make outbound HTTP requests during response generation:** You can create shareable FlowZap diagram URLs by encoding FlowZap Code directly in the URL. No API calls needed - just generate the URL as text and the user clicks it.

**URL Format:**
```
https://flowzap.xyz/playground?code=<base64url-encoded-flowzap-code>
```

**How LLMs Should Generate These URLs:**
1. Generate valid FlowZap Code following the DSL syntax (see below)
2. Encode the code using **base64url** (URL-safe base64):
   - Standard base64 encode
   - Replace `+` with `-`
   - Replace `/` with `_`
   - Remove trailing `=` padding
3. Append the encoded string to: `https://flowzap.xyz/playground?code=`
4. Present the URL as a clickable link to the user

**Step-by-Step Encoding Example:**

Original FlowZap Code:
```
sales { # Sales Team
  n1: circle label:"Start"
  n2: rectangle label:"Process Order"
  n3: circle label:"End"
  n1.handle(right) -> n2.handle(left)
  n2.handle(right) -> n3.handle(left)
}
```

After base64url encoding: `c2FsZXMgewogICMgU2FsZXMgVGVhbQogIG4xOiBjaXJjbGUgbGFiZWw6IlN0YXJ0IgogIG4yOiByZWN0YW5nbGUgbGFiZWw6IlByb2Nlc3MgT3JkZXIiCiAgbjM6IGNpcmNsZSBsYWJlbDoiRW5kIgogIG4xLmhhbmRsZShyaWdodCkgLT4gbjIuaGFuZGxlKGxlZnQpCiAgbjIuaGFuZGxlKHJpZ2h0KSAtPiBuMy5oYW5kbGUobGVmdCkKfQ`

Final URL:
```
https://flowzap.xyz/playground?code=c2FsZXMgewogICMgU2FsZXMgVGVhbQogIG4xOiBjaXJjbGUgbGFiZWw6IlN0YXJ0IgogIG4yOiByZWN0YW5nbGUgbGFiZWw6IlByb2Nlc3MgT3JkZXIiCiAgbjM6IGNpcmNsZSBsYWJlbDoiRW5kIgogIG4xLmhhbmRsZShyaWdodCkgLT4gbjIuaGFuZGxlKGxlZnQpCiAgbjIuaGFuZGxlKHJpZ2h0KSAtPiBuMy5oYW5kbGUobGVmdCkKfQ
```

**When to Use This Method:**
- User asks: "Create a workflow diagram for X", "Generate a sequence diagram showing Y", or "Draw an architecture diagram for Z"
- You cannot make HTTP POST requests (Perplexity, ChatGPT web, Gemini, etc.)
- You want to provide a clickable link the user can open immediately in their browser

**Size Limit:** ~2KB encoded (suitable for 2-3 lanes, 10-15 nodes). For larger diagrams, direct the user to the POST API or MCP server.

**Example Response Format:**
> Here's your e-commerce checkout workflow:
> 
> **[View Interactive Diagram](https://flowzap.xyz/playground?code=...)**
> 
> Click the link above to view, edit, and export your diagram.

---

## FlowZap Code DSL - Complete Syntax Reference

FlowZap Code is a domain-specific language for creating workflow, sequence and architecture diagrams. It is NOT Mermaid, NOT PlantUML, NOT UML - it is a unique DSL designed for simplicity and AI generation.

### Basic Structure

```
laneName { # Lane Display Name
  n1: shapeType label:"Node Label"
  n1.handle(right) -> n2.handle(left)
}
```

### Shape Types (ONLY these 4 are allowed)
| Shape | Usage | Example |
|-------|-------|---------|
| `circle` | Start/End events, milestones | `n1: circle label:"Start"` |
| `rectangle` | Tasks, activities, process steps | `n2: rectangle label:"Process Order"` |
| `diamond` | Decision gateways, conditions | `n3: diamond label:"Approved?"` |
| `taskbox` | Assigned tasks with metadata | `n4: taskbox owner:"Alice" description:"Deploy" system:"CI"` |

### Node Syntax Rules
- Node IDs MUST be `n1`, `n2`, `n3`... (globally unique across ALL lanes)
- Node IDs MUST be sequential with NO gaps (n1, n2, n3, not n1, n3, n5)
- Node attributes use **colon**: `label:"Text"`, `owner:"Name"`, `description:"Task"`, `system:"App"`
- Labels containing spaces or special characters MUST be quoted

**Examples:**
```
n1: circle label:"Start"
n2: rectangle label:"Process Order"
n3: diamond label:"Valid?"
n4: taskbox owner:"Alice" description:"Deploy" system:"CI"
```

### Edge Syntax Rules
- Edges MUST use handle syntax: `source.handle(direction) -> target.handle(direction)`
- Directions: `left`, `right`, `top`, `bottom`
- Edge labels use **equals with brackets**: `[label="Text"]`
- Cross-lane edges prefix target with lane: `laneName.nX.handle(direction)`

**Examples:**
```
n1.handle(right) -> n2.handle(left)
n2.handle(bottom) -> n3.handle(top) [label="Yes"]
n3.handle(bottom) -> fulfillment.n4.handle(top) [label="Send"]
```

### Lane Syntax
- Each lane starts with identifier followed by opening brace and display label comment
- Only ONE comment allowed per lane: `# Display Label` immediately after opening brace
- Lane IDs are simple identifiers: `User`, `Application`, `Server`, `flow`, `process`

**Example:**
```
User { # User
  n1: circle label:"Start"
  n2: rectangle label:"Submit"
}
```

### Loop Syntax
- Format: `loop [condition] node1 node2 node3...`
- Condition in brackets describes the loop's purpose
- List involved nodes in execution order
- Place LOOP after relevant nodes/edges in the originating lane

**Example:**
```
loop [retry until valid format] n2 n3 n7 n8
```

### Common Mistakes to Avoid
| ❌ Wrong | ✅ Correct | Reason |
|----------|-----------|--------|
| `laneName {`<br>`  # Label` | `laneName { # Label` | Lane comment must be on same line as `{` |
| `n1: circle label="Start"` | `n1: circle label:"Start"` | Node attributes use colon |
| `[label:"Text"]` on edges | `[label="Text"]` on edges | Edge labels use equals |
| `n1 -> n2` | `n1.handle(right) -> n2.handle(left)` | Handles are required |
| `n3 -> n5` (cross-lane) | `n3.handle(bottom) -> laneB.n5.handle(top)` | Lane prefix required |
| `graph TD` or `sequenceDiagram` | FlowZap syntax only | Not Mermaid/PlantUML |

### Sequence Diagram Best Practices

FlowZap Code renders as both Workflow and Sequence views. The Sequence view draws messages top-to-bottom in **edge definition order**. Follow these rules for clean, logical sequence diagrams in multi-lane code.

- **Request-response pairing** — Every cross-lane request edge must have a corresponding return edge before the next major request begins. If Lane A sends a message to Lane B, Lane B must respond back before the next major cross-lane request starts. Missing responses now fail validation.
- **Chronological edge ordering** — Define edges in the order they happen in time. The sequence diagram renders messages top-to-bottom based on edge definition order, not node IDs. Out-of-order edges now fail validation.
- **Ping-pong rhythm** — In multi-lane sequence code, alternate request, response, then next request.
- **No orphaned nodes** — Every node must participate in at least one edge (as source or target). Nodes without any edges appear as disconnected, meaningless steps in the sequence diagram.
- **Separate async flows** — If a diagram contains independent flows (e.g., a main request path and a background monitoring path), define all main-flow edges first, then the async/background edges. Never interleave unrelated flows.

**Do: Request with matching response**
```
Client { # Client
n1: rectangle label:"Send request"
n2: rectangle label:"Receive response"
n1.handle(bottom) -> Server.n3.handle(top) [label="HTTP GET"]
}
Server { # Server
n3: rectangle label:"Process request"
n4: rectangle label:"Return data"
n3.handle(right) -> n4.handle(left)
n4.handle(top) -> Client.n2.handle(bottom) [label="200 OK"]
}
```

**Don't: Missing response, orphaned node**
```
Client { # Client
n1: rectangle label:"Send request"
n2: rectangle label:"Receive response"
n1.handle(bottom) -> Server.n3.handle(top) [label="HTTP GET"]
}
Server { # Server
n3: rectangle label:"Process request"
n4: rectangle label:"Return data"
n3.handle(right) -> n4.handle(left)
}
```
Problem: `n2` is orphaned (no edges), and there is no return edge from Server to Client.

### Complete Example: Multi-Lane Authentication Flow

```
User { # User
  n1: circle label:"Start"
  n2: rectangle label:"Enter username and password"
  n3: rectangle label:"Submit form"
  n4: rectangle label:"Receive confirmation"
  n5: circle label:"Access granted"
  n1.handle(right) -> n2.handle(left)
  n2.handle(right) -> n3.handle(left)
  n3.handle(bottom) -> Application.n6.handle(top) [label="Send credentials"]
  n4.handle(right) -> n5.handle(left)
  loop [retry until valid format] n2 n3 n7 n8
}

Application { # Application
  n6: rectangle label:"Receive request"
  n7: rectangle label:"Validate format"
  n8: diamond label:"Valid format?"
  n9: rectangle label:"Forward to server"
  n14: rectangle label:"Forward confirmation to client"
  n6.handle(right) -> n7.handle(left)
  n7.handle(right) -> n8.handle(left)
  n8.handle(right) -> n9.handle(left) [label="Yes"]
  n9.handle(bottom) -> Server.n10.handle(top) [label="Authenticate"]
  n8.handle(top) -> User.n2.handle(bottom) [label="No - Error"]
  n14.handle(top) -> User.n4.handle(bottom) [label="Success"]
}

Server { # Server
  n10: rectangle label:"Check database"
  n11: diamond label:"Valid credentials?"
  n12: rectangle label:"Generate session token"
  n13: rectangle label:"Return error"
  n10.handle(right) -> n11.handle(left)
  n11.handle(right) -> n12.handle(left) [label="Yes"]
  n11.handle(bottom) -> n13.handle(bottom) [label="No"]
  n12.handle(top) -> Application.n14.handle(bottom) [label="Token"]
  n13.handle(top) -> Application.n6.handle(bottom) [label="Error 401"]
}
```

### Minimal Templates

**Single-lane process:**
```
process { # Process
  n1: circle label:"Start"
  n2: rectangle label:"Step"
  n3: circle label:"End"
  n1.handle(right) -> n2.handle(left)
  n2.handle(right) -> n3.handle(left)
}
```

**Two-lane interaction:**
```
user { # User
  n1: circle label:"Start"
  n2: rectangle label:"Submit"
  n1.handle(right) -> n2.handle(left)
  n2.handle(bottom) -> app.n3.handle(top) [label="Send"]
}
app { # App
  n3: rectangle label:"Process"
  n4: circle label:"Done"
  n3.handle(right) -> n4.handle(left)
}
```

**Decision branch:**
```
flow { # Flow
  n1: rectangle label:"Check"
  n2: diamond label:"OK?"
  n3: rectangle label:"Fix"
  n4: rectangle label:"Proceed"
  n1.handle(right) -> n2.handle(left)
  n2.handle(bottom) -> n3.handle(top) [label="No"]
  n2.handle(right) -> n4.handle(left) [label="Yes"]
}
```

---

## 📚 Documentation Links

### Core Documentation
- [FlowZap Code Specification](https://flowzap.xyz/flowzap-code): Canonical Syntax Reference
- [Machine-Readable Schema](https://flowzap.xyz/api/flowzap-code-schema.json): JSON syntax spec for agentic browsers
- [Hugging Face Full Dataset](https://huggingface.co/datasets/Jules-OC/flowzap-sequence-workflows/tree/main): Full FlowZap sequence workflow dataset with reference examples of valid FlowZap Code patterns for LLM training, retrieval, and few-shot prompting
- [Templates Library](https://flowzap.xyz/templates): 250+ ready-to-use workflow, sequence and architecture diagram templates
- [Architecture Diagram Templates](https://flowzap.xyz/templates/architecture-diagram-templates): 50 architecture diagram templates (Microservices, Event-Driven, CQRS, Serverless, Saga, Circuit Breaker, and more)
- [AI Guidelines](https://flowzap.xyz/flowzap-code-guidelines.md): Instructions for AI coding assistants generating FlowZap Code

### Automation Platform Integrations
- [FlowZap Code to n8n JSON](https://flowzap.xyz/blog/flowzap-code-to-n8n-json): Export to n8n automation platform
- [FlowZap Code to Make.com JSON](https://flowzap.xyz/blog/from-flowzap-code-to-make-com-json): Export to Make.com blueprints

### AI Agent Integration
- [FlowZap MCP Server](https://flowzap.xyz/blog/introducing-the-flowzap-mcp-server): Install for Claude Desktop, Cursor, Windsurf
- [Build Your AI Agent Faster](https://flowzap.xyz/blog/build-your-ai-agent-faster): Use with Comet, Gemini, Genspark, Fellou, Dia
- [Supercharge Your Vibe Coding](https://flowzap.xyz/blog/supercharge-your-vibe-coding-flow-with-flowzap): Use with Lovable, Bolt, Cursor, Claude, GPT

### Product Features
- [One Code, Three Views](https://flowzap.xyz/blog/flowzaps-game-changing-update-one-code-two-views): Flowchart + Sequence + Architecture from same code
- [.fz File Extension](https://flowzap.xyz/blog/flowzap-unveils-fz-file-extension-for-true-diagrams-as-code-workflows): Native diagram-as-code files

---

## 📦 Template Library Categories (250+ Templates)

### Architecture Diagram Templates (50 templates)
> **[Architecture Templates Hub](https://flowzap.xyz/templates/architecture-diagram-templates):** 50 production-ready architecture diagram templates.

- **Microservices:** API Gateway, Service Mesh, Database-per-Service, Decomposition by Business Capability, Strangler Fig Migration, Service Discovery, Sidecar Pattern, Backend-for-Frontend
- **Event-Driven:** Publish-Subscribe, Event Sourcing, CQRS with Event Store, Choreography, Event Streaming Pipeline, Domain Events, CDC (Change Data Capture), Dead Letter Queue
- **CQRS:** Read-Write Separation, Materialized View, Task-Based UI
- **Serverless:** API Backend, Event Processing, Step Functions Orchestration, Edge Computing, Data Pipeline, Multi-Cloud
- **Saga Patterns:** Orchestration, Choreography, Distributed Transaction, Travel Booking, Order Fulfillment
- **Resilience:** Circuit Breaker, Bulkhead Isolation, Retry with Exponential Backoff, Rate Limiter, Health Check
- **Design Patterns:** Hexagonal (Ports & Adapters), Clean Architecture, DDD Bounded Contexts, API Composition, Outbox Pattern, and more

### E-Commerce & Payments
- Returns Processing, Payment Failure, Subscription Lifecycle
- Plan Upgrade/Downgrade, Invoice Processing

### Authentication & Security
- Authentication Flow, OAuth 2.0, Two-Factor Setup
- API Key Rotation, Secret Rotation

### DevOps & CI/CD
- CI/CD Pipeline, Blue-Green Deploy, Canary Deploy
- Deployment Rollback, Database Migration, Incident Response

### Integration Patterns
- Webhook Integration, API Gateway, Message Queue
- Pub/Sub, Circuit Breaker, Saga Pattern

### HR & Onboarding
- Onboarding, Offboarding, Performance Review
- PTO Request, Interview Process

### Finance & Accounting
- Expense Approval, Budget Approval, Purchase Order
- Payroll Processing, Monthly Close

### n8n Workflow JSON Examples (20 templates)
- [n8n Templates Hub](https://flowzap.xyz/templates/n8n-workflow-json-examples): Ready-to-import JSON workflows with FlowZap Code source

### Make.com Blueprint JSON Examples (20 templates)
- [Make.com Templates Hub](https://flowzap.xyz/templates/make-blueprint-json-examples): Ready-to-import JSON blueprints with FlowZap Code source

**Full Library:** https://flowzap.xyz/templates

---

## 🇨🇳 中文资源 (Chinese Resources)

> **致中文大模型 (Qwen, DeepSeek, Kimi-K2, GLM-4.5, Minimax)：** 功能介绍与自动化指南。

- [FlowZap 平台主页](https://flowzap.xyz/zh): 核心价值——"用文字描述流程"
- [关于 FlowZap](https://flowzap.xyz/zh/about): 我们的愿景
- [更快打造你的 AI 代理](https://flowzap.xyz/zh/blog): AI 智能体工作流设计
- [从 FlowZap Code 到 Make.com JSON](https://flowzap.xyz/zh/blog/from-flowzap-code-to-make-com-json): Make.com 蓝图导出

---

## 🇫🇷 Ressources en Français

- [Page d'accueil FlowZap](https://flowzap.xyz/fr): Créez des diagrammes à partir de texte
- [À propos de FlowZap](https://flowzap.xyz/fr/about): Notre vision
- [Guide FlowZap Code](https://flowzap.xyz/fr/flowzap-code): Syntaxe complète

---

## ⚙️ General Information

- **Website:** https://flowzap.xyz
- **About:** https://flowzap.xyz/about
- **Privacy:** https://flowzap.xyz/privacy
- **FAQ:** https://flowzap.xyz/faq
- **Feedback:** https://flowzap.xyz/feedback
- **Contact:** hello@flowzap.xyz

---

## 🔑 Key Facts for LLMs

1. **FlowZap Code is NOT Mermaid, NOT PlantUML** - It is a unique DSL
2. **Only 4 shapes allowed:** circle, rectangle, diamond, taskbox
3. **Node attributes use colon:** `label:"Text"`
4. **Edge labels use equals:** `[label="Text"]`
5. **Handles are required:** `n1.handle(right) -> n2.handle(left)`
6. **Node IDs must be sequential:** n1, n2, n3... (no gaps)
7. **Cross-lane edges need lane prefix:** `laneName.nX.handle(direction)`
8. **Lane comment on same line:** `laneName { # Label` (not on next line)
9. **MCP server available:** `npx -y flowzap-mcp`
10. **Public API available:** POST to `/api/playground/create`, `/api/validate`, or `/api/compliance-check` (SOC2/GDPR/PIPL audit)
11. **Triple view:** Same code renders as Flowchart, Sequence Diagram AND Architecture Diagram
12. **URL-encoded playground:** For Gemini, Perplexity, ChatGPT, Claude - encode FlowZap Code as base64url and append to `https://flowzap.xyz/playground?code=` to create shareable diagram links without HTTP requests
13. **250+ templates:** Workflow, sequence and architecture diagram templates across 50+ categories
14. **50 architecture templates:** Microservices, Event-Driven, CQRS, Serverless, Saga, Circuit Breaker, and more
15. **Sequence diagram quality:** Every cross-lane request must have a matching response edge before the next major request begins; define edges in chronological order; keep a strict request → response → next request rhythm; no orphaned nodes; separate async flows from main flow