> ## Documentation Index
> Fetch the complete documentation index at: https://docs.flowx.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Workflow node reference: data, document, and AI nodes

> Configure workflow nodes that parse and generate tabular files, fill templates, send notifications, merge or split PDFs, retrieve context, and run AI agents.

This page describes the data, document, and AI nodes you use in [Integration Designer workflows](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/integration-workflows.md). For every node type, see the [workflow nodes overview](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/integration-workflows.md#workflow-nodes-overview).

## Tabular Data Extraction node

Reads a CSV or spreadsheet file and returns its rows as structured JSON, so extracted data can drive conditions, script logic, and data operations downstream. Available under **Tools** in the workflow node palette.

**Configuration:**

* **Use Test File** — toggles where the file comes from. **OFF**: provide **File Path**, the download path of a file available at run time (for example, produced by a previous node or a file upload); supports `${}` expressions. **ON**: select an uploaded test file — useful while building and testing the workflow
* **Sheet** (Excel only) — the sheet name to extract from; leave empty to use the first sheet
* **Response Key** — where the node writes its output; the extracted rows are stored under `<responseKey>.data`

**Supported files:** CSV, XLS, and XLSX, up to 15 MB for test-file uploads.

Each row becomes a JSON object keyed by the header row (the file's first row), with every value returned as a **string**. For a file with columns `id`, `name`, and `role` and response key `rows`:

```json theme={"dark"}
{
  "rows": {
    "data": [
      { "id": "1", "name": "Alice", "role": "Engineer" },
      { "id": "2", "name": "Bob", "role": "Designer" }
    ]
  }
}
```

> [!NOTE]
>
> The node outputs data, not a file — its result cannot be passed to the file-manipulation nodes (Combine Files, Split File). To extract structured data from unstructured documents such as PDFs or images, use the **Extract Data from File** AI node instead.

If extraction fails (missing file, unknown sheet name, or an unsupported format), an `error` object is returned on the same key. An empty file returns an empty `data` array.

### Data Parse: XML and JSON support

The node appears in the **Tools** palette as **Data Parse**, described as "Parse CSV, spreadsheet, XML or JSON files into structured JSON." Workflows that already use the node keep working: the node type and its configuration fields are unchanged.

* **Accepted files**: CSV, XLS, XLSX, and XLSM spreadsheets, plus **XML** and **JSON** files. Test file uploads are still capped at 15 MB. Uploaded XML and JSON test files are listed with the **Structured Data** type.
* **Sheet**: applies to Excel files only (`.xls`, `.xlsx`, `.xlsm`) and is ignored for CSV, XML, and JSON.
* **Output**: always under `<responseKey>.data`. Spreadsheets return rows as described above. XML and JSON files return an object tree.
* **Size and depth limits**: XML and JSON files are parsed up to 5 MB. XML nested deeper than 64 levels is rejected.

A **JSON** file is returned as it is, once the node has checked that it holds a single well-formed JSON document.

An **XML** file is converted with these rules:

* The root element is unwrapped: `data` holds its content, not an object keyed by the root name.
* An element with only text becomes a string. An empty element becomes an empty string.
* Attributes become keys. When an element has both attributes and text, the text is stored under `value`.
* Sibling elements with the same name become an array. A single occurrence stays an object, so plan for both shapes when the count can vary.
* Namespaces are dropped and only local names are kept. All values are strings.
* Document type definitions (DTDs) and external entities are not processed.

For this file and response key `customers`:

```xml theme={"dark"}
<customers>
  <customer id="1">
    <name>Alice</name>
    <role>Engineer</role>
  </customer>
  <customer id="2">
    <name>Bob</name>
    <role>Designer</role>
  </customer>
</customers>
```

the node returns:

```json theme={"dark"}
{
  "customers": {
    "data": {
      "customer": [
        { "id": "1", "name": "Alice", "role": "Engineer" },
        { "id": "2", "name": "Bob", "role": "Designer" }
      ]
    }
  }
}
```

A file downloaded by a **File Storage Operation** node can be parsed too. Its format is recognized from the file name, so keep the extension (for example, `.xml` or `.json`) on the stored file. Malformed XML or JSON, a file over the size limit, or XML nested too deeply makes the node run fail with an error message.

***

## Generate Tabular File node

Turns workflow data into a CSV or XLSX file and stores it as a document linked to the current workflow run, so a workflow can produce an export without a Script node. Available under **Tools** in the workflow node palette.

**Configuration:**

* **File name**: the name of the generated file, up to 255 characters; supports `${}` expressions (for example, `${reportDate}`). The extension is added from **Format**, so a typed `.csv`, `.xlsx`, or `.xls` extension is replaced. The characters `\ / : * ? " < > |` are replaced with `_`.
* **Document Tag** (optional): the tag stored on the generated document; supports `${}` expressions. When left empty, the file name without its extension is used.
* **Format**: `CSV` (default) or `XLSX`.
* **Row format**: the shape of each row in **Data**.
  * **Arrays** (default): each row is a list of values, such as `["FP-1001", "Closed"]`. The first row is the header row, and each following row is written in the same column order.
  * **Objects**: each row is an object, such as `{"invoice": "FP-1001", "status": "Closed"}`. The keys become the column headers, in the order they first appear. A missing key leaves the cell empty.
* **Data**: a single workflow variable that holds the rows, such as `${data}` or `${dbResult.sheets}`. The variable must resolve to an array; inline JSON is not accepted.
* **Response Key**: where the node writes the generated file's metadata.

For a `${employees}` variable set to:

```json theme={"dark"}
[
  { "id": 1, "name": "Alice" },
  { "id": 2, "name": "Bob", "role": "Designer" }
]
```

with **Row format** set to **Objects**, **Format** set to `CSV`, **File name** set to `team-export`, and response key `export`, the node writes a CSV file with the columns `id`, `name`, and `role`, and returns:

```json theme={"dark"}
{
  "export": {
    "fileName": "team-export.csv",
    "documentType": "team-export",
    "format": "CSV",
    "rowFormat": "objects",
    "rowCount": 2,
    "fileSize": 40,
    "downloadPath": "internal/files/{fileEntryUuid}/download",
    "filePath": "...",
    "fileEntryUuid": "..."
  }
}
```

`rowCount` counts data rows only, never the header row, and `fileSize` is in bytes. The generated file also appears in the **Document** tab of the run's console log.

**How values are written:**

* CSV files are UTF-8 encoded with a byte order mark, so spreadsheet apps read non-ASCII characters correctly. XLSX files have a single sheet named `Sheet1`, and numbers and booleans keep their type.
* Text that starts with `=`, `+`, `-`, `@`, a tab, or a carriage return is written as text, never as a formula.
* In **Arrays** mode, a row shorter than the header row is padded with empty cells, and extra values become extra columns with an empty header.
* Rows with no values are left out. An empty array still produces a file, with `rowCount` set to `0`.

**Limits:** an XLSX file holds up to 1,048,576 rows, including the header row. A generated file can be up to 50 MB.

The node run fails with an error message in the run log when **Data** is not mapped, is not a single variable reference, or does not resolve to an array; when a row does not match the selected **Row format**; when **File name** or **Document Tag** references a variable that has no value; or when the file exceeds a limit. Reduce the number of rows or split the export across several nodes to stay under the limits.

***

## Template Filling node

Generates a document from a document template populated with workflow data. Available under **Tools** in the workflow node palette.

**Configuration:**

* **Template** — select a document template defined in your project's **Document templates**; **Open template** jumps to the template definition
* **Language** — enabled once a template is selected, and defaults to the template's first available language
* **Template Variables** — click **Configure Variables** to fill the template's data-model variables with values from the workflow; changing the template resets the language and variables
* **Input Mapping** — new nodes map workflow data onto the template's input parameters in the data mapper (**Configure mapping** on the **Template Input** card) instead of **Template Variables**. Nodes created before FlowX.AI 5.13 show an **Enable data mapping** toggle: on uses the data mapper, off keeps **Template Variables**
* **Folder** — optional folder for the generated file; supports `${}` expressions (e.g., `${client.id}`)
* **Document Tag** — the tag under which the generated document is stored (e.g., `ContractTemplate`)
* **Document format** — **PDF** (default) or **DOCX**

The node writes the generation result to its response key, including the file ID, storage and download paths, document tag, and page count. If generation fails, an `error` object is returned on the same key.

To map a Script node's output into the template, fix a node that shows no mapping options, or build the download URL from `downloadPath`, see [Fill a document template from a workflow and download it](https://docs.flowx.ai/6.x/cookbooks/generate-and-download-a-document.md).

> [card] [Managing document templates](https://docs.flowx.ai/6.x/docs/platform-deep-dive/core-extensions/content-management/documents-plugin/managing-html-templates.md)
>
> Learn how to create and manage the document templates this node fills

***

## Send Notification node

Sends a notification built from one of your project's notification templates, directly from a workflow. Available under **Tools** in the workflow node palette. Until now this took a round trip through a process: the workflow had no way to reach the Notifications plugin on its own.

**Configuration:**

* **Template** — the notification template to send, from your project's notification templates; **Open notification template** jumps to its definition. **Language** unlocks once a template is picked. **Variables** fills the template's data-model variables from workflow data, the same mapping as the Template Filling node.
* **Recipients** — **To** (required), **Cc** and **Bcc**. Each takes a recipient address, a JSON array of addresses, or a `${}` expression resolving to either.
* **Email options** — all optional: **Subject override** (leave empty to use the template subject), **Sender name** and **Sender email**, **Attachments** (one file path or `${}` key per line), and **Custom headers**, which must be a JSON object or a `${}` expression that resolves to one.

### When does a Send Notification node take its failure exit?

A Send Notification node has a success exit and a failure exit. It takes the success exit only when the Notifications plugin accepts the message with a `2xx` response. Everything else takes the failure exit:

* A configuration problem caught before sending, such as no template or language, an empty **To** after `${}` expressions resolve, an attachment given as a URL instead of a file path, or custom headers that aren't valid JSON
* The Notifications plugin rejecting the message
* An authorization error (`401` or `403`)
* The plugin being unreachable, timing out, or answering with a `5xx`

If the node fails and the failure exit isn't connected, the workflow instance fails with `Workflow is missing outgoing sequences.` It doesn't fall through to the success exit.

On both exits the node writes its result under its response key: `sent`, `hasError`, `errorType`, `errorMessage`, `template` (name and ID), `language`, `recipients` (`to`, `cc`, and `bcc` counts), and `metadata.statusCode`. `errorType` is `VALIDATION` (caught before sending), `DELIVERY` (rejected by the plugin), `AUTH`, or `TRANSPORT`. `metadata` is absent for `VALIDATION` and `TRANSPORT`, because no status code reached the node.

> [card] [Managing notification templates](https://docs.flowx.ai/6.x/docs/platform-deep-dive/core-extensions/content-management/notifications-plugin/managing-notification-templates.md)
>
> Learn how to create and manage the notification templates this node sends

***

## Combine Files node

Merges multiple **PDF** files into a single output file, in the order you specify. Available under **Tools** in the workflow node palette.

**Configuration:**

* **Files** — add two or more source files, each by path (or a test file). Set the **order** and choose which pages to include per file: **All pages** or a **custom** page range.
* **Folder** — optional folder for the combined file; supports `${}` expressions.
* **Document Tag** — the tag under which the combined file is stored.

Each input must be a PDF of up to 15 MB, and at least two files are required. The node writes the combined file's ID and paths to its response key.

***

## Split File node

Splits a single **PDF** into multiple output files — by page ranges or one file per page. Available under **Tools** in the workflow node palette.

**Configuration:**

* **Source file** — the PDF to split, by path (or a test file).
* **Output files** — define each output by its **pages** using a range grammar such as `1-3,5`, or a `${}` expression that resolves to one at runtime. Each output can set its own **Folder** and **Document Tag**.

The source must be a PDF of up to 15 MB. The node writes the resulting files' IDs and paths to its response key.

***

## Context Retrieval node

Retrieves relevant data from Knowledge Bases or conversation memory using semantic and keyword search, without calling an LLM, and passes the chunks to downstream nodes. Available under **Data Operations** in the workflow node palette.

**Configuration:**

* **Source** — choose between Knowledge Base or Memory (Memory is available only in chat-driven workflows)
* **Knowledge Base** — select a Knowledge Base to search (when source is Knowledge Base)
* **User Query** — the search query, supports process variable expressions (e.g., `${userMessage}`)
* **Search Type** — Hybrid (default), Semantic, or Keywords
* **Max Number of Chunks** — how many chunks to return (1-10, default: 5)
* **Min Relevance Score** — minimum relevance threshold (0-100%, default: 70%)
* **Metadata Filters** — filter chunks by metadata properties using the query builder: typed operators per key type and AND/OR grouping
* **Use advance metadata filters** — toggle to enable expression-based filtering for complex logic
* **Use Re-rank** — toggle to re-rank retrieved chunks before returning

The node returns structured chunk data: content, metadata, relevance score, and store.

**Common use cases:**

* Feeding context into a downstream Custom Agent or Text Generation node
* Building multi-step RAG pipelines with custom processing between retrieval and generation
* Retrieving relevant documentation chunks for further analysis

> [card] [Context Retrieval Documentation](https://docs.flowx.ai/6.x/ai-platform/agent-builder/context-retrieval.md)
>
> Learn how to configure Context Retrieval nodes, search types, and output format

> [card] [Using Knowledge Base in Workflows](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/knowledge-base-integration/using-knowledge-base-in-workflows.md)
>
> Learn how to configure Context Retrieval and Custom Agent nodes with Knowledge Bases

***

## Custom Agent node

Enables AI agents to perform intelligent, autonomous tasks using Model Context Protocol (MCP) tools within your workflow. Custom Agent nodes apply ReAct (Reasoning and Acting) to decide which tools to use and execute multi-step operations.

**Key capabilities:**

* Access external systems through MCP servers
* Execute complex, multi-step operations autonomously
* Make intelligent decisions based on available tools
* Return structured responses for downstream processing

**Use cases:**

* Customer support automation with CRM integration
* Data analysis across multiple systems
* Dynamic integration orchestration
* Autonomous problem-solving workflows

> [card] [Custom Agent Node Documentation](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/custom-agent-node.md)
>
> Learn how to configure Custom Agent nodes, write effective prompts, and monitor AI agent execution

***

## Intent Classification Agent node

Classifies user messages using an LLM and automatically routes the workflow to the matching intent branch — combining AI classification and conditional branching in a single node. Works like a [Condition (Fork)](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/workflow-nodes-control-flow.md#condition-fork-node) node, but uses natural language intent descriptions instead of code expressions.

**Key capabilities:**

* Define up to 10 intents as plain-text descriptions
* Automatic "If No Intent Matches" fallback branch
* Optional conversation memory for context-aware classification
* Optional rationale output explaining the classification decision

**Common use cases:**

* Chatbot message routing
* Email triage and classification
* Customer support ticket categorization

> [card] [Intent Classification Agent Documentation](https://docs.flowx.ai/6.x/ai-platform/agent-builder/intent-classification.md)
>
> Learn how to configure intents, output format, and routing behavior

***

## AI Nodes

AI nodes enable intelligent processing of text, documents, images, and data directly within your Integration Designer workflows.

![AI Nodes](https://s3.eu-west-1.amazonaws.com/docx.flowx.ai/5.x/ai_nodes.png)

### AI Text Operations

| Node | Description |
| - | - |
| **Text Transformation** | Modify text tone, complexity or formatting for better clarity or style |
| **Text Understanding** | Analyze text to determine sentiment, topics, intent, language and named entities |
| **Text Generation** | Generate new text such as summaries, completions, translations or paraphrases |
| **Text Extraction** | Extract structured information, keywords or metadata from text |

### AI Document Operations

| Node | Description |
| - | - |
| **Document Generation** | Automatically build reports or complete templates based on given inputs |
| **Document Extraction** | Identify and extract structured data, entities or metadata from documents |
| **Document Understanding** | Analyze documents to extract meaning, topics, sentiment, or important information |
| **Extract Data from File** | Extract text and data from documents and images using LLM, OCR, or text parsing |

### AI Image Operations

| Node | Description |
| - | - |
| **Image Description** | Generate captions or extract detailed information from visual content |
| **Image Analysis** | Recognize objects, emotions and scenes in images for contextual understanding |

### AI Data Operations

| Node | Description |
| - | - |
| **Data Enrichment** | Add annotations, context or relationships to enhance raw data value |
| **Data Generation** | Produce synthetic or structured data using templates and logic-based rules |
| **Data Transformation** | Clean, normalize, aggregate, or restructure datasets into usable formats |

> [card] [AI Node Types](https://docs.flowx.ai/6.x/ai-platform/agent-builder/node-types.md)
>
> Learn more about AI node types and configuration options

### Personal Information Guard

Personal Information Guard detects and redacts PII on AI workflow nodes before the payload reaches the model, and restores it in the response. It is configured per node (sensitivity preset, input/output scan direction, entity types) and runs in the fail-closed **data-privacy** service.

For the full reference — configuration, scan flow, supported entity types, and run-log fields — see [Personal Information Guard](https://docs.flowx.ai/6.x/ai-platform/personal-information-guard.md).


## Related topics

- [Workflow node reference: control flow and integration nodes](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/workflow-nodes-control-flow.md)
- [Create and run workflows in Integration Designer](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/integration-workflows.md)
- [AI node types](https://docs.flowx.ai/6.x/ai-platform/agent-builder/node-types.md)
- [Passing data between nodes](https://docs.flowx.ai/6.x/docs/building-blocks/process/passing-data-between-nodes.md)
- [Reference types in resources usage](https://docs.flowx.ai/6.x/docs/projects/reference-types.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.