n8n-nodes-lite-parser 1.0.0

package/README.md

@@ -0,0 +1,57 @@
+# n8n-nodes-liteparse
+
+An n8n community node for [LiteParse](https://github.com/run-llama/liteparse) — fast, local document parsing with Markdown and JSON output.
+
+## What It Does
+
+Parse PDFs, Office documents (DOCX, XLSX, PPTX), and images into structured Markdown, plain text, or JSON — all locally, no API keys, no cloud.
+
+## Features
+
+- **Markdown output** — headings, tables, lists, links preserved
+- **JSON output** — structured data with bounding boxes and spatial coordinates
+- **OCR** — built-in Tesseract for scanned documents (100+ languages)
+- **Encrypted PDFs** — password-protected PDF support
+- **Page targeting** — parse specific pages only
+- **Lightweight** — Rust core, no GPU, no PyTorch, minimal system load
+
+## Supported Formats
+
+**Native:** PDF
+**Via LibreOffice:** DOCX, DOC, PPTX, PPT, XLSX, XLS, ODT, RTF, Pages, Numbers, Keynote
+**Via ImageMagick:** JPG, PNG, GIF, BMP, TIFF, WebP, SVG
+
+## Installation
+
+In n8n:
+1. Go to **Settings** > **Community Nodes**
+2. Enter `n8n-nodes-liteparse`
+3. Click **Install**
+
+Or manually:
+```bash
+cd ~/.n8n/nodes
+npm install n8n-nodes-liteparse
+```
+
+## Node Parameters
+
+| Parameter | Default | Description |
+|---|---|---|
+| Input Binary Field | `data` | Binary property containing the document |
+| Output Format | `markdown` | `markdown` / `text` / `json` |
+| OCR Enabled | `true` | Run OCR on scanned docs |
+| OCR Language | `eng` | Tesseract language code |
+| Password | — | For encrypted PDFs |
+| Target Pages | — | e.g. `1-5,10` |
+| DPI | `150` | Rendering resolution |
+
+## Example Workflow
+
+```
+[Read Binary File / HTTP Request] → [LiteParse] → [Code Node / AI Agent]
+```
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiteParseNode = void 0;
+var LiteParse_node_1 = require("./nodes/LiteParse/LiteParse.node");
+Object.defineProperty(exports, "LiteParseNode", { enumerable: true, get: function () { return LiteParse_node_1.LiteParseNode; } });
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "n8n-nodes-lite-parser",
+  "version": "1.0.0",
+  "description": "n8n community node for LiteParse — fast, local document parsing (PDF, Office, images) with Markdown/JSON output",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "pdf",
+    "parser",
+    "ocr",
+    "markdown",
+    "liteparse",
+    "document-parsing"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "@llamaindex/liteparse": "^2.1.2"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  },
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "nodes": [
+      "dist/nodes/LiteParse/LiteParse.node.js"
+    ]
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { LiteParseNode } from './nodes/LiteParse/LiteParse.node';

package/src/nodes/LiteParse/LiteParse.node.ts

