L2M
Triggers workflows from signed Discord webhook events with Ed25519 signature validation.
Syncs workflows and variables with Git repositories via push/pull source control integration.
Triggers workflows from signed GitHub webhooks.
Supports using Google Gemini models as LLM providers in workflows and agents.
Supports using Ollama local models as LLM providers in workflows and agents.
Supports using OpenAI models as LLM providers in workflows and agents.
Exposes runtime and workflow metrics for Prometheus scraping and monitoring.
Triggers workflows from RSS feeds.
Streams workflow and runtime logs to Sentry.
Triggers workflows from signed Slack webhooks.
Triggers workflows from signed Stripe webhooks and validates Stripe webhook signatures.
Triggers workflows from signed Telegram webhook events.
Allows using HashiCorp Vault as an external secret provider for encrypted secrets and rotation.
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
L2M
The MCP-native agent runtime. Visual workflow builder, multi-agent Swarm, and a first-party VS Code surface — for developers composing AI agents that do real work in real systems via the Model Context Protocol.
🌐 lsquarem.com · 📚 Docs · 🚀 5-minute tutorial · 🧩 Patterns · 🔬 Sample projects
Learn MCP and AI agents
Free guides on lsquarem.com/docs/learn, written from building L2M. They're useful whether or not you use it:
What is MCP?: hosts, clients, servers, tools and transports
What is an AI agent?: the tool-calling loop, step by step
Regression testing agents from recorded runs
Also: the Glossary, ready-to-import Recipes and the Blog.
Related MCP server: mlua-swarm
What makes it different
MCP-first. Wire any MCP server into an agent as a tool. The runtime compacts tool descriptions and schemas, and caches full tool outputs across multi-turn sessions so models stay grounded without re-calling expensive endpoints. You can also expose your own workflows back out as MCP tools that other agents invoke (
mcp_server_trigger).Multi-agent Swarm. Compose Supervisor → Worker hierarchies via dedicated attachment ports. Workers are exposed to the parent as synthetic tools, recursively. Other visual workflow tools either lack MCP integration entirely or treat agent delegation as chained prompts rather than first-class topology.
VS Code agent surface. First-party extension at
apps/vscode-l2m-agentturns any workflow into a coding agent inside the editor — streaming responses, patch previews with workspace-path safety, command approval, and bounded context bundling.
Plus the production basics: SAML/LDAP SSO, MFA/TOTP, encrypted secrets with rotation, external secret providers (Vault, AWS, GCP, Azure), RBAC + projects + custom roles, comprehensive audit log, Prometheus metrics, OTEL tracing, multi-main HA via leader election, Postgres or SQLite, Helm chart, Docker Compose prod template, and webhook signature validation (HMAC, Stripe, Discord Ed25519, Telegram).
What's in the box
Drag-and-drop node editor (
React Flow) with mini-map, multi-select, copy/paste/duplicate, undo/redo, sticky notes, dark mode, and a keyboard shortcut panelWorkflow CRUD with import/export, duplication, projects, folders, tags, search, debug replay, pinned node data, single-node execution, and streaming execution progress
Runtime: sub-workflows, flow-control nodes, queue-backed execution with DLQ, per-node retry/continue-on-fail, error workflows, parallel-branch execution, and binary-data passthrough
Triggers: schedule, webhook, form, chat, file, RSS, SSE, MCP-server, manual, and signed Slack/GitHub/Stripe/Telegram/Discord webhooks
LLM providers: OpenAI, Azure OpenAI, Anthropic, Gemini, Ollama, and OpenAI-compatible endpoints
MCP adapters:
http_mcp(remote streamable HTTP) andmock-mcp(local demo tools)RAG: chunking, embeddings, in-memory + Azure AI Search + Qdrant + Pinecone + PGVector + Chroma + Weaviate retrievers
50+ data-transformation, code, crypto, JWT, XML/HTML, file, and compression nodes
Source control sync (Git push/pull workflows + variables), workflow versioning, log streaming (Syslog/Webhook/Sentry), and a Settings UI for everything
For the GA roadmap, see the public project board.
Architecture overview
Frontend (
apps/web): React + TypeScript + React FlowBackend (
apps/api): Fastify + TypeScriptProduct docs (
apps/docs): VitePress documentation siteDB: SQLite by default using
sql.js(persisted toapps/api/data/orchestrator.db) or PostgreSQL viaDB_TYPE=postgresBackground services: scheduler service, trigger service, and in-process execution queue with persisted queue/DLQ tables
Shared contracts:
packages/sharedRuntime/SDK packages:
packages/provider-sdkpackages/mcp-sdkpackages/connector-sdkpackages/agent-runtimepackages/workflow-engine
Monorepo structure
.
+- apps/
| +- api/
| | +- src/
| | | +- app.ts
| | | +- index.ts
| | | +- db/database.ts
| | | +- services/
| | +- Dockerfile
| +- web/
| | +- src/
| | | +- App.tsx
| | | +- styles.css
| | | +- lib/
| | +- Dockerfile
| | +- nginx.conf
| +- docs/
| +- docs/
| | +- .vitepress/config.ts
| | +- index.md
| +- package.json
+- packages/
| +- shared/
| +- provider-sdk/
| +- mcp-sdk/
| +- connector-sdk/
| +- agent-runtime/
| +- workflow-engine/
+- samples/workflows/
| +- basic-flow.json
| +- conditional-flow.json
| +- rag-flow.json
| +- rag-pinecone-flow.json
| +- agentic-mcp-flow.json
| +- structured-output-flow.json
| +- azure-openai-flow.json
| +- azure-connectors-demo-flow.json
+- docs/
| +- (legacy static site)
+- docker-compose.yml
+- .env.example
+- README.mdSetup (local)
Prerequisites
Node.js 24+
pnpm 10+
Optional for local LLM: Ollama running at
http://localhost:11434/v1
1) Configure environment
cp .env.example .envGenerate a master key and put it in .env as SECRET_MASTER_KEY_BASE64:
node -e "console.log(require('crypto').randomBytes(32).toString('base64'))"Set bootstrap admin credentials in .env (recommended for local dev):
BOOTSTRAP_ADMIN_EMAIL=admin@example.com
BOOTSTRAP_ADMIN_PASSWORD=ChangeThisPassword123!Increase workflow timeout for long-running MCP/LLM executions (example 20 min):
WORKFLOW_EXECUTION_TIMEOUT_MS=1200000Optional PostgreSQL storage:
DB_TYPE=postgres
# Defaults shown; uncomment only what you change.
# DB_POSTGRESDB_HOST=localhost
# DB_POSTGRESDB_PORT=5432
# DB_POSTGRESDB_DATABASE=ai_orchestrator
# DB_POSTGRESDB_USER=postgres
# DB_POSTGRESDB_PASSWORD=
# DB_POSTGRESDB_SSL=false
# DB_POSTGRESDB_POOL_SIZE=10
# Or one URL (wins over the settings above). sslmode require / verify-ca / verify-full turn TLS on and verify the
# certificate and host name; disable turns it off; allow / prefer are refused. DB_POSTGRESDB_SSL, if set, must agree.
# DB_POSTGRESDB_URL=postgres://user:password@host:5432/ai_orchestrator?sslmode=verify-full
# Private CA (PEM or path of a PEM file):
# DB_POSTGRESDB_SSL_CA=/etc/ssl/certs/my-db-ca.pem
# Not recommended: skip certificate verification (a startup warning says so).
# DB_POSTGRESDB_SSL_REJECT_UNAUTHORIZED=falseOptional execution queue concurrency:
QUEUE_CONCURRENCY=52) Install
pnpm installIf you want rich HTML/image PDF rendering in PDF Output node (renderMode=html), install Chromium for Playwright:
pnpm exec playwright install chromium3) Start servers
Start API + UI + docs together:
pnpm devAPI:
http://localhost:4000Web UI:
http://localhost:5173Docs UI:
http://localhost:4173
Optional: set VITE_DOCS_URL (in apps/web/.env or your build env) to override the top-bar Docs link target.
Start product only (API + UI):
pnpm dev:productStart API only:
pnpm --filter @ai-orchestrator/api startStart UI only:
pnpm --filter @ai-orchestrator/web devStart docs site only:
pnpm docs:devDocs UI:
http://localhost:4173
4) Run tests
pnpm testRun only web unit/component tests:
pnpm --filter @ai-orchestrator/web testRun web Playwright golden-journey E2E:
pnpm --filter @ai-orchestrator/web e2e5) Build all packages/apps
pnpm buildDocker (optional)
docker compose up --buildWeb:
http://localhost:5173API:
http://localhost:4000
This builds the images from source. Tagged releases also publish signed multi-arch images to GHCR (ghcr.io/tensorgreed/ai-orchestrator, ghcr.io/tensorgreed/ai-orchestrator-web) with SBOMs and build provenance; see Verify a release to check one and pin its digest.
CI
GitHub Actions CI is defined in .github/workflows/ci.yml and runs:
pnpm lintpnpm testpnpm buildpnpm docs:buildpnpm --filter @ai-orchestrator/web e2e
Authentication and RBAC
Session model:
Login creates a server-side
sessionsrecord and setsSESSION_COOKIE_NAMEas anhttpOnlycookie.Frontend uses
credentials: "include"for API calls.Session state is persisted in the configured database (
users,sessionstables).
Auth endpoints:
POST /api/auth/registerPOST /api/auth/loginPOST /api/auth/logoutGET /api/auth/me
POST /api/auth/register payload:
email(required)password(required, min 8)role(optional:admin|builder|operator|viewer)admin(optional boolean shortcut; equivalent torole: "admin")
Bootstrap credentials strategy:
If
BOOTSTRAP_ADMIN_EMAILandBOOTSTRAP_ADMIN_PASSWORDare set and there are no users yet, API bootstraps the first admin account on startup.If bootstrap values are not set, you can create the first user with
POST /api/auth/register; first user defaults toadmin.Keep
AUTH_ALLOW_PUBLIC_REGISTER=falsein non-dev environments. When it is on, a signed-out caller always registers asviewer, a signed-in user cannot give a role above their own, and API keys are refused.
Role permissions:
Area | viewer | operator | builder | admin |
Workflow list/get/export/validate | yes | yes | yes | yes |
Workflow create/update/delete | no | no | yes | yes |
Project/folder/tag list | yes | yes | yes | yes |
Project/folder/tag create/update/delete | no | no | yes | yes |
Pinned data list | yes | yes | yes | yes |
Pin/unpin node data | no | no | yes | yes |
Execute workflow | no | no | yes | yes |
Enqueue workflow / queue depth / DLQ | no | yes | yes | yes |
Execution history/debug load | yes | yes | yes | yes |
Human approvals | no | yes | yes | yes |
Execute | no | no | yes | yes |
Secrets list/create | no | no | yes | yes |
Register users | first-user only or when public register enabled | first-user only or when public register enabled | no (except public register viewer-level) | yes |
API error behavior:
401for missing/invalid/expired session403for authenticated users without required role
Core API endpoints
Health and metadata:
GET /healthGET /api/definitionsGET /api/integrations
Auth:
POST /api/auth/registerPOST /api/auth/loginPOST /api/auth/logoutGET /api/auth/me
Workflows:
GET /api/workflows?projectId=&folderId=&tag=&search=GET /api/workflows/:idGET /api/workflows/:id/variablesPUT /api/workflows/:id/variablesPOST /api/workflowsPUT /api/workflows/:idDELETE /api/workflows/:idPOST /api/workflows/:id/duplicatePOST /api/workflows/:id/movePOST /api/workflows/importGET /api/workflows/:id/exportPOST /api/workflows/:id/validatePOST /api/workflows/:id/executePOST /api/workflows/:id/execute/streamPOST /api/workflows/:id/enqueue
Projects, folders, tags, and pins:
GET /api/projectsPOST /api/projectsPUT /api/projects/:idDELETE /api/projects/:idGET /api/folders?projectId=POST /api/foldersPUT /api/folders/:idDELETE /api/folders/:idGET /api/workflows/:id/pinsPUT /api/workflows/:id/pins/:nodeIdDELETE /api/workflows/:id/pins/:nodeId
Execution history, debug helpers, and approvals:
GET /api/executions?page=&pageSize=&status=&workflowId=&triggerType=GET /api/executions/:idPOST /api/code-node/testPOST /api/expressions/previewGET /api/approvalsPOST /api/approvals/:id/approvePOST /api/approvals/:id/reject
Trigger and webhook entry points:
POST /api/webhooks/executePOST /api/webhooks/execute/streamPOST /api/webhooks/slack/:workflowIdPOST /api/webhooks/github/:workflowIdPOST /api/triggers/manual/:workflowIdGET /api/forms/:pathPOST /api/forms/:pathPOST /api/chat/:workflowIdGET /api/mcp-server/:path/manifestPOST /api/mcp-server/:path/invokeANY /webhook/:path(configured production webhook URL)ANY /webhook-test/:path(configured test webhook URL)
Queue and services:
GET /api/queue/depthGET /api/queue/dlq
Secrets and connection tests:
POST /api/secretsGET /api/secrets?projectId=POST /api/connectors/testPOST /api/providers/testPOST /api/mcp/discover-tools
Workflow organization and debugging
Projects isolate workflows and secrets. The API bootstraps a default project and backfills legacy rows on startup.
Folders organize workflows inside a project. Deleting a folder moves contained workflows back to the project root.
Tags are stored on workflows and can be edited or filtered from the dashboard.
The dashboard supports project switching, folder filtering, tag filtering, and search by name, ID, or tag.
Pinned node data is stored in
workflow.pinnedDataand reused during test runs unlessusePinnedData=false.Single-node execution uses
runMode: "single_node"with a selectedstartNodeIdand supplied previous node outputs or pinned parent data.Execution history can be loaded back into the editor for failed-run debugging or re-run with
sourceExecutionId.Debug mode shows compact node input/output/error previews on the canvas and schema/table views in the node inspector.
Connector and trigger coverage
Tier 1 integrations exposed through /api/integrations:
HTTP request, configured webhook input, and webhook response
Slack send message and Slack Events API trigger
SMTP send email and IMAP email trigger
Google Sheets read/append/update and polling trigger
PostgreSQL query and polling trigger
MySQL query
MongoDB find/insert/update/aggregate
Redis commands and Redis trigger
GitHub issue/PR/repo actions and signed GitHub webhook trigger
General trigger nodes:
schedule_triggermanual_triggerwebhook_inputform_triggerchat_triggerfile_triggerrss_triggersse_triggermcp_server_triggerslack_triggergithub_webhook_triggergoogle_sheets_triggerpostgres_triggerredis_triggerimap_email_triggererror_trigger
Message queue trigger nodes are registered for Kafka, RabbitMQ, and MQTT with optional-dependency detection. Their long-lived consumers are intentionally held back until the corresponding client dependency and deployment path are configured.
Chat model nodes (implemented)
Agent Chat Model attachments can use dedicated provider nodes:
OpenAI Chat Model(openai_chat_model)Anthropic Chat Model(anthropic_chat_model)Ollama Chat Model(ollama_chat_model)OpenAI Compatible Chat Model(openai_compatible_chat_model)AI Gateway Chat Model(ai_gateway_chat_model)Azure OpenAI Chat Model(azure_openai_chat_model)Google Gemini Chat Model(google_gemini_chat_model)Legacy generic
LLM Call(llm_call)
Azure node suite (implemented)
The Azure suite is implemented end-to-end:
Azure OpenAI Chat Model(azure_openai_chat_model)Embeddings Azure OpenAI(embeddings_azure_openai)Azure Storage(azure_storage)Azure Cosmos DB(azure_cosmos_db)Microsoft Azure Monitor(azure_monitor_http)Azure AI Search Vector Store(azure_ai_search_vector_store)
Qdrant node suite (implemented)
Qdrant Vector Store(qdrant_vector_store) with actions:get_ranked_documentsadd_documentsretrieve_for_chain_toolretrieve_for_ai_agent_tool
Qdrant is also available in RAG Retrieve via vectorStoreId = qdrant-vector-store.
For env-backed local defaults you can set QDRANT_ENDPOINT and QDRANT_API_KEY.
What is included for these nodes:
structured node config forms in the editor (no free-form JSON required for normal use)
dedicated node icons on canvas and in node library
secret-backed credentials via
secretRef.secretIdTest Connectionaction for connector nodes (/api/connectors/test)Test Connectionaction for LLM model nodes (/api/providers/test)execution support in the workflow engine (including demo fallback mode for local development)
Webhook execution
Configure the Webhook Input node with:
method(defaultPOST)path(example:agent-demo)
Then call the generated URL from Postman:
Test URL:
http://localhost:4000/webhook-test/<path>Production URL:
http://localhost:4000/webhook/<path>
Webhook payload (minimum):
{
"session_id": "demo-session-1",
"system_prompt": "You are a tool-using agent. Use tools when required.",
"user_prompt": "What time is it in America/Toronto and what is 12*7?",
"variables": {
"tenant": "local-dev"
}
}Optional payload field for long runs:
{
"executionTimeoutMs": 1200000
}Example curl:
curl -X POST http://localhost:4000/webhook/agent-demo \
-H "Content-Type: application/json" \
-d '{
"session_id": "demo-session-1",
"system_prompt": "You are a tool-using agent. Use tools when required.",
"user_prompt": "What time is it in America/Toronto and what is 12*7?"
}'Rich PDF output (HTML + images)
PDF Output node supports two render modes:
text(default): fast plain-text PDFhtml: renders HTML/CSS/images using headless Chromium
Recommended config for charts/reports:
Set
renderMode = htmlPut report HTML in
htmlTemplateor upstreaminputKeyKeep
printBackground = trueChoose
pageFormat(A4default)
If Chromium is not auto-detected, set:
PDF_CHROMIUM_EXECUTABLE_PATH=/absolute/path/to/chrome-or-chromiumCompatibility endpoint (still supported): POST /api/webhooks/execute with workflow_id.
Webhook security modes
Webhook Input node now supports:
nonebearer_tokenhmac_sha256
Configure these in the Webhook node modal:
auth mode
header names
secret reference
idempotency toggle + header name
Postman example: bearer token
Headers:
Authorization: Bearer <token>
Body:
{
"user_prompt": "hello",
"system_prompt": "You are concise."
}Postman example: HMAC SHA256
Assume:
timestamp header:
x-webhook-timestampsignature header:
x-webhook-signaturesigning secret:
<shared_secret>
Signature formula:
signature = hex(HMAC_SHA256(secret, timestamp + "." + raw_body))
Headers:
x-webhook-timestamp: <unix_seconds_or_iso>x-webhook-signature: <hex_signature>(orsha256=<hex_signature>)
Body (raw JSON):
{
"user_prompt": "hello",
"system_prompt": "You are concise."
}Replay/idempotency behavior:
signed requests require timestamp and are rejected outside tolerance window (default 5 minutes)
duplicate signed fingerprint within TTL is rejected as replay (
403)when idempotency is enabled, repeated
Idempotency-Keyfor same endpoint returns cached result instead of re-running
Agent loop behavior (Agent Orchestrator node)
Resolve system prompt + user prompt templates
Discover attached MCP tools from configured MCP servers
Expose tool metadata to selected LLM provider
Call model with conversation + tools
If model returns tool calls, invoke tools and append tool outputs as tool messages
Repeat model call with updated context
Stop on final answer or
maxIterations
The runtime supports zero, one, or multiple tool calls per iteration.
Swarm Multi-Agent & Port Attachments
The Agent Orchestrator and Supervisor Nodes support dedicated attachment ports. These are auxiliary edges and are not part of linear DAG execution.
chat_modelport:attach an
LLM CallorAzure OpenAI Chat Modelnodethis attachment is required; the agent runtime always uses this node's
providerconfig
memoryport:attach a
Simple Memorynodememory persists conversation turns in the configured database by
namespace + session_id
toolport:attach one or more
MCP Toolnodesattached tool configs are converted into available MCP tools for the agent loop
workerport (Supervisor Node only):attach worker
Agent OrchestratororSupervisornodesconnected workers are dynamically exposed as tool calls to the parent Supervisor, allowing it to delegate tasks downstream recursively for Swarm coordination.
Attachment-only helper nodes are marked as skipped in execution traces because they are consumed by the agent runtime rather than executed as direct steps.
Node Input Mapping (Data Passing)
Nodes can dynamically read outputs from previous nodes in the DAG layout.
In a node's configuration, use {{ ... }} templates or dedicated mapping blocks to inject upstream data into prompts, tool arguments, connector parameters, and output templates.
Supported template forms:
Simple dotted paths for back compatibility, for example
{{user_prompt}}or{{parent_outputs.nodeId.answer}}JavaScript-like expressions for richer logic, for example
{{ $if($json.status === "ok", "continue", "stop") }}Built-ins:
$input,$json,$node,$workflow,$execution,$env,$vars,$now,$today,$itemIndexHelpers:
$jmespath(input, path),$if(condition, trueValue, falseValue),$ifEmpty(value, fallback)
The expression preview endpoint (POST /api/expressions/preview) lets the editor evaluate expression fields against sample data before saving a workflow.
Output Parser Robust Parsing
Output Parser now supports parser strictness profiles (independent of parser mode):
strict: accepts only valid JSONlenient: repairs common JSON-like output (single quotes, python booleans/None, trailing commas, unquoted keys)anything_goes: includeslenientand best-effortkey: valueparsing
inputKey supports path forms:
debug.agent_answermessages[5].content{{debug.agent_answer}}
When parsing succeeds/fails, node output includes parserTrace with strategy/confidence/attempt metadata for debugging.
MCP Node Setup (real endpoint)
Use an MCP Tool node attached to the Agent tool port.
Open MCP node config.
Set
MCP Server AdaptertoHTTP MCP Server (http_mcp).Set
Endpointto your MCP server URL.Set
Request Timeout (ms)based on tool latency (for large fetches use60000-300000).Set
Authentication(None/Bearer/Basic) and chooseAuth Secretif needed.Click
Discover Tools, then select the discovered tool.To expose every discovered tool to the agent, set
Tools To IncludetoAll discovered tools (agent decides).
Notes:
mock-mcpis a demo adapter and always returns demo tools (get_current_time,calculator,lookup_kb).If you want a brand-new adapter implementation, select
Custom Adapter IDand register that adapter inpackages/mcp-sdk/src/index.ts.If your MCP server exposes many large tool schemas, model context limits can be hit. The runtime now compacts tool schemas, truncates oversized tool outputs in conversation memory, and caps tool metadata sent to the model.
Every tool an MCP Tool node selects is sent to the model, so for large servers prefer
Select multiple tools. A keyword shortlist by prompt relevance applies only to an agent with no MCP Tool or Workflow Tool node, whose tools come from its inlinemcpServersconfig; Supervisor workers are always offered.
Configurable Tool Output Limits (Agent Orchestrator)
In Agent Orchestrator node config, use Tool Output Limits (Advanced) to control truncation:
toolMessageMaxCharstoolPayloadMaxDepthtoolPayloadMaxObjectKeystoolPayloadMaxArrayItemstoolPayloadMaxStringChars
These values are passed directly to the runtime and validated server-side.
Recommended starting point for large-context local models (~92k available context):
toolMessageMaxChars:90000toolPayloadMaxDepth:8toolPayloadMaxObjectKeys:256toolPayloadMaxArrayItems:256toolPayloadMaxStringChars:4096
If you still hit provider context errors, reduce these values first (especially toolMessageMaxChars), then reduce attached tool count.
Simple Memory Node
Simple Memory (local_memory) is a real database-backed session memory node.
Config:
namespace: memory bucket key (defaultdefault)sessionIdTemplate: defaults to{{session_id}}maxMessages: max persisted turns retainedpersistToolMessages: whether tool messages are saved in memory
DB storage table:
session_memory(namespace, session_id, messages_json, created_at, updated_at)
Session Tool Cache (Automatic)
To support multi-turn agent conversations without flooding model context, the runtime now caches full MCP tool outputs outside the LLM prompt window.
How it works:
On each external MCP tool call, runtime stores full tool args/output in the configured database by
namespace + session_id.The model sees compact tool messages in-context (for token safety), but full payload remains retrievable.
Runtime injects two internal tools automatically (when
session_idis present):session_cache_listsession_cache_get
On follow-up turns, the model can fetch prior tool data from cache instead of re-calling MCP endpoints.
Requirements for reuse across turns:
Use the same
session_idon follow-up webhook/UI runs.Keep agent memory namespace stable (default is stable per workflow/agent attachment).
DB storage table:
session_tool_cache(id, namespace, session_id, tool_name, tool_call_id, args_json, output_json, error, summary_json, created_at)
Why this helps:
reduces repeated expensive MCP calls
avoids large-context crashes for local models
keeps follow-up questions grounded in previously fetched data
Secrets handling
Secrets are created with
POST /api/secretsSecret values are encrypted server-side using AES-256-GCM
Workflow/provider configs reference
secretRef.secretIdonlyAPI responses never return raw secret values
Error logging passes through redaction helper
Extension points
Add a new LLM provider adapter
Implement
LLMProviderAdapterinpackages/provider-sdk/src/types.tsAdd adapter implementation under
packages/provider-sdk/src/providers/Register in
createDefaultProviderRegistry()inpackages/provider-sdk/src/index.ts
Add a new connector adapter
Implement
ConnectorAdapterinpackages/connector-sdk/src/types.tsAdd adapter file under
packages/connector-sdk/src/adapters/Register in
createDefaultConnectorRegistry()inpackages/connector-sdk/src/index.ts
Add a new MCP server adapter
Implement
MCPServerAdapterinpackages/mcp-sdk/src/types.tsAdd adapter file under
packages/mcp-sdk/src/adapters/Register in
createDefaultMCPRegistry()inpackages/mcp-sdk/src/index.ts
Workflow JSON format
Export format is stable and explicit:
{
"schemaVersion": "1.0.0",
"workflowVersion": 1,
"workflow": {
"id": "wf-basic-llm",
"name": "Basic LLM Flow",
"schemaVersion": "1.0.0",
"workflowVersion": 1,
"nodes": [],
"edges": []
},
"exportedAt": "2026-03-30T00:00:00.000Z"
}Includes node types/config, edge graph, and node positions for canvas restoration.
Sample workflows
samples/workflows/basic-flow.json— text-in / LLM / text-out, runs zero-key with the bundled echo provider.samples/workflows/mcp-agent-quickstart-flow.json— zero-key MCP agent (target of the 5-minute tutorial).samples/workflows/supervisor-worker-swarm-flow.json— multi-agent: a Supervisor delegating to a researcher and a computer worker.samples/workflows/workflow-as-mcp-tool-flow.json—mcp_server_triggerexposing a workflow as a callable MCP tool.samples/workflows/agentic-mcp-flow.json— webhook → agent → MCP tools + memory.samples/workflows/two-turn-report-code-helper-flow.json— multi-turn helper with deterministic session artifacts.samples/workflows/vscode-l2m-coding-agent-flow.json— canonical wiring for the VS Code extension.samples/workflows/conditional-flow.json— branching from a webhook trigger.samples/workflows/rag-flow.json— RAG with Google Drive + in-memory vector store.samples/workflows/rag-pinecone-flow.json— RAG backed by Pinecone.samples/workflows/structured-output-flow.json— schema-validated structured output extraction.samples/workflows/azure-openai-flow.json— basic LLM flow using Azure OpenAI.samples/workflows/azure-connectors-demo-flow.json— Azure Storage / Cosmos DB / Monitor / AI Search.
Set SEED_SAMPLE_WORKFLOWS=true to load these into the database when the workflow table is empty. See the pattern library for when to use which.
For full real-world reference projects (helpdesk agent, support triage, VS Code repo reviewer) with end-to-end READMEs and production-deployment notes, see the dedicated l2m-samples repo.
Authoring community nodes
Third-party developers can ship l2m-nodes-* npm packages that contribute LLM providers, MCP transports, and connectors to a running L2M instance — no fork or PR required. Start from the l2m-nodes-template scaffold and read the community-nodes guide for the contract, threat model, and install flow. Admins enable installs via COMMUNITY_NODES_ENABLED=true in the server env.
Contributing
L2M is pure OSS (MIT) and the project's growth depends on community contributions — adapters, MCP integrations, docs, bug reports, real-world patterns. Start with CONTRIBUTING.md. Bug? File a bug report. Question or design discussion? Use GitHub Discussions. Security issue? Use a private advisory — see SECURITY.md. Participation is governed by the Code of Conduct. Notable changes are tracked in CHANGELOG.md.
Status and roadmap
L2M ships a deep capability surface today. Enterprise capabilities — SAML/LDAP SSO, MFA, audit logging, external secret managers, source control sync, OpenAPI coverage, multi-main HA via leader election — are implemented. The active focus is GA polish: deepening the MCP/Swarm/VS Code differentiators, first-run UX, production hardening (rate limiting, security headers, image build automation), and a community node SDK so connectors can be shipped as npm packages.
The horizontal-scaling story moves further along when the in-process queue backend is swapped for Redis/BullMQ; the Helm chart and Docker Compose prod template already assume webhook process separation and leader-elected schedulers.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
Open-source Zapier/n8n alternative as an MCP server: agents build, run and debug your workflows.
Build and run AI workflows, agents, data tables and 1000+ API integrations from any MCP client.
Zero-setup MCP gateway securely connecting AI to your tools with authentication and workflows
Related MCP Servers
- FlicenseCqualityAmaintenanceSelf-hosted, source-available AI workflow automation platform. Build multi-agent, RAG, and tool-using pipelines on a visual canvas and publish any workflow as an MCP server (stdio/SSE/Streamable HTTP). Also an MCP client via the agent node.21,774-
- AlicenseNot gradedqualityBmaintenanceMCP server that executes Blueprint workflows (flow.ir) with swarm operations, dispatching agent steps to backends like Lua, Rust, processes, or interactive Operator sessions.1Apache 2.0
- AlicenseNot gradedqualityBmaintenanceSelf-hosted workspace MCP gateway that registers MCP servers, stores secrets encrypted, mints agent keys, and shares a unified tool library across multiple AI harnesses.1Apache 2.0
- AlicenseNot gradedqualityBmaintenanceEnables autonomous multi-agent orchestration using directed acyclic graph workflows to interact with external developer infrastructure such as Git, Postgres, and Docker through safety-gated MCP servers.Apache 2.0