Archive Decompression ai.archive.decompress Unpacks compressed archives into a structured array of files suitable for iteration with `flow.split` and downstream extraction nodes.
Supports the most common archive formats used for email attachments, data deliveries, and document exports, with recursive unpacking of nested archives up to a configurable depth.
**Features:**
- **Supported formats:** ZIP, TAR, TAR.GZ (tgz), TAR.BZ2 (tbz2), 7z. Format detection combines filename hints with magic bytes so mislabelled archives are still handled.
- **Recursive unpacking:** Nested archives (archive inside archive) are unpacked up to `max_depth`, preserving full path context in each emitted file's `name`.
- **MIME detection per entry:** Every output file carries a normalized `content_type` derived from its extension plus magic-byte sniffing so downstream dispatchers can route without extra probing.
- **Path traversal protection:** Entries with `../` or absolute paths are rejected to prevent Zip Slip attacks.
- **Encrypted / damaged entries:** Entries that cannot be decompressed are skipped and reported in metadata rather than aborting the whole archive.
- **Output shape:** Array of `{ name, content_type, size, content_base64 }` plus a `count` and per-entry metadata block.
Classify Text ai.classify Categorizes input text into one of a predefined set of labels.
This operator uses Zero-Shot Classification or a fine-tuned model to determine the intent, sentiment, or topic of the text.
**Use Cases:**
- **Support Routing:** Tagging emails as 'Billing', 'Tech Support', or 'Feature Request'.
- **Sentiment Analysis:** Labeling checks as 'Positive', 'Negative', 'Neutral'.
- **Spam Detection:** Filtering content.
Registry-based Classifier ai.classify.registry Rule-based classifier that resolves the best-matching entry from a registry KnowledgeResource given a set of input signals, using a deterministic weighted-score algorithm.
Unlike `ai.classify` / `ai.classify.triage` which rely on an LLM to pick a label, this operator scores each candidate entry declared in a structured registry (KR `resource_type: dataset`) against the caller's signals, and returns the highest-scoring entry along with its opaque `payload` — ready for downstream nodes to consume (task assignees, routing targets, SLA hints, pricing tiers, etc.).
The registry shape and matching semantics are fully client-agnostic. The registry lives in a KnowledgeResource so non-technical operators can add/edit/remove entries from the webapp without modifying the workflow graph or redeploying the orchestrator.
**How it decides**
Each entry declares `match_rules` with three independent channels:
- `labels`: exact-string matches against the caller's `labels[]` signal (e.g. a classification output like `"some_category.some_subcategory"`).
- `tags`: exact-string matches against the caller's `tags[]` signal (e.g. routing hints emitted by an upstream triage).
- `keywords`: case-insensitive substring matches against the caller's `text` signal (e.g. the original email or document body).
Each rule carries a `weight`. The worker iterates all entries, sums the weights of matching rules, and returns the entry with the highest total score. Ties break by first-in-array order (ops can reorder rows to express priority explicitly).
If no entry scores > 0, the worker returns the entry whose `slug` matches the registry's `default_entry` field (or exits via port `no_match` if the registry has no default).
**Typical use cases**
- **Intake routing**: classify an incoming case to a branch / office / team from a registry of hundreds of such entities, with per-entity assignee, SLA and priority declared as data.
- **Workload dispatch**: pick a queue or specialist from a catalog when the choice depends on multiple signals (category + region + urgency hints).
- **Product / plan selection**: match a support ticket to a product variant based on classification + keywords in the text.
- **Tiering and filtering**: rule-based assignment of customers/leads to tiers, segments, or workflows when criteria evolve faster than code.
**Why a dedicated worker instead of `flow.switch` or `data.transform`**
`flow.switch` forces one case/port per outcome — doesn't scale past ~10 cases. `data.transform` with an inline IIFE duplicates the scoring code across workflows. `ai.classify.registry` centralizes the algorithm, validates the registry shape defensively, and exposes a clean input/output contract that downstream nodes (e.g. `human.task.create`) consume via expressions.
**When NOT to use**
When the decision requires semantic understanding (ambiguous text, novel cases, a justification written for a human reviewer), use `ai.classify.triage` instead. This operator is deterministic, explainable, and cheap to run — but it will only recover from novel phrasings if a matching keyword is declared.
Triage Classifier ai.classify.triage Performs hierarchical intake triage with policy-driven decision rules.
This operator classifies text into a **category + subcategory** taxonomy, produces **confidence** and a full **probability distribution** across categories, generates **routing hints**, and returns both **notes** and a longer **justification** suitable for audits and human review.
**Typical use cases**
- Government / legal intake triage (PQRS, tutela, hábeas corpus, etc.)
- Enterprise incident routing with policy rules
- Multi-level taxonomy classification with traceable rationale
Compare Texts ai.compare Semantic text comparison powered by LLM.
This operator compares two text inputs using a configurable comparison mode and routes to match/no_match ports based on the result.
**Operations**
- **Similarity:** Computes a semantic similarity score (0-1) between two texts.
- **Diff:** Identifies meaningful semantic differences (not character-level) between texts.
- **Contradiction:** Detects factual contradictions between two texts with evidence from each.
- **Dedup:** Assesses whether two texts are duplicates or near-duplicates based on a configurable threshold.
**Use Cases**
- Detecting duplicate support tickets or content submissions.
- Comparing policy documents for contradictions or drift.
- Validating consistency between source material and generated content.
- Flagging conflicting information across data sources.
Check Compliance ai.compliance.check Evaluate content against compliance policies, regulatory rules, or business guidelines.
Link a Knowledge Resource containing your compliance policy and this node will automatically check any text for violations — returning severity levels, specific rule citations, and remediation suggestions.
**Operations:**
- **Full Check:** Deep analysis against all policy rules with detailed violation reports.
- **Quick Check:** Fast scan for critical violations only.
Ideal for regulatory compliance (GDPR, HIPAA, SOX), internal policy enforcement, content review workflows, and audit automation.
Compose Content ai.compose AI-powered content composition for structured business communications.
This operator generates polished content from structured parameters, using mode-specific prompts or custom PromptTemplates.
**Operations**
- **Email:** Composes a professional email from subject, key points, and tone.
- **Response:** Generates a customer service response from ticket context and resolution details.
- **Report:** Produces a report section from data points and an optional template structure.
- **Notification:** Creates a notification message from event details and target audience.
- **Custom:** Generates content using a PromptTemplate with variable hydration.
**Use Cases**
- Automating outbound email drafts in workflows.
- Generating consistent customer service replies.
- Producing report sections from structured data.
- Creating templated notifications for operational events.
AI Decision ai.decision Intelligent routing node that replaces complex flow.switch chains with a single AI-powered decision point.
Define decision criteria in natural language and let the LLM route to the correct output port. Each decision becomes a named output port in the workflow graph.
**How it works:**
- Configure named decisions with natural language criteria (e.g., "Urgent: customer is threatening to cancel and mentions legal action").
- The AI evaluates the input against ALL criteria and selects the best match.
- Output routes to the matching decision port with confidence and reasoning.
- Optionally load decision policies from a Knowledge Resource.
Far more flexible than rule-based switches — understands nuance, context, and natural language criteria.
Deep Entity Extraction ai.deep.extract Extract entities from large documents (100+ pages) using Hierarchical Map-Reduce with context propagation.
Unlike basic entity extraction which processes text in a single pass, Deep Extract handles documents of unlimited length by:
**Phase 1 — Document Profile:** Analyzes the first and last pages to understand document type, parties involved, structure, and key references.
**Phase 2 — Map with Rolling Context:** Processes each chunk sequentially, carrying forward previously found entities as context. This prevents the LLM from extracting partial names or missing relationships.
**Phase 3 — Reduce & Consolidate:** A final pass deduplicates entities (J. Pérez = Juan Pérez), resolves relationships (who is plaintiff, defendant), validates coherence, and assigns legal relevance.
Ideal for court sentences, contracts, regulatory filings, and any document where context matters.
DOCX Text Extraction ai.docx.extract.text Extracts text from Microsoft Word (.docx) documents by traversing the Office Open XML Wordprocessing structure with python-docx.
Preserves the logical flow of the document: heading hierarchy, paragraph order, list nesting, and table structure.
**Features:**
- **Structural preservation:** Emits headings with their outline level, paragraphs in document order, and list items with bullet/number indicators.
- **Tables as markdown:** Each in-document table is rendered as a markdown table so downstream LLMs and parsers can consume cell boundaries without losing context.
- **Inline annotations:** References to embedded images, hyperlinks, and footnotes are surfaced as inline markers with their target metadata.
- **Metadata:** Document title, author, last modified, and revision count extracted from the core properties when present.
Email Parsing ai.email.parse Parses raw email files into a normalized structured object with headers, body, and attachments, ready for classification or extraction pipelines.
Dual-format dispatcher: `extract-msg` for Microsoft Outlook MSG (CFBF / OLE compound-file container) and `mail-parser` for standard RFC 822 / MIME EML messages. Format detection is automatic based on magic bytes, with an optional override.
**Features:**
- **Header normalization:** From, To, CC, BCC, Reply-To, Subject, Message-Id, In-Reply-To, and Received-Date decoded to canonical form (ISO-8601 for dates, arrays for address lists).
- **Body handling:** Returns plain-text body directly; when only an HTML part is present, converts to text while preserving paragraph and list breaks.
- **Attachments:** Each attachment emitted as `{ name, content_type, size, content_base64 }` so it can be piped through `flow.split` to extractors (PDF, DOCX, OCR, etc.).
- **Inline vs attached:** Distinguishes inline attachments (e.g. embedded images referenced by Content-Id) from user attachments in metadata.
- **Encoding recovery:** Handles MIME-encoded-word subjects (UTF-8, Latin-1, ISO-2022-JP) and quoted-printable / base64 bodies transparently.
- **Malformed input:** Emits port `empty` when the email has no body or attachments, and `error` with trace detail when the container itself is corrupt.
Generate Embeddings ai.embed Converts text into high-dimensional vector embeddings.
Embeddings capture the semantic meaning of text as a list of numbers (vectors). These vectors are essential for semantic search, clustering, and RAG (Retrieval Augmented Generation) workflows.
**Use Cases:**
- **Semantic Search:** Preparing data for vector database storage.
- **Clustering:** Grouping similar support tickets.
- **Classification:** Feeding downstream ML models.
Enrich Data ai.enrich Enrich records by adding computed, inferred, or standardized fields using an LLM.
Select an enrichment mode and define the output fields you need. The operator reads the input record, applies the chosen strategy, and returns the enriched record with confidence scores per field.
**Operations:**
- **Categorize:** Add category tags to a record based on its content.
- **Standardize:** Normalize names, addresses, dates, and phone numbers to consistent formats.
- **Infer:** Fill missing field values by reasoning from available context.
- **Augment:** Add computed fields such as seniority from job title or industry from company name.
Extract Entities ai.entity.extract Extract named entities from text using LLM-powered recognition.
Identify people, organizations, locations, dates, monetary amounts, and custom entity types from any unstructured text. Configure entity types or provide your own definitions via Knowledge Resources.
**Operations:**
- **Standard:** Extract common entity types (PERSON, ORG, LOCATION, DATE, MONEY, EMAIL, PHONE, URL).
- **Custom:** Define your own entity types with descriptions and examples.
- **All:** Combine standard and custom entity extraction.
Extract Data ai.extract Extracts structured data (JSON) from unstructured text using an LLM.
This operator intelligently parses emails, documents, or logs and converts them into a strict JSON schema you define. It uses an LLM (Schema Mode) to guarantee the output format.
**Use Cases:**
- **Invoices:** extracting 'Total Amount', 'Due Date', 'Vendor' from OCR text.
- **Resumes:** extracting 'Skills', 'Experience', 'Contact Info' from a bio.
- **Support:** extracting 'Ticket ID', 'Severity', 'Sentiment' from a chat log.
Generate Text ai.generate Leverages Large Language Models (LLMs) to generate natural language content.
This operator connects to configured LLM providers (e.g., OpenAI, Anthropic, Local) to produce text based on a given prompt. It supports system instructions, temperature control, and context injection.
**Use Cases:**
- **Content Creation:** Drafting emails, blog posts, or reports.
- **Summarization:** Condensing long documents into executive summaries.
- **Transformation:** Rewriting text in a different tone or format.
HTML Text Extraction ai.html.extract.text Extracts the main readable content from HTML or XHTML documents using trafilatura with content-boundary detection.
Strips navigation chrome, scripts, style blocks, advertising containers, cookie banners, headers, footers, and comment threads while preserving the substantive article body.
**Features:**
- **Boilerplate removal:** Detects and removes page chrome based on trafilatura's trained extractors, tuned for modern CMS and blog layouts.
- **Structural preservation:** Retains headings, paragraphs, ordered and unordered lists, and blockquotes in document order.
- **Precision/recall tradeoff:** `favor_precision` toggles between aggressive cleanup (default, fewer false positives) and permissive extraction (recovers content on unconventional layouts).
- **Metadata extraction:** Pulls title, canonical URL, author, publish date, site name, and language when surfaced by the page's meta tags, Open Graph, or JSON-LD.
- **Inputs:** Accepts raw HTML as a string, base64-encoded HTML, or a local file path.
Detect Intent ai.intent Detects user intent from text input and extracts relevant parameters for downstream routing.
This operator classifies input text against a configurable intent catalog, producing a primary intent, confidence score, extracted parameters, and routing hints for workflow orchestration.
**Operations**
- **Intent Detection:** Matches text against a catalog of named intents with descriptions and examples.
- **Parameter Extraction:** Extracts key-value slot parameters relevant to the detected intent.
- **Routing:** Provides routing hints to guide downstream workflow branching.
**Use Cases**
- Chatbot message routing based on user intent (e.g., "book_appointment", "check_status", "complaint").
- Email triage and automatic categorization by purpose.
- Command Center input classification for explicit vs. inference-assisted execution.
- Multi-channel intake routing with confidence-based human review escalation.
Extract Key Phrases ai.keyphrases Extracts the most important phrases, terms, and concepts from text with relevance scoring. Each phrase is optionally categorized as topic, entity, concept, or action.
Detect Language ai.language Detects the language or languages present in a text with confidence scores. Supports multi-language content detection and returns ISO 639-1 language codes.
Multimodal Text Extraction ai.multimodal.extract.text Format-agnostic dispatcher that accepts a single file, detects its MIME type, and routes it to the appropriate extractor, returning a unified text output.
Backed by MarkItDown as the orchestration layer for Office and markup formats and by pytesseract for image OCR. Produces deterministic text suitable for classification, RAG indexing, or downstream LLM consumption without the caller having to pre-identify the format.
**Supported formats:**
- **Documents:** PDF (text layer only — no OCR fallback in this tier), DOCX, XLSX, PPTX.
- **Markup and structured text:** HTML, XHTML, Markdown, plain text, CSV, TSV, JSON, XML.
- **Images:** PNG, JPG, JPEG, TIFF, BMP, WebP — processed with a single-pass OCR engine.
**Operational notes:**
- **Single-file scope:** Processes one file per invocation. For batch inputs (email attachments, archive contents), compose `ai.email.parse` or `ai.archive.decompress` upstream with `flow.split`, then fan in with `flow.join`.
- **Silent-fail detection:** When the underlying extractor returns no meaningful text (common with scanned PDFs and low-quality images), the worker emits port `empty` rather than a silent empty string.
- **Tier upgrade:** For quality-driven cascade with OCR fallback, confidence scoring, adaptive preprocessing, language detection, and per-segment error recovery, use `ai.multimodal.extract.text.cascade-pipeline`.
Multimodal Cascade Text Extraction ai.multimodal.extract.text.cascade-pipeline Multi-stage text extraction pipeline with quality-driven fallback, adaptive preprocessing, and per-segment error recovery.
Selects a primary extractor by MIME type, scores the extraction quality, and escalates to secondary engines when the primary result is empty or unreadable. Produces rich metadata so downstream classifiers can reason about confidence and language without re-reading the source.
**Primary extractors by format:**
- **PDF:** PyMuPDF text layer first; falls back to multi-engine OCR (pytesseract + EasyOCR with confidence voting) when the text layer is absent or returns gibberish.
- **DOCX / XLSX / PPTX:** python-docx / openpyxl / python-pptx with structural preservation (headings, tables as markdown, presenter notes).
- **HTML / XHTML:** trafilatura with boilerplate removal and metadata harvesting.
- **Images:** pytesseract with adaptive preprocessing (Otsu binarization, deskew via Radon transform, morphological denoising, contrast enhancement).
- **Plain text / CSV / JSON / XML:** direct decoding with charset sniffing.
**Quality scoring:**
- Shannon entropy of the character distribution detects uniform noise.
- Alphanumeric ratio rejects OCR output dominated by symbols or isolated glyphs.
- Sentence-density heuristic (tokens per sentence, average word length) catches garbled passages that pass char-level checks.
- Aggregated score in `[0, 1]`; below `0.5` triggers the fallback path automatically and is reported as `metadata.fallback_reason`.
**Operational features:**
- **Per-segment error recovery:** Page, sheet, or slide failures are isolated — the rest of the file continues and failed segments are reported in metadata rather than aborting the whole extraction.
- **Language detection:** langdetect runs on the final text and populates `metadata.language`, useful for downstream routing and localized classification.
- **Partial results port:** When the aggregate quality score falls below the HITL threshold, the worker emits port `partial` so the workflow can route to a reviewer instead of silently accepting a low-quality extraction.
- **Single-file scope:** Processes one file per invocation. Compose `ai.email.parse` or `ai.archive.decompress` upstream with `flow.split` for batch inputs.
**Output enrichment:**
- `quality_score`: aggregate score in `[0, 1]`.
- `metadata.language`: ISO 639-1 code detected from the final text.
- `metadata.fallback_reason`: why the primary extractor was bypassed (`empty_text_layer`, `low_quality`, `not_supported`).
- `metadata.segment_quality`: per-page / per-sheet / per-slide quality array.
- `metadata.extractor_chain`: ordered list of engines actually invoked.
OCR - PDF to Text ai.ocr Extract text from PDF documents using OCR (Optical Character Recognition).
Automatically detects whether the PDF contains embedded text or is a scanned image, and uses the optimal extraction method.
**Operations:**
- **Auto:** Try text extraction first (pdftotext), fall back to OCR if text is sparse.
- **Text Extract:** Fast extraction of embedded text only (no OCR). Best for digital PDFs.
- **OCR Only:** Force OCR on all pages. Best for scanned documents.
OCR - Adaptive ai.ocr.adaptive Adaptive multi-engine OCR with intelligent preprocessing, table detection, and confidence scoring.
Uses multiple OCR engines (pytesseract + EasyOCR) in parallel and selects the highest-confidence result per page. Includes OpenCV-based preprocessing for scanned documents.
**Features:**
- **Multi-engine comparison:** Runs pytesseract and EasyOCR, picks the best result per page based on confidence score.
- **Preprocessing:** Binarization (Otsu), deskew correction, noise removal, and contrast enhancement via OpenCV.
- **Table detection:** Optional morphological detection of table structures with cell-level text extraction.
- **Confidence scoring:** Per-page confidence metrics and aggregated processing statistics.
- **Batch processing:** Handles large documents efficiently by processing pages in batches of 5.
Parse Document ai.parse.document Parse and extract structured data from documents using an LLM.
Analyzes document text (OCR output, raw text, or pre-processed content) and extracts structured fields based on the document type. Includes built-in schemas for common document types and supports custom extraction schemas.
**Operations:**
- **Invoice:** Extract vendor, line items, totals, payment terms.
- **Receipt:** Extract merchant, items, totals, payment method.
- **Resume:** Extract contact info, experience, education, skills.
- **Contract:** Extract parties, dates, clauses, obligations.
- **Form:** Extract generic label-value field pairs.
- **Custom:** Use a user-defined JSON schema for extraction.
PDF Text Extraction ai.pdf.extract.text Extracts the embedded text layer from PDF documents using PyMuPDF.
Reads the native text stream of a PDF without rasterization or OCR, preserving the document's logical reading order and emitting page-level markers in the output.
**Operational notes:**
- **Text layer only:** Returns the PDF's embedded text. Scanned PDFs and image-based PDFs have no text layer and will emit port `empty`.
- **Page range:** Optional filter to process a subset of pages (e.g. `1-50`, `1,5,10-20`).
- **Metadata:** Returns page count, character count, and document metadata (title, author, producer) when present.
- **Downstream fallback:** For scanned PDFs, route `empty` output to `ai.ocr` or `ai.ocr.adaptive`.
PPTX Text Extraction ai.pptx.extract.text Extracts text from Microsoft PowerPoint (.pptx) presentations by traversing the Office Open XML Presentation structure with python-pptx.
Emits slide-by-slide content preserving deck order and separating visible slide text from presenter notes.
**Features:**
- **Slide order preservation:** Every slide produces a section marker with its slide number, title placeholder, and body placeholders concatenated in reading order.
- **Presenter notes:** Speaker notes are extracted per slide and emitted as a separate block so they can be used or filtered independently.
- **Tables within slides:** In-slide tables are rendered as markdown tables.
- **Shape traversal:** Text from grouped shapes, text frames, and SmartArt is flattened deterministically so the same deck always yields the same output.
- **Hidden slides:** Slides flagged as hidden are reported in metadata but excluded from the main text stream by default.
Get Prompt Template ai.prompt Hydrates a managed prompt template with dynamic variables.
Instead of hardcoding prompts in your workflow, use this operator to fetch versioned, managed templates from the Prompt Registry and fill them with workflow data.
**Benefits:**
- **Separation of Concerns:** Prompts can be tuned by Prompt Engineers without changing code.
- **Version Control:** Use specific versions of a prompt.
- **Reusability:** Share standard system prompts across workflows.
Answer Question ai.qa Grounded question answering from provided context.
This operator answers a question strictly from the supplied context, with evidence citations and confidence scoring. In strict grounding mode, it refuses to answer when the context does not contain sufficient information.
**Capabilities**
- Answers questions based exclusively on provided context documents.
- Returns evidence citations linking the answer to source material.
- Detects unanswerable questions and routes them to a dedicated port.
- Supports supplementary knowledge resources for additional reference.
- Provides confidence scores and grounding assessment for every answer.
**Use Cases**
- Q&A over internal documentation, policies, or knowledge bases.
- Grounded customer support answers from product documentation.
- Compliance verification against policy documents.
- Extracting specific answers from contracts or legal documents.
RAG Compose Prompt ai.rag.compose Constructs a RAG (Retrieval-Augmented Generation) prompt by combining a query with retrieved context.
This operator formats a list of retrieved documents into a context block and injects it into a "Answer with context" prompt template.
**Use Cases:**
- Q&A over internal documentation.
- Summarizing search results.
- Grounding LLM responses in factual data.
Retrieve Context (RAG) ai.rag.retrieve Orchestrates the retrieval of context for RAG (Retrieval-Augmented Generation).
This high-level operator abstracts the Embedding -> Vector Search -> Reranking pipeline into a single step. It takes a text query, handles the embedding internally (or via configuration), searches the vector store, and returns the best matching text chunks.
**Use Cases:**
- "One-click" RAG context retrieval.
- Simplifying the graph by hiding vector complexity.
Extract Relations ai.relation.extract Extracts semantic relationships between entities from text as subject-predicate-object triples.
Produces knowledge-graph-ready output that identifies who did what to whom, when, and where. Optionally filter to specific relation types and include evidence text spans.
**Use Cases:**
- **Knowledge Graphs:** Build structured graphs from documents.
- **Compliance:** Extract contractual obligations and parties.
- **Intelligence:** Map relationships between people, organizations, and events.
Rewrite Text ai.rewrite Rewrite text with a specific tone, style, or transformation goal.
Transform input text while preserving its core meaning. Supports multiple rewriting strategies including tone adjustment, simplification, formalization, expansion, condensation, and fully custom instructions.
**Operations:**
- **Tone:** Rewrite in a target tone (professional, casual, empathetic, assertive, diplomatic).
- **Simplify:** Make text accessible to a general audience.
- **Formalize:** Convert to formal, business-appropriate language.
- **Expand:** Elaborate with more detail and context.
- **Condense:** Remove redundancy while preserving key information.
- **Custom:** Apply free-form rewriting instructions via an expression.
Safety Filter ai.safety.filter Evaluates text against safety guidelines to block harmful content.
Uses a moderation model (e.g., OpenAI Moderation API, Llama Guard) to detect categories like Hate, Harassment, Self-Harm, Sexual, or Violence.
**Use Cases:**
- Moderating user input before sending to an LLM.
- Validating LLM output before showing to user.
- Ensuring brand safety.
Content Safety Scan ai.safety.scan Comprehensive multi-modal safety scanner (Text/Image).
This is a broader version of the Safety Filter, designed for analyzing multimodal payloads for production safety compliance.
**Checks:**
- PII Detection (Basic).
- Toxicity/Hate Speech.
- Prompt Injection Detection.
Score & Rate ai.score Score and rate text content using LLM-powered evaluation across multiple dimensions.
Evaluate quality, relevance, urgency, risk, or custom criteria with configurable scales and thresholds. Supports weighted multi-criteria scoring via custom rubrics loaded from Knowledge Resources.
**Operations:**
- **Quality:** Evaluate clarity, completeness, accuracy, and coherence.
- **Relevance:** Score semantic overlap and topic alignment against a reference.
- **Urgency:** Assess time sensitivity, impact severity, and stakeholder importance.
- **Risk:** Identify risk factors, likelihood, and potential impact.
- **Custom:** Define weighted criteria with descriptions and optional rubrics.
Analyze Sentiment ai.sentiment Analyze the sentiment and emotional tone of text.
Detect whether text is positive, negative, neutral, or mixed. Optionally break down into specific emotions or analyze sentiment per aspect/topic.
**Operations:**
- **Overall:** Single sentiment classification with valence score (-1 to 1) and confidence.
- **Emotions:** Detect specific emotions (joy, anger, sadness, fear, surprise, disgust, trust) with intensity scores.
- **Aspect-Based:** Extract topics/aspects mentioned in text and score sentiment for each independently.
Summarize Text ai.summarize Multi-format text summarization powered by LLM.
This operator condenses input text into a summary using one of several modes.
**Operations**
- **Executive:** 2-3 sentence high-level summary for decision-makers.
- **Bullets:** Key points as a bullet-point list.
- **Abstractive:** Condensed rewrite preserving core meaning.
- **Extractive:** Selects the most important original sentences.
- **Structured:** Produces a JSON object with overview, key_findings, action_items, and risks_concerns sections.
**Use Cases**
- Condensing meeting transcripts or reports for stakeholders.
- Generating bullet-point digests for dashboards and notifications.
- Producing structured summaries for downstream workflow processing.
Extract Topics ai.topics Extract and identify the main topics from text content.
Analyzes unstructured text to discover relevant topics, assign relevance scores, and optionally map them to an existing taxonomy via a linked Knowledge Resource.
**Operations:**
- **Discover:** Open-ended topic discovery — the model freely identifies the most salient topics from the text.
- **Constrained:** Map text to a predefined taxonomy loaded from a Knowledge Resource. Only topics present in the taxonomy are returned.
Audio and Video Transcription ai.transcribe Automatic Speech Recognition over audio and video streams using faster-whisper (CTranslate2-backed Whisper).
Single-pass decoding on CPU with configurable model size, beam width, and language hint. Suitable for utility-grade transcription of meetings, voicemails, and short-form media. For speaker diarization, 100+ locales, or custom vocabulary, use `connectors.microsoft.azure.speech`.
**Features:**
- **Model selection:** `tiny`, `base` (default), or `small`. Larger models increase accuracy at the cost of latency and memory.
- **Beam search:** Configurable beam size; beam > 1 improves transcription quality on noisy input at a linear cost.
- **Language:** ISO 639-1 hint (`es`, `en`, `pt`, ...) or auto-detection from the first 30 seconds of audio.
- **Word timestamps:** Optional per-segment timestamps for subtitle generation, chaptering, or evidence anchoring.
- **Input formats:** mp3, wav, m4a, ogg, flac, mp4, mov, webm. Container demuxing and PCM resampling to 16 kHz handled internally via ffmpeg.
- **Silent input handling:** Emits port `empty` when Voice Activity Detection finds no speech in the stream.
Translate Text ai.translate Translate text between languages using LLM-powered translation with domain awareness and glossary support.
Supports formal, neutral, and informal registers across general, legal, medical, technical, business, and academic domains. Enforce term consistency with custom glossaries and preserve original formatting.
**Operations:**
- **Translation:** Accurate cross-language translation with tone and domain context.
- **Auto-detection:** Automatically detect source language when not specified.
- **Glossary enforcement:** Apply mandatory term mappings for consistency.
- **Formality control:** Adjust output register (formal, neutral, informal).
Vector Search ai.vector.search Performs a semantic search against a Vector Database.
Finds records that are semantically similar to the query vector. Used as the core retrieval step in RAG pipelines.
**Features:**
- **Metadata Filtering:** Restrict search to specific documents (e.g., `{ "user_id": "123" }`).
- **Top-K:** precise control over number of results.
- **Metric:** Cosine Similarity, Euclidean Distance, etc. (DB dependent).
Upsert Vector ai.vector.upsert Inserts or Updates records in a Vector Database.
Used during the ingestion phase. It takes vectors (and their metadata/text) and stores them in the index for future retrieval.
**Use Cases:**
- Indexing a new document.
- Updating user profile embeddings.
XLSX Text Extraction ai.xlsx.extract.text Extracts tabular data from Microsoft Excel (.xlsx) workbooks using openpyxl.
Iterates every non-empty sheet in workbook order and renders each as a standalone markdown table, producing a single normalized text output suitable for downstream LLM consumption, vector indexing, or direct classification.
**Features:**
- **Per-sheet rendering:** Each sheet is emitted with its name as a header followed by a markdown table of its used range.
- **Formatted cell values:** Applies the workbook's display formats for numbers, dates, and percentages so the extracted text matches what a user sees in Excel.
- **Merged cells and frozen panes:** Merged regions are collapsed to their anchor value and annotated; frozen header rows are marked so they survive downstream truncation.
- **Empty sheet detection:** Sheets with no data are skipped and reported in the output metadata rather than emitted as empty sections.
- **Metadata:** Workbook properties (title, author, creation date) plus per-sheet statistics (rows, columns, used range).
Code in JavaScript code.js Execute custom JavaScript code within the workflow.
Write JavaScript to transform data, implement custom logic, or perform calculations. The incoming payload is available as `$json` and common helpers like lodash (`_`) are pre-loaded.
**Execution Modes:**
- **Sandbox** (default): Fast, isolated execution via VM context. No I/O access (no `require`, no `fs`, no `process`). Ideal for data transformations and calculations.
- **Process**: Full Node.js execution in a child process. Supports `require()` for installed modules and I/O operations. Use for advanced integrations.
**Convention:** Your code must return a value. The returned value becomes the node output.
**Examples:**
- `return $json.items.map(i => i.name)`
- `const total = $json.prices.reduce((sum, p) => sum + p, 0); return { total }`
- `return _.groupBy($json.users, 'role')`
Code in Python code.python Execute custom Python code within the workflow.
Write Python to process data, run ML models, perform OCR, or implement complex logic. The incoming payload is available via the `input` parameter of your `main()` function.
**Convention:** Define a `main(input)` function that receives the node input as a dictionary and returns a dictionary with your results.
**Any pip package, zero setup:** Add the packages you need in the "Pip Packages" field — pandas, scikit-learn, pytesseract, transformers, or any package from PyPI. They are installed automatically before your code runs. No configuration, no Docker, no DevOps required.
**Examples:**
```python
def main(input):
items = input.get("items", [])
return {"count": len(items), "urls": [i["url"] for i in items]}
```
```python
import pandas as pd
def main(input):
df = pd.DataFrame(input.get("records", []))
summary = df.describe().to_dict()
return {"summary": summary}
```
```python
from faker import Faker
def main(input):
fake = Faker(input.get("locale", "en_US"))
count = input.get("count", 5)
return {"users": [{"name": fake.name(), "email": fake.email()} for _ in range(count)]}
```
Shell Command code.shell Execute shell commands within the workflow.
Run any shell command (bash, sh) and capture the output. Useful for system operations, file processing, CLI tools, and scripting.
**Features:**
- Full shell access with configurable working directory and timeout.
- Stdout and stderr captured separately.
- Supports {{expressions}} in the command field to inject data from upstream nodes.
**Examples:**
- `curl -s https://api.example.com/data | jq '.results'`
- `ls -la /tmp/uploads/ | wc -l`
- `echo "{{$json.message}}" | base64`
Chunk Text data.chunk Split large text into smaller chunks for parallel processing.
Essential for processing documents that exceed LLM context windows. Supports multiple splitting strategies with configurable overlap to prevent losing information at chunk boundaries.
**Split Modes:**
- **Pages:** Split at page markers (--- PAGE N ---). Groups pages to stay under chunk size. Best after OCR.
- **Paragraphs:** Split at paragraph boundaries (double newline). Groups paragraphs to stay under chunk size.
- **Characters:** Split at character boundaries with smart backtracking to sentence/paragraph ends.
Date & Time data.datetime Manipulates date and time values, offering formatting, calculations, and current time generation.
This utility does not rely on external services and uses the 'luxon' library for robust handling of timezones and formats.
**Operations:**
- **Now:** Returns the current date/time in the specified timezone.
- **Format:** Converts a date string into a specific format pattern.
- **Add:** Adds time (minutes, days, etc.) to a given date.
- **Diff:** Calculates the difference between two dates in a specific unit.
**Use Cases:**
- Generating timestamps for DB records.
- Calculating "Due Date" (Now + 7 Days).
- Formatting dates for email templates (e.g., "Jan 01, 2024").
Data Lookup data.lookup Retrieves a value from a provided dictionary or map based on a specific key.
This operator is used for simple reference data enrichment. It takes a static or dynamic source map and attempts to find a match for the input key.
**Use Cases:**
- **Enrichment:** looking up a "Country Name" from a "Country Code" (e.g., "US" -> "United States").
- **Mapping:** Translating status codes (e.g., 200 -> "OK").
- **Authorization:** Checking if a User ID exists in an "Admin List".
Math Operations data.math Performs mathematical calculations or aggregations on data.
This operator provides standard arithmetic and aggregation functions. For complex formulas, the JSONata `expr` mode is powerful.
**Operations:**
- **Sum/Avg/Min/Max:** Aggregations over a list of numbers.
- **Advanced (Expr):** Custom math expressions (e.g. `$round(price * 1.2, 2)`).
**Use Cases:**
- Calculating the total value of items in a shopping cart.
- Finding the highest bid in an auction list.
- Computing tax percentages.
Parse Data data.parse Parses a raw string into a structured data object.
Essential for handling incoming data from external systems, files, or legacy APIs that return data as serialized strings (JSON, CSV, XML, YAML).
**Supported Formats:**
- **JSON:** Standard JSON parsing.
- **CSV:** Comma-Separated Values (can output Array of Objects).
- **XML:** Converts XML to JSON structure.
- **YAML:** Parse YAML to JSON.
**Use Cases:**
- Converting an HTTP response body string into useable JSON variables.
- Parsing a CSV file uploaded by a user.
Stringify Data data.stringify Serializes a structured data object into a string format.
This is the inverse of 'Parse Data'. It is useful when you need to send a JSON object as a raw string body to an API, save a configuration to a text file, or generate a CSV report from a list of items.
**Supported Formats:**
- **JSON:** Standard JSON serialization (with optional pretty-print).
- **CSV:** Converts a list of objects to Comma-Separated Values.
- **XML:** Converts an object tree to XML.
- **YAML:** Converts an object to YAML.
**Use Cases:**
- preparing a payload for an `http.request` body.
- Generating a downloadbale CSV export.
Render Template data.template Generates dynamic text using the Handlebars templating engine.
This operator allows you to merge data variables into a text template. It is ideal for constructing emails, SMS messages, HTML documents, or SQL queries.
**Features:**
- **Handlebars Syntax:** usage of `{{variable}}`, `{{#each list}}`, `{{#if condition}}`.
- **Rich Input:** Full access to the payload as context.
**Use Cases:**
- Creating a personalized email body: "Hello {{user.name}}..."
- Constructing a complex file path: "/archives/{{year}}/{{month}}/report.pdf"
Transform Data data.transform Transforms the input payload using powerful JSONata expressions.
This is the primary tool for data mapping and structural transformation logic within the workflow. It allows you to reshape, filter, and mathematically compute new values from the input JSON.
**Features:**
- Full JSONata syntax support.
- Access to the entire workflow context.
- Capability to query and aggregate data.
**Use Cases:**
- Mapping an API response to an internal model.
- Filtering items from a list (e.g., `items[price > 50]`).
- Calculating totals (e.g., `$sum(items.price)`).
Generate UUID data.uuid Generates a cryptographically strong unique identifier (UUID/NanoID).
This operator produces unique strings suitable for database keys, transaction IDs, or idempotency tokens.
**Formats:**
- **v4:** Random UUID (Standard).
- **v5:** Name-based UUID (Deterministic based on namespace + name).
- **NanoID:** Compact, URL-friendly unique string.
**Use Cases:**
- Assigning an ID to a newly created resource.
- Generating a correlation ID for tracking request chains.
Validate Data data.validate Validates the input payload against a JSON Schema (Draft-07).
Ensures data quality and integrity by strictly enforcing structure, types, and constraints before proceeding in the workflow. If validation fails, execution is routed to the 'invalid' port with detailed error metadata.
**Features:**
- Uses AJV (Another JSON Validator) under the hood.
- Supports full JSON Schema specification.
- Provides detailed error reports in the metadata.
**Use Cases:**
- Verifying API request bodies.
- Ensuring mandatory fields exist before database insertion.
- Validating configuration parameters.
If Condition flow.if Evaluates a boolean condition against the input payload to bifurcate the execution flow.
This operator functions as a gateway that routes execution to either the 'true' or 'false' port based on the result of the configured expression. It supports two evaluation modes: the Sommatic Expression Engine ({{ }} syntax, full JavaScript via vm.Script) as the primary engine, and raw JSONata as a simpler fallback for expressions entered without {{ }}.
**Behavior:**
- If the expression evaluates to a truthy value, execution proceeds through the 'true' port.
- If the expression evaluates to a falsy value, execution proceeds through the 'false' port.
- If 'treat_missing_as' is set to true and the expression yields undefined/null, it is treated as false.
Join / Merge flow.join Consolidates multiple execution branches back into a single path.
This operator implements the 'Fan-In' synchronization pattern. It is essential when a concurrent split (Fan-Out) needs to be gathered back for aggregated processing. It waits for upstream signals based on the configured mode before proceeding.
**Modes:**
- **Wait All:** Blocks until ALL incoming branches have completed. Ideal for parallel processing where all results are needed.
- **Wait Any:** Proceeds as soon as the FIRST branch completes. ideal for race conditions or redundancy checks.
**Output:**
The result is an array containing the payloads from all joined branches: `[result1, result2, ...]`.
Mutex Lock flow.mutex Ensures exclusive access to a critical section of the workflow via a distributed lock.
When multiple workflow instances (or parallel branches) try to access a shared resource simultaneously, a Mutex (Mutual Exclusion) ensures only one can proceed at a time. Other instances will wait until the lock is released or a timeout occurs.
**Behavior:**
- **Acquire:** Attempts to lock the key. If free, lock is granted.
- **Wait:** If locked, the process spins/waits.
- **Release:** The lock is automatically released after the TTL expires (to prevent deadlocks).
**Use Cases:**
- Preventing double-spending on a user wallet.
- Serializing access to a legacy system that cannot handle concurrency.
- Ensuring "Check-then-Act" atomicity in database operations.
Rate Limit flow.rate.limit Throttles the number of executions allowed within a specific time window.
This operator enforces a rate limit policy (e.g., "10 requests per minute"). If the limit is exceeded, subsequent executions are routed to the 'throttled' port (or delayed, depending on engine configuration).
**Behavior:**
- **Key-based Throttling:** Can throttle globally or per-key (e.g., per user ID).
- **Strategies:** Fixed Window, Sliding Window (engine dependent).
- **Overflow:** Excess requests trigger the 'throttled' port immediately.
**Use Cases:**
- Protecting a fragile downstream API from overload.
- Enforcing usage quotas for different user tiers.
- Preventing spam or abuse.
Split In Batches flow.split Splits an array into individual items or batches for parallel or iterative processing.
This operator allows you to iterate over a list of items found in the input payload. For each item (or batch of items), it triggers the 'loop' output port. Once all items have been processed, it triggers the 'done' port.
**Behavior:**
- **Iteration:** Emits a message for each item/batch in the array.
- **Context Preservation:** Child executions inherit the parent context.
- **Batching:** Can group items into batches (e.g., size 10) for efficiency.
**Use Cases:**
- Processing a list of new users from a CSV.
- Sending emails to a segment of subscribers.
- Processing order line items individually.
Switch (Route) flow.switch Routes the execution flow to one of multiple ports based on a matching condition.
This operator functions similarly to a switch-case or if-else-if ladder. It evaluates a list of defined 'cases' in order. The first case whose expression evaluates to true triggers its corresponding output port. If no cases match, execution is routed to the 'default' port.
**Behavior:**
- **Sequential Evaluation:** Cases are checked in the order defined.
- **First Match:** By default, stops after the first true condition.
- **Default Path:** If no conditions are met, the 'default' port is activated.
**Use Cases:**
- Routing orders based on status (e.g., 'pending' -> Port A, 'shipped' -> Port B).
- Categorizing support tickets by priority.
- Handling different event types in a webhook.
Try / Catch flow.try Defines a scope for error handling.
This operator marks the beginning of a "Try" block. Any errors occurring in the downstream nodes connected to the 'do' port will be caught and routed to the corresponding "Catch" handler (structurally defined in the workflow graph).
**Behavior:**
- **Normal Flow:** Passes payload to 'do'.
- **Error Scoping:** The engine registers this node as the error handler for its children.
- **Catch:** Errors in children trigger the configured 'Catch' operator (if any).
**Use Cases:**
- Wrapping a risky API call.
- Implementing "Compensating Transactions" for a specific step.
- Graceful degradation (fallback logic).
Wait / Delay flow.wait Pauses the execution flow for a specified duration or until a specific timestamp.
This operator is used to introduce delays or schedule execution for a future time. It relies on the orchestration engine to suspend the workflow and resume it at the calculated wake-up time.
**Modes:**
- **Duration:** Waits for a relative amount of time (e.g., "5 minutes").
- **Timestamp:** Waits until a specific absolute date/time (e.g., "2025-12-31T23:59:59Z").
**Use Cases:**
- Sending a follow-up email 24 hours after sign-up.
- Waiting for a connection retry backoff.
- Pausing a workflow until a specific business date.
Time Window flow.window Aggregates events into time-based or count-based windows.
This operator allows processing of streams of data by grouping them into "windows". It buffers incoming payloads and emits them as a batch when the window conditions are met.
**Window Types:**
- **Tumbling:** Fixed non-overlapping windows (e.g., every 5 minutes).
- **Sliding:** Overlapping windows (e.g., last 5 minutes, updated every minute).
- **Count:** Window of N items.
**Use Cases:**
- Aggregating sensor readings every minute.
- Batching analytics events before sending to a data warehouse.
- Detecting patterns A -> B within a specific timeframe.
Approval Gate human.approval.gate Configures the approval gate on a task created by a preceding Create Task node. Writes payload.hitl + execution.app_slug via PATCH to the backend.
Create Task human.task.create Creates a human task in the Work Management system.
Execute Sommatic App sommatic.app.execute Requests a user to interact with a specific Sommatic App UI.
Check Consent consent.check Checks if User has consented to activity.
Decrypt Data crypto.decrypt Decrypts data using AES.
Encrypt Data crypto.encrypt Encrypts data using AES.
Hash Data crypto.hash Hashes data using SHA/MD5.
Redact PII pii.redact Redacts Personally Identifiable Information (PII) from text or JSON objects to ensure data privacy and compliance.
Inspect Token token.inspect Decodes and verifies a JWT.
Issue Token token.issue Issues a new JWT access or session token.
Veripass Policy Evaluation veripass.evaluate Evaluates access policies against Veripass Identity Contract.
Integrations Outlook - Attachments connectors.microsoft.outlook.attachments Download and manage email attachments from Microsoft Outlook via Microsoft Graph API.
Dedicated attachment handler for corporate environments with high-volume email processing. Supports filtering by type, size, pagination for emails with many attachments, and streaming to disk for large files.
**Operations:**
- **List:** Get metadata of all attachments (name, type, size) without downloading content.
- **Download:** Download attachment content as base64 or write directly to temporary files.
- **Download All:** Download all attachments from a message with optional filtering.
Integrations Outlook - Mail connectors.microsoft.outlook.mail Send, read, and manage emails through Microsoft Outlook via the Microsoft Graph API.
Connect your Microsoft 365 account and automate email operations — send notifications, process incoming mail, manage drafts, and more.
**Operations:**
- **Send:** Compose and send a new email with recipients, subject, body, and optional attachments.
- **Reply:** Reply to an existing email by message ID.
- **Get:** Retrieve a specific email by message ID.
- **List:** List emails from a folder with optional filtering.
- **Delete:** Delete an email by message ID.
- **Forward:** Forward an email to new recipients.
Integrations Outlook - Message Category connectors.microsoft.outlook.message.category Apply Outlook categories (labels) to messages via the Microsoft Graph API.
Categories live in the user master list and can be applied to messages with a merge-safe PATCH that preserves categories already set by humans or other automations.
**Operations:**
- **apply:** Apply one or more categories to an existing message. Merges with existing categories (does not overwrite).
- **ensure_master_category:** Create one or more categories in the user master list. Idempotent: returns success if the category already exists.
- **apply_with_ensure:** Combination of the two. Recommended for workflows that should self-bootstrap their categories.
Integrations Outlook - New Email connectors.microsoft.outlook.trigger Triggers when a new email arrives in a Microsoft Outlook mailbox.
Listens for incoming emails via Microsoft Graph API subscriptions. When a new email is received, the workflow is triggered with the full email data (id, subject, from, body, attachments info).
**How it works:**
- When the workflow starts, a Graph API subscription is created for the configured mailbox.
- Microsoft notifies Sommatic when a new email arrives.
- The trigger fetches the full email and passes it to the next node.
**Use Cases:**
- Auto-reply to incoming support emails.
- Process email attachments (OCR, classification).
- Route emails to different workflows based on sender or subject.
Integrations Outlook - Multi-Mailbox Trigger connectors.microsoft.outlook.trigger.multi Triggers when a new email arrives in ANY of multiple Microsoft Outlook mailboxes.
Enterprise-grade multi-tenant mailbox listener. A single trigger node watches a list of mailboxes in parallel and fires **one workflow execution per new email**, with the originating mailbox identified in the payload. Ideal for shared inbox architectures (PQRS, support, legal intake, HR) where several functional mailboxes must feed the same triage workflow.
**How it works:**
- On each polling cycle, the trigger checks ALL configured mailboxes in parallel (one Graph API call per mailbox).
- Every new email found is emitted as an independent trigger fire — if 3 mailboxes each receive 1 new email in the same cycle, the workflow executes 3 times.
- The originating mailbox is exposed as `mailbox_email` in the output payload so downstream nodes can route or tag accordingly.
- `lastTimeChecked` state is tracked **per mailbox** independently (so a slow-polling mailbox does not block others).
- If an email has many attachments, the `heavy_attachments` port is used instead of `out` for dedicated downstream processing.
**When to prefer this over the single-mailbox trigger:**
- You have 2+ shared inboxes that should run the same workflow.
- You want to avoid maintaining N parallel workflows (one per mailbox) that all do the same thing.
- You need consistent state tracking across a mailbox cluster.
**When NOT to prefer this:**
- You have >10K emails/month and need sub-second latency — use Graph webhooks + a queue (e.g. Service Bus) instead.
- Each mailbox has materially different downstream logic — use separate workflows.
Integrations AWS - S3 Storage integrations.aws.s3.storage Upload, download, list, and delete objects on Amazon S3 or S3-compatible storage.
Connect your AWS account and automate object storage operations — store files, retrieve documents, list bucket contents, and manage object lifecycle.
**Operations:**
- **Get Object:** Download an object's content by key.
- **Put Object:** Upload content to a specific key in the bucket.
- **List Objects:** List objects in a bucket with optional prefix filtering.
- **Delete Object:** Remove an object by key.
Integrations Azure - Blob Storage integrations.microsoft.azure.blob Upload, download, list, and delete blobs (files) on Azure Blob Storage containers.
Connect your Azure Storage Account and automate file operations — store workflow outputs, retrieve documents for processing, list container contents, and manage blob lifecycle.
**Operations:**
- **Upload:** Upload content to a blob in the specified container.
- **Download:** Download a blob's content by name.
- **List:** List all blobs in a container.
- **Delete:** Delete a specific blob by name.
Integrations Azure - CosmosDB integrations.microsoft.azure.cosmos Execute queries and CRUD operations on Azure CosmosDB NoSQL containers.
Connect your Azure CosmosDB account and automate database operations — run SQL queries, read documents by ID, upsert records, and delete items.
**Operations:**
- **Query:** Execute a SQL query against a container with optional parameters.
- **Read:** Retrieve a single document by its ID and partition key.
- **Upsert:** Create or update a document in the container.
- **Delete:** Remove a document by its ID and partition key.
Integrations Azure - AI Document Intelligence integrations.microsoft.azure.document-intelligence Execute layout analysis, form understanding, and structured extraction on complex documents using Microsoft Azure AI Document Intelligence (formerly Azure Form Recognizer).
Authenticates with your own Azure resource via `connection_id` (api-key credential with `endpoint` metadata); execution costs are billed by Azure to your subscription.
**Operations (prebuilt and custom models):**
- **prebuilt-layout** (default): full page structure — paragraphs, tables, selection marks, reading order.
- **prebuilt-document:** generic key-value and entity extraction across arbitrary forms.
- **prebuilt-invoice:** typed schema for invoice fields (vendor, totals, line items, dates).
- **prebuilt-receipt:** typed schema for retail receipts (merchant, totals, taxes, items).
- **prebuilt-tax.us.w2:** typed schema for U.S. W-2 tax forms.
- **prebuilt-id:** typed schema for government-issued identification documents.
- **prebuilt-healthInsuranceCard.us:** typed schema for U.S. health insurance cards.
- **prebuilt-read:** page-level OCR with handwriting and multi-language support.
- **custom-<id>:** user-trained models for specific document templates.
Integrations Azure - AI Speech integrations.microsoft.azure.speech Execute production-grade Automatic Speech Recognition (ASR) on audio streams using Microsoft Azure AI Speech.
Authenticates with your own Azure resource via `connection_id` (api-key credential with `region` metadata); execution costs are billed by Azure to your subscription.
**Operations:**
- **Continuous recognition:** Streams audio of any length through the long-running recognition endpoint — meetings, calls, long-form media.
- **Speaker diarization:** When `diarization.enabled` is true, uses the ConversationTranscriber to tag each segment with a speaker identifier and return a structured `speakers` array.
- **Custom vocabulary bias:** Phrase list injected into the recognizer to improve accuracy on names, acronyms, product terms, and jargon.
- **Locale selection:** 100+ BCP-47 locales (`es-CO`, `en-US`, `pt-BR`, `fr-FR`, ...); auto-detection is available in the underlying API when no locale is supplied.
- **Segment timestamps:** Per-segment start/end timestamps returned in `segments` for subtitles, chaptering, and evidence anchoring.
Integrations SQL Server - Query integrations.microsoft.sqlserver.query Execute SQL queries and stored procedures on Microsoft SQL Server databases.
Connect your SQL Server instance (on-premise or Azure SQL) and run parameterized queries with @paramName binding for SQL injection prevention. Supports connection pooling and automatic cleanup.
**Operations:**
- **SELECT:** Fetch rows from tables with filters, joins, and aggregations.
- **INSERT:** Add new records to tables.
- **UPDATE:** Modify existing records matching a condition.
- **DELETE:** Remove records from tables.
- **Stored Procedures:** Execute stored procedures with named input parameters.
- **DDL:** Execute CREATE, ALTER, DROP statements for schema management.
Integrations MongoDB - Operation integrations.mongodb.operation Execute CRUD operations and aggregation pipelines on MongoDB collections.
Connect your MongoDB instance and automate database operations — query documents, insert records, update fields, delete entries, and run aggregation pipelines.
**Operations:**
- **Find:** Query multiple documents with a filter.
- **Find One:** Retrieve a single document matching a filter.
- **Insert One / Insert Many:** Add one or multiple documents.
- **Update One / Update Many:** Modify documents matching a filter.
- **Delete One:** Remove a single document.
- **Aggregate:** Run an aggregation pipeline.
Integrations OpenAI - GPT-4o Vision integrations.openai.gpt-4o.vision Invoke OpenAI GPT-4o (Omni) via the Chat Completions API for image understanding, vision-based OCR, and visual reasoning over diagrams and charts.
Routes through the backend `POST /cognitive-infrastructure/cognitive-assets/llm-provider/invoke` endpoint using an `llm_provider_id` registered in the cognitive-assets registry. Billing is handled directly by OpenAI or Azure OpenAI against your subscription. Compatible with any GPT-4 class model that exposes the `vision` capability (GPT-4o, GPT-4o mini, GPT-4 Turbo with vision).
**Operations:**
- **Image captioning:** Natural-language descriptions of photographs, screenshots, and product imagery.
- **Chart and diagram interpretation:** Structured extraction of data series, labels, and relationships from bar charts, line charts, flow diagrams, and images containing tables.
- **Vision-based OCR:** Reads text in layouts that defeat classical OCR — low contrast, unusual typography, handwriting, skewed scans, stylized signage.
- **Scene understanding:** Identifies objects, activities, and contextual cues to support moderation, tagging, and routing workflows.
**Inputs:** base64-encoded image or a public image URL.
**Controls:** system prompt, user prompt (expression-enabled), temperature, and max tokens exposed as node configuration so the same node can run deterministic OCR-style calls or creative captioning.
Integrations MySQL - Query integrations.oracle.mysql.query Execute SQL queries on MySQL and MariaDB databases.
Connect your MySQL instance and run parameterized queries with positional ? binding for SQL injection prevention. Compatible with MySQL, MariaDB, and similar databases.
**Operations:**
- **SELECT:** Fetch rows from tables with filters, joins, and aggregations.
- **INSERT:** Add new records to tables.
- **UPDATE:** Modify existing records matching a condition.
- **DELETE:** Remove records from tables.
- **Stored Procedures:** Call stored procedures via CALL statements.
- **DDL:** Execute CREATE, ALTER, DROP statements for schema management.
Integrations PostgreSQL - Query integrations.postgresql.query Execute SQL queries on PostgreSQL databases.
Connect your PostgreSQL instance and run parameterized queries with $1, $2 positional binding for SQL injection prevention. Compatible with PostgreSQL, CockroachDB, Supabase, and Neon.
**Operations:**
- **SELECT:** Fetch rows from tables with filters, joins, and aggregations. Returns empty port when no results.
- **INSERT:** Add new records to tables with RETURNING support.
- **UPDATE:** Modify existing records matching a condition.
- **DELETE:** Remove records from tables.
- **Functions:** Call PL/pgSQL functions and stored procedures.
- **DDL:** Execute CREATE, ALTER, DROP statements for schema management.
Integrations Redis - Command integrations.redis.command Execute commands on a Redis key-value store.
Connect your Redis instance and automate cache and data operations. Send any Redis command with arguments — from simple key-value reads to complex data structure manipulation.
**Operations:**
- **GET / SET / MGET / MSET:** Read and write string values, bulk operations.
- **HGET / HSET / HGETALL:** Work with hash maps (field-value pairs).
- **LPUSH / RPUSH / LPOP / LRANGE:** Manage ordered lists.
- **SADD / SMEMBERS / SINTER:** Work with sets and intersections.
- **ZADD / ZRANGE / ZRANGEBYSCORE:** Sorted sets with scoring.
- **DEL / EXISTS / TTL / EXPIRE:** Key lifecycle and expiration management.
- **INCR / DECR:** Atomic counters.
- **PUBLISH:** Publish messages to channels.
Desktop Clipboard io.desktop.clipboard Read/Write to System Clipboard.
Desktop Input (HID) io.desktop.input Simulate Keyboard/Mouse input.
OS Notification io.desktop.notify Show system notification.
Open File/URL io.desktop.open Open a file or URL in default system application.
Desktop Screenshot io.desktop.screenshot Capture desktop screenshot.
FTP/SFTP Client io.ftp Transfer files via FTP/SFTP.
GraphQL Client io.graphql Execute GraphQL Query or Mutation.
gRPC Client io.grpc Call gRPC Service method.
HTTP Client io.http Make HTTP Requests.
Read Email (IMAP) io.imap Read emails from IMAP server.
JSON-RPC Client io.jsonrpc Call JSON-RPC 2.0 Method.
Local File System io.local.file Read/Write files on host machine.
Local Shell Command io.local.shell Execute shell command on the host machine.
MQTT Client io.mqtt Publish to MQTT Broker.
Send Email (SMTP) io.smtp Send emails via SMTP server.
SOAP Client io.soap Make SOAP Web Service calls.
SSH Command io.ssh Execute commands on remote server via SSH.
WebSocket Client io.websocket Send message to WebSocket Server.
Append Audit Log audit.append Appends an immutable entry to the secure audit trail.
This operator ensures compliance and traceability by recording key decisions, data access, or modifications. Entries are signed and stored in a tamper-evident audit log.
**Fields:**
- **Actor:** Who performed the action (User/Service).
- **Action:** What happened (e.g., "Approved Loan").
- **Resource:** Target entity (e.g., "Loan #123").
- **Evidence:** JSON payload proving the action.
**Use Cases:**
- Regulatory compliance (GDPR, HIPAA).
- Debugging security incidents.
- Tracking approval chains.
Emit Metric metrics.emit Publishes custom operational telemetry (metrics) to the monitoring system.
These metrics are aggregated by the platform (e.g., Prometheus, Datadog) to visualize workflow health, business KPIs, or performance trends.
**Metric Types:**
- **Counter:** Monotonically increasing number (e.g., "Total Orders").
- **Gauge:** A value that goes up and down (e.g., "Current Queue Size").
- **Histogram:** Distribution of values (e.g., "Processing Time").
**Use Cases:**
- Tracking the number of failed validations.
- Monitoring the value of processed transactions.
- Alerting on unexpected business logic paths.
Checkpoint ops.checkpoint Marks a guaranteed durability point in the workflow execution.
A Checkpoint acts as a "Save Game" spot. If the workflow crashes or is restarted, it can resume from the last successful checkpoint rather than restarting from the beginning. It also supports Idempotency, identifying duplicate requests to prevent double-processing.
**Behavior:**
- **First Run:** Persists the checkpoint and triggers 'success'.
- **Replay:** Detects the checkpoint exists and triggers 'skip' (or returns the previous output).
- **Hashing:** Can optionally hash the input payload to ensure it's the *exact same* request.
**Use Cases:**
- Between charging a credit card and shipping a product.
- Ensuring an email is sent exactly once.
Deduplicate ops.dedupe Filters duplicate payloads based on a derived key and time window.
This operator ensures that specific events are processed only once within a given timeframe. It is crucial for handling "at-least-once" delivery systems where duplicate messages might occur (e.g., Queue retries, Webhook replays).
**Behavior:**
- Calculates a unique key from the input payload (via template/expression).
- Checks if the key exists in the cache.
- **Unique:** If new, passes to 'unique' port and caches key.
- **Duplicate:** If exists, passes to 'duplicate' port (or drops).
**Use Cases:**
- Ignorning double-clicks on a "Submit" button.
- Processing a specific webhook ID only once.
Read State ops.state.read Retrieves a persistent value from the workflow state store.
This operator is used to access data saved in previous steps or even from other workflows (using Global/Case scope). It provides a way to maintain context across long-running or distributed executions.
**Behavior:**
- Attempts to find the key in the specified scope.
- If found, returns the value.
- If not found, triggers the 'miss' port to allow for fallback logic.
**Use Cases:**
- Retrieving a cached user profile.
- Validating if a previous step completed via a state flag.
Write State ops.state.write Persists a value to the persistent state store.
This operator allows workflows to remember information across different execution steps, or even share data between different workflows (using Global scope).
**Scopes:**
- **Instance:** Visible only to this workflow run.
- **Case:** Visible to all workflows in the same Case/Thread.
- **Global:** Visible system-wide (use with caution).
**Use Cases:**
- Saving a user's progress.
- Caching an API token.
- Passing data from a parent workflow to a child workflow via 'Case' scope.
End Trace Span ops.trace.end Closes an active distributed tracing span.
This operator marks the completion of a specific unit of work (Span). It calculates the duration and finalizing the span status (success/error). It is essential for accurate APM (Application Performance Monitoring) and constructing the full trace waterfall.
**Use Cases:**
- Measuring the latency of an external API call block.
- Grouping a set of complex logic steps into a single readable span.
- Recording the final status of a custom transaction.
Start Trace Span ops.trace.start Initiates a new Distributed Tracing Span for deep observability.
Spans allow you to visualize the duration and details of a specific block of work in a trace waterfall graph. This operator starts a custom span, which must typically be closed by a corresponding 'End Span' (or happens automatically at workflow end).
**Use Cases:**
- Explicitly measuring the duration of a specific group of steps.
- Adding business-specific attributes (tags) to a trace segment.
- Correlating with external systems via Parent Trace ID.
Begin Saga saga.begin Initiates a distributed transaction using the Saga pattern.
The Saga pattern manages long-running transactions by breaking them into a sequence of sub-transactions. If any step fails, the Saga orchestrator executes compensating transactions (undo steps) to rollback the changes and maintain eventual consistency.
This operator marks the beginning of a Saga scope. It initializes a unique Saga ID and tracks the transaction steps.
**Key Concepts:**
- **Steps:** A sequence of actions ("do") and their rollbacks ("undo").
- **Compensation:** The reverse action triggered on failure.
- **Traceability:** All actions in the scope are linked by "saga_id".
**Use Cases:**
- E-commerce order processing (Inventory -> Payment -> Shipping).
- Booking travel (Flight -> Hotel -> Car).
Compensate Saga saga.compensate Triggers the compensation process for a distributed transaction (Saga).
When a failure occurs in a long-running transaction, this operator instructs the engine to "rollback" by executing the registered compensation steps for all previously successful activities in reverse order.
**Behavior:**
- Identifies the active Saga Scope.
- Retrieves the 'undo' operations for completed steps.
- Executes them stack-wise (LIFO).
**Use Cases:**
- Rolling back a payment if inventory reservation fails.
- Cancelling a hotel booking if the flight is unavailable.
Vectry Log vectry.log Emits a structured causal event to the Vectry Operational Intelligence Platform.
Vectry uses these events to construct a Causal Graph of your system, enabling advanced XAI (Explainable AI), anomaly detection, and root cause analysis. Unlike standard logs, Vectry events are linked by entities and operations to model *cause and effect*.
**Key Concepts:**
- **Entity:** The noun (e.g., "Order", "User").
- **Operation:** The verb (e.g., "Created", "Updated").
- **Context:** Payload data that helps explain the event.
**Use Cases:**
- Reporting significant business milestones (e.g., "LoanApproved").
- Logging internal AI reasoning steps (SpikingBrain integration).
- Tracking distributed system interactions.
Cron Schedule cron.trigger Initiates workflow execution on a precise schedule using CRON syntax.
This trigger is the entry point for time-based automation. It supports standard CRON expressions for defining recurring intervals (e.g., "Every Friday at 5 PM").
**Features:**
- **Standard Cron:** Full support for "* * * * *" syntax.
- **Timezones:** Schedule respects localized time zones.
- **Jitter:** Optional random delay to prevent "thundering herd" issues.
**Use Cases:**
- Generating daily reports.
- Running nightly cleanup jobs.
- Polling an API every 15 minutes.
Vectry Event Subscription event.trigger Trigger workflow execution based on internal system events (Event Bus).
This trigger subscribes to the Vectry Causal Event Bus. It listens for specific business or system events (e.g., "Order Created", "User Signup") and initiates the workflow when a matching event occurs.
**Features:**
- **Filtering:** Subscribe only to events matching specific criteria (domain, entity, tag).
- **Replay:** Process historical events ("since") or only new ones.
- **Pattern Matching:** Trigger on complex event sequences (if configured).
**Use Cases:**
- Sending a Welcome Email when a 'UserCreated' event occurs.
- Auditing high-value transactions.
Manual / Ad-Hoc Trigger manual.trigger Allows a workflow to be started manually by a user or administrator.
This trigger defines the "Start Button" for a workflow. It is commonly used for testing, debugging, or workflows that require explicit human initiation (e.g., "Run End of Month Report").
**Features:**
- **Form Input:** Can define a schema for the input payload the user must provide when clicking "Run".
- **Testing:** Ideal for validating logic with disparate test datasets.
**Use Cases:**
- Launching a one-off database migration script.
- Testing a new workflow with mock customer data.
Queue / Topic Consumer queue.trigger Consumes messages from an external Message Queue or Pub/Sub Topic.
This trigger connects to external brokers (like RabbitMQ, Kafka, SQS, or Redis) and initiates a workflow instance for each incoming message.
**Key Features:**
- **Backpressure:** Supports `prefetch` to limit concurrent workflow instantiations.
- **Reliability:** Supports Auto or Manual Acknowledgement (Ack/Nack) to ensure message delivery guarantees.
**Use Cases:**
- Processing tasks offloaded from a main web server.
- Event-driven architecture integrating with legacy systems.
Webhook Receiver webhook.trigger Listens for external HTTP requests to trigger the workflow.
This operator exposes a unique URL endpoint. When an external service (e.g., Stripe, Typeform, GitHub) sends a POST request to this URL, the workflow is instantiated with the request body as the payload.
**Features:**
- **Method Agnostic:** Can be configured to accept POST, GET, PUT.
- **Authentication:** Supports validating headers or signatures/secrets.
- **Response:** Can define what response to send back to the caller (Sync vs Async).
**Use Cases:**
- Integrating form submissions (Typeform).
- Reacting to payment events (Stripe Webhook).
- Building a custom API endpoint.
Workflow Chain Receiver workflow.trigger Receives execution requests from another workflow's Chain node.
This trigger acts as the entry point for a workflow that is invoked by another workflow via the `workflow.chain` node. It enables peer-to-peer workflow chaining without creating a parent-child hierarchy.
**Features:**
- **Caller Filtering:** Optionally restrict which workflows can chain into this one.
- **Payload Passthrough:** The calling workflow's payload is available as `$json` in downstream nodes.
- **Traceability:** Chain context (caller instance, node, correlation ID) is preserved for audit.
**Use Cases:**
- Modular workflow composition (e.g., shared validation workflow invoked by multiple callers).
- Event-driven chaining where Workflow A completes a phase and delegates to Workflow B.
- Reusable sub-processes that remain independently testable and deployable.
Workflow Chain workflow.chain Invokes another workflow and optionally waits for its result.
This operator enables peer-to-peer workflow chaining. It triggers a target workflow and can operate in synchronous (wait for result) or asynchronous (fire-and-forget) mode.
**Features:**
- **Sync Mode:** Waits for the target workflow to complete and returns its result.
- **Async Mode:** Fires the target workflow and continues immediately with the instance ID.
- **Traceability:** Correlation ID links both workflow instances for audit and debugging.
- **Payload Forwarding:** Define exactly what data to pass to the target workflow.
**Use Cases:**
- Composing complex processes from reusable workflow modules.
- Delegating specialized processing (e.g., validation, enrichment) to dedicated workflows.
- Fan-out patterns where one workflow triggers multiple independent workflows.
