Text - Parse Document to Content

Type identifier: text:parseDocumentToContent Category: Text Operations

Description

Parses PDF files into structured content. Extracts text with page-level granularity, generates page images, and splits content into chunks.

Input Handles

Handle	Data Type	Required	Description
`document`	`file`	Yes	The document file to parse
`pageScale`	`number`	No	Dynamic page rendering scale

Input Handle Details

`document`

Type: file
Supported Formats: PDF

`pageScale`

Type: number (0-10)
Notes:
- Controls image quality for page rendering

Output Handles

Handle	Data Type	Description
`content`	`array`	Text chunks from document
`pages`	`array`	Page-level data with images
`metadata`	`object`	Document metadata
`error`	`trigger`	Triggered on parsing error

Output Handle Details

`content`

Type: string[]
Notes:
- Text split into chunks
- Respects chunkSize and chunkOverlap
- Ready for embedding or search indexing

`pages`

Type: Array of page objects
Includes:
- Page number
- Page text
- Rendered page image (file)

`metadata`

Type: Object
Includes:
- title: Document title
- totalPages: Number of pages
- documentId: PDF document ID
- instanceId: PDF instance ID

Configuration Options

Property	Type	Required	Default	Description
`label`	`string`	Yes	`"Parse Document to Content"`	Display label
`chunkSize`	`number`	Yes	`750`	Characters per chunk
`chunkOverlap`	`number`	Yes	`20`	Overlap between chunks
`pageScale`	`number` (literal or dynamic)	No	`{ type: "literal", value: 2 }`	Page render scale

Configuration Details

`chunkSize`

Type: number
Default: 750 characters
Notes: Target size for each text chunk

`chunkOverlap`

Type: number
Default: 20 characters
Notes: Overlap between consecutive chunks to maintain context

`pageScale`

Type: number, literal or dynamic
Range: 0-10
Default: 2
Notes:
- Higher values = better quality, larger images
- Dynamic: the scale comes from the pageScale input handle

Behaviour

Execution Flow

Resolves document input handle
Validates the file input
Loads the file
Parses PDF
Extracts text from each page
Renders page images at configured scale
Splits text into chunks
Returns content, pages, and metadata

PDF Processing

Supports standard PDF features
Handles encrypted PDFs (if password-free)

Text Splitting

Chunks are split as follows:

Attempts to split at natural boundaries (paragraphs, sentences)
Falls back to character boundaries
Maintains overlap for context continuity

Error Handling

Scenario	Behaviour
No file entry	Throws error
Invalid file entry	Throws error
PDF parse failure	Triggers `error`
Corrupted PDF	Triggers `error`

Examples

Basic Document Parsing

{
  "type": "text:parseDocumentToContent",
  "data": {
    "label": "Parse PDF",
    "chunkSize": 750,
    "chunkOverlap": 20
  }
}

Large Chunk Processing

{
  "type": "text:parseDocumentToContent",
  "data": {
    "label": "Parse for Summarization",
    "chunkSize": 2000,
    "chunkOverlap": 100,
    "pageScale": { "type": "literal", "value": 1 }
  }
}

High Quality Page Images

{
  "type": "text:parseDocumentToContent",
  "data": {
    "label": "Parse for Display",
    "chunkSize": 750,
    "chunkOverlap": 20,
    "pageScale": { "type": "literal", "value": 4 }
  }
}

AI - Chat Message

The AI - Chat Message node enables conversations with large language models (LLMs) from multiple providers including OpenAI, Anthropic, Google AI, and Groq. It supports dynamic message templates with variable interpolation, streaming responses, extended thinking, and AI actions (tool use).

Text - Parse HTML to Content

Parses HTML string into rich content. Converts HTML elements into structured content nodes including paragraphs, headings, lists, links, and more. Optionally resolves relative URLs in the content.

Text - Parse Markdown to Content

Parses Markdown text into rich content. Converts Markdown elements into structured content nodes. Handles code blocks, including automatic stripping of Markdown code fences if wrapping the entire content.

Text - Recursive Split

The Text - Recursive Split node divides text into smaller chunks suitable for processing by language models or other text analysis tools. It splits on natural boundaries (paragraphs, lines, words) where possible, while respecting the configured chunk size. Overlapping between chunks ensures context is preserved across boundaries.