Visually design, automate, and diagnose complex workflows across protocols with a built-in Agentic AI Copilot. 7 core protocols ship in the binary; extend with one-click plugins. A cross-platform desktop app with a powerful CLI — all in one binary.
Current version: loading...
Visual debugging, AI tool evaluation, and automated end-to-end multi-protocol testing in one workspace.
Orchestrate multi-protocol DAGs from natural language prompts. Features slash shortcut commands (/fix, /explain, /test), interactive user choices (ask_user), quick AI provider switcher, configurable execution iteration limits (aiMaxIterations), secure sandboxed execution, and 1-click error self-healing.
Orchestrate workflows across three dedicated stages: Setup for pre-warming auth tokens, Main for pure business logic, and Teardown for alerts and cleanup with the read-only $report variable. Stress tests loop only Main to preserve pristine metrics.
Run selected subgraphs directly from the canvas via right-click (run_slice) with automatic zero-indegree entry derivation. Pause runs for human intervention using interactive input cards (ask_human) directly inside the execution panel.
mpe serveSimulate incoming webhook triggers and mock HTTP backends directly on canvas. http:ingress spins up an embedded HTTP server listener, http:respond returns customized dynamic responses, and mpe serve runs long-lived daemonized mock gateways with graceful SIGTERM teardown.
Natively host workflows as Model Context Protocol (MCP) tools via the built-in host engine and port 9528 shared gateway. Generate stdio configs for Claude Desktop & Cursor with one click, manage services in Settings, and debug remote MCP servers visually.
Connect HTTP triggers, Kafka queues, Redis caches, and SQL databases across a single canvas. Eliminate fragmented Python/Go test scripts.
Standardized exit codes (0/1/2/3), 3-stage aligned JUnit XML reports (--report junit), automatic GitHub Actions step summaries (--summary $GITHUB_STEP_SUMMARY), and self-contained interactive HTML reports (--export-html) plug straight into Jenkins, GitHub Actions, and GitLab CI.
Decouple environment sets (dev, staging, prod) into git-shared YAML files, paired with git-ignored .local.yaml private overrides for credentials. Features 4-tier cascading resolution, credential leak scanners, and headless CI management via mpe env.
Core protocols run out of the box; everything else installs with one command
GraphQL
Why modern engineering and QA teams choose MPE Flow over single-protocol tools
| Core Dimension | MPE Flow | Postman | Apache JMeter | Bruno |
|---|---|---|---|---|
| Multi-Protocol Chaining | ✓ Native HTTP, WS, TCP, UDP, SSE, GQL, Kafka, MCP | HTTP only (isolated WS tab) | Supported via complex sampler plugins | HTTP & basic GraphQL only |
| Workflow Lifecycle Stages | ✓ Native Setup / Main / Teardown with $report | Pre-request / test scripts only | setUp / tearDown Thread Groups | Pre-request / post-response scripts only |
| HTTP Ingress & Webhook Mock | ✓ Embedded http:ingress & http:respond | Paid cloud mock servers only | Complex custom HTTP sampler | ✗ Not Supported |
| Interactive Slice & HITL | ✓ Run Selected Nodes + ask_human cards | ✗ Not Supported | ✗ Not Supported | ✗ Not Supported |
| Engine & Resource Footprint | ⚡ Native Rust (Zero GC, <30MB RAM) | Electron (Heavy memory usage) | Java JVM (High RAM & GC pauses) | Electron / Node.js |
| Delivery & Mode | ✓ Single Binary (Desktop GUI + CLI) | Desktop App + Newman wrapper | Java GUI + Shell script | Desktop App + Bru CLI |
| MCP (Model Context Protocol) Eval | ✓ Native Visual Inspector & Assertions | ✗ Not Supported | ✗ Not Supported | ✗ Not Supported |
| Built-in Stress Testing | ✓ Native Tokio Async (p50/p90/p99 latency) | ✗ Paid cloud monitor only | ✓ Built-in (Thread-heavy) | ✗ Not Supported |
| Local-First & Data Sovereign | ✓ 100% Local Git-friendly .mpf files | ✗ Mandatory Cloud Account | ✓ Local XML/JMX | ✓ Local plain files |
| Built-in AI Copilot & Auto-Fix | ✓ Full-canvas Copilot (NL-to-DAG, auto-layout, autonomous run, 1-click error fix, code perception) | Postbot (HTTP-only, cloud account required, paid tier) | ✗ Not Supported | ✗ Not Supported |
| CI/CD Native Reporting | ✓ JUnit XML, JSON, HTML, Markdown | Newman CLI / JSON | JTL / HTML report | CLI text output |
Everything you need to know about MPE Flow architecture, protocols, and deployment.
The AI Copilot connects to any OpenAI-compatible provider (such as DeepSeek, OpenAI, Claude, or local Ollama instances) and interacts directly with the MPE Flow canvas via tool calling. It supports slash shortcut commands (/fix, /explain, /test), interactive user inquiries (ask_user), secure sandboxed terminal execution, full-trust autonomous execution, and one-click canvas error diagnosis and repair — with zero data lock-in and offline model support.
Workflows in MPE Flow are structured into three distinct lifecycle stages: Setup runs once before the test for login pre-warming and variable initialization; Main executes the core business flow (looped during stress testing); and Teardown runs once afterwards for cleanup and notifications, equipped with the read-only $report variable. The canvas switches stages with a dedicated top-left pill bar, and the debugger steps smoothly across all three stages.
MPE Flow (Multi-Protocol Flow Executor) is a high-performance visual workflow orchestration and integration testing engine built with Rust and Tauri. It enables engineers to chain and automate complex scenarios across HTTP, WebSocket, TCP, UDP, SSE, GraphQL, Kafka, and MCP in a single desktop application and standalone CLI.
MPE Flow includes 7 native core protocols inside the single binary: HTTP/HTTPS (client and embedded ingress/respond webhook mocks), WebSocket, TCP, UDP, SSE (Server-Sent Events), GraphQL, and Script/Assertion nodes. It also natively hosts Model Context Protocol (MCP) servers on a shared port (9528) or dedicated ports. Additional client protocols such as Kafka, MCP client tools, gRPC, Redis, MongoDB, SMTP, and IMAP are available through one-click sidecar plugins.
Unlike HTTP-centric tools like Postman, MPE Flow provides native first-class support for stateful protocols (TCP, WebSocket, SSE streams, Kafka pub/sub, MCP) with visual graph-based flow design, branching, variable extraction, assertion chains, first-class Setup/Main/Teardown lifecycle stages, and high-concurrency stress testing in a lightweight Rust binary.
Yes, MPE Flow is open source under the MIT License, hosted on GitHub at github.com/multi-protocol-flow.
Yes. MPE Flow ships as a dual-mode single binary containing both the GUI and the standalone mpe CLI. You can run mpe run flow.mpf -e staging --report junit --report-file results.xml --summary $GITHUB_STEP_SUMMARY --export-html report.html directly in GitHub Actions, GitLab CI, Jenkins, or Docker without GUI dependencies, with standardized exit codes (0/1/2/3).
MPE Flow runs natively on Windows (x64 installer & portable), macOS (Universal DMG for Intel & Apple Silicon), and Linux (both native GUI desktop apps via .deb & portable .AppImage packages, and lightweight standalone CLI binaries for headless servers and containers).
Join developers who trust MPE Flow for their integration testing and automation needs.