@@ -0,0 +1,275 @@
+import {
+  IExecuteFunctions,
+  INodeExecutionData,
+  INodeType,
+  INodeTypeDescription,
+  NodeConnectionTypes,
+} from 'n8n-workflow';
+
+export class LiteParseNode implements INodeType {
+  description: INodeTypeDescription = {
+    displayName: 'LiteParse',
+    name: 'liteParse',
+    icon: 'file:liteparse.svg',
+    group: ['transform'],
+    version: 1,
+    subtitle: '={{ $parameter["outputFormat"] }}',
+    description: 'Parse PDFs, Office docs, and images into Markdown, JSON, or text — locally, no API keys',
+    defaults: {
+      name: 'LiteParse',
+    },
+    inputs: [NodeConnectionTypes.Main],
+    outputs: [NodeConnectionTypes.Main],
+    properties: [
+      {
+        displayName: 'Input Binary Field',
+        name: 'binaryPropertyName',
+        type: 'string',
+        default: 'data',
+        required: true,
+        description: 'Name of the binary property containing the document to parse',
+      },
+      {
+        displayName: 'Output Format',
+        name: 'outputFormat',
+        type: 'options',
+        options: [
+          {
+            name: 'Markdown',
+            value: 'markdown',
+            description: 'Structured Markdown with headings, tables, lists, and links',
+          },
+          {
+            name: 'Text',
+            value: 'text',
+            description: 'Plain text with layout preserved',
+          },
+          {
+            name: 'JSON',
+            value: 'json',
+            description: 'Structured JSON with bounding boxes and spatial data',
+          },
+        ],
+        default: 'markdown',
+        description: 'Format of the parsed output',
+      },
+      {
+        displayName: 'OCR Enabled',
+        name: 'ocrEnabled',
+        type: 'boolean',
+        default: true,
+        description: 'Whether to run OCR on scanned documents and images',
+      },
+      {
+        displayName: 'OCR Language',
+        name: 'ocrLanguage',
+        type: 'string',
+        default: 'eng',
+        displayOptions: {
+          show: {
+            ocrEnabled: [true],
+          },
+        },
+        description: 'Tesseract language code (e.g. eng, fra, deu, ara, ara+eng)',
+      },
+      {
+        displayName: 'Password',
+        name: 'password',
+        type: 'string',
+        typeOptions: { password: true },
+        default: '',
+        description: 'Password for encrypted/protected PDFs (leave empty if not encrypted)',
+      },
+      {
+        displayName: 'Target Pages',
+        name: 'targetPages',
+        type: 'string',
+        default: '',
+        placeholder: '1-5,10,15-20',
+        description: 'Specific pages to parse (leave empty for all pages)',
+      },
+      {
+        displayName: 'DPI',
+        name: 'dpi',
+        type: 'number',
+        default: 150,
+        typeOptions: {
+          minValue: 72,
+          maxValue: 600,
+        },
+        description: 'Rendering DPI for OCR and screenshots (higher = better quality, slower)',
+      },
+      {
+        displayName: 'Options',
+        name: 'options',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        options: [
+          {
+            displayName: 'Image Mode',
+            name: 'imageMode',
+            type: 'options',
+            options: [
+              {
+                name: 'Placeholder',
+                value: 'placeholder',
+                description: 'Reference images with placeholder links',
+              },
+              {
+                name: 'Off',
+                value: 'off',
+                description: 'Strip all images from output',
+              },
+              {
+                name: 'Embed',
+                value: 'embed',
+                description: 'Write image PNGs to disk and reference them',
+              },
+            ],
+            default: 'placeholder',
+            description: 'How to handle images in Markdown output',
+            displayOptions: {
+              show: {
+                '/outputFormat': ['markdown'],
+              },
+            },
+          },
+          {
+            displayName: 'Extract Links',
+            name: 'extractLinks',
+            type: 'boolean',
+            default: true,
+            description: 'Whether to render hyperlinks as [text](url) in Markdown output',
+            displayOptions: {
+              show: {
+                '/outputFormat': ['markdown'],
+              },
+            },
+          },
+          {
+            displayName: 'Max Pages',
+            name: 'maxPages',
+            type: 'number',
+            default: 1000,
+            description: 'Maximum number of pages to parse',
+          },
+          {
+            displayName: 'OCR Workers',
+            name: 'numWorkers',
+            type: 'number',
+            default: 4,
+            description: 'Number of concurrent OCR workers',
+          },
+          {
+            displayName: 'Quiet Mode',
+            name: 'quiet',
+            type: 'boolean',
+            default: true,
+            description: 'Suppress progress output from LiteParse',
+          },
+        ],
+      },
+    ],
+  };
+
+  async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+    const { LiteParse } = await import('@llamaindex/liteparse');
+
+    const items = this.getInputData();
+    const returnData: INodeExecutionData[] = [];
+
+    for (let i = 0; i < items.length; i++) {
+      try {
+        const binaryPropertyName = this.getNodeParameter('binaryPropertyName', i) as string;
+        const outputFormat = this.getNodeParameter('outputFormat', i) as 'markdown' | 'text' | 'json';
+        const ocrEnabled = this.getNodeParameter('ocrEnabled', i) as boolean;
+        const ocrLanguage = this.getNodeParameter('ocrLanguage', i) as string;
+        const password = this.getNodeParameter('password', i) as string;
+        const targetPages = this.getNodeParameter('targetPages', i) as string;
+        const dpi = this.getNodeParameter('dpi', i) as number;
+        const options = this.getNodeParameter('options', i) as {
+          imageMode?: string;
+          extractLinks?: boolean;
+          maxPages?: number;
+          numWorkers?: number;
+          quiet?: boolean;
+        };
+
+        // Validate binary data exists
+        const binaryMetadata = items[i].binary?.[binaryPropertyName];
+        if (!binaryMetadata) {
+          throw new Error(`Binary property "${binaryPropertyName}" does not exist on item ${i}`);
+        }
+
+        // Get the file buffer
+        const buffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
+
+        // Build parser config
+        const parserConfig: Record<string, any> = {
+          outputFormat,
+          ocrEnabled,
+          dpi,
+        };
+
+        if (ocrEnabled && ocrLanguage) {
+          parserConfig.ocrLanguage = ocrLanguage;
+        }
+        if (password) {
+          parserConfig.password = password;
+        }
+        if (targetPages) {
+          parserConfig.targetPages = targetPages;
+        }
+        if (options.imageMode && outputFormat === 'markdown') {
+          parserConfig.imageMode = options.imageMode;
+        }
+        if (options.extractLinks !== undefined && outputFormat === 'markdown') {
+          parserConfig.extractLinks = options.extractLinks;
+        }
+        if (options.maxPages) {
+          parserConfig.maxPages = options.maxPages;
+        }
+        if (options.numWorkers) {
+          parserConfig.numWorkers = options.numWorkers;
+        }
+        if (options.quiet !== undefined) {
+          parserConfig.quiet = options.quiet;
+        }
+
+        // Parse the document
+        const parser = new LiteParse(parserConfig);
+        const result = await parser.parse(buffer);
+
+        // Build output
+        const outputJson: Record<string, any> = {
+          text: result.text,
+          pages: result.pages?.length || 0,
+          format: outputFormat,
+        };
+
+        // Include structured page data for JSON format
+        if (outputFormat === 'json' && result.pages) {
+          outputJson.pageData = result.pages;
+        }
+
+        returnData.push({
+          json: outputJson,
+          binary: items[i].binary,
+          pairedItem: { item: i },
+        });
+      } catch (error) {
+        if (this.continueOnFail()) {
+          returnData.push({
+            json: { error: (error as Error).message },
+            pairedItem: { item: i },
+          });
+          continue;
+        }
+        throw error;
+      }
+    }
+
+    return [returnData];
+  }
+}

package/src/nodes/LiteParse/liteparse.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/>
+  <polyline points="14 2 14 8 20 8"/>
+  <line x1="16" y1="13" x2="8" y2="13"/>
+  <line x1="16" y1="17" x2="8" y2="17"/>
+  <polyline points="10 9 9 9 8 9"/>
+</svg>

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "module": "commonjs",
+    "target": "es2020",
+    "lib": ["es2020"],
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}