@n8n/instance-ai 1.1.0 → 1.2.0

package/dist/tools/best-practices/guides/data-persistence.js

@@ -1,198 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDocumentation = getDocumentation;
-function getDocumentation() {
-    return `# Best Practices: Data Persistence
-
-## Overview
-
-Data persistence involves storing, updating, or retrieving records from durable storage systems. This technique is essential when you need to maintain data beyond the lifetime of a single workflow execution, or when you need to access existing data that users have stored in their spreadsheets, tables, or databases as part of your workflow logic.
-
-## When to Use Data Persistence
-
-Use data persistence when you need to:
-- Store workflow results for later retrieval or audit trails
-- Maintain records that multiple workflows can access and update
-- Create a centralized data repository for your automation
-- Archive historical data for reporting or compliance
-- Build data that persists across workflow executions
-- Track changes or maintain state over time
-- Store raw form inputs
-
-## Choosing the Right Storage Node
-
-### Data Table (n8n-nodes-base.dataTable) - PREFERRED
-
-**Best for:** Quick setup, small to medium amounts of data
-
-Advantages:
-- No credentials or external configuration required
-- Built directly into n8n
-- Fast and reliable for small to medium datasets
-- Ideal for prototyping and internal workflows
-- No additional costs or external dependencies
-
-When to use:
-- Internal workflow data storage
-- Temporary or staging data
-- Admin/audit trails
-- Simple record keeping
-- Development and testing
-
-### Google Sheets (n8n-nodes-base.googleSheets)
-
-**Best for:** Collaboration, reporting, easy data sharing
-
-Advantages:
-- Familiar spreadsheet interface for non-technical users
-- Easy to share and collaborate on data
-- Built-in visualization and formula capabilities
-- Good for reporting and dashboards
-- Accessible from anywhere
-
-When to use:
-- Data needs to be viewed/edited by multiple people
-- Non-technical users need access to data
-- Integration with other Google Workspace tools
-- Simple data structures without complex relationships
-- Workflow needs access to existing spreadsheets in Google Sheets
-
-Pitfalls:
-- API rate limits can affect high-volume workflows
-- Not suitable for frequently changing data
-- Performance degrades with very large datasets (>10k rows)
-
-### Airtable (n8n-nodes-base.airtable)
-
-**Best for:** Structured data with relationships, rich field types
-
-Advantages:
-- Supports relationships between tables
-- Rich field types (attachments, select, links, etc.)
-- Better structure than spreadsheets
-
-When to use:
-- Data has relationships or references between records
-- Need structured database-like features
-- Managing projects, tasks, or inventory
-- Workflow needs access to existing data in Airtable
-
-Pitfalls:
-- Requires Airtable account and API key
-- Schema changes require careful planning
-
-## Storage Patterns
-
-### Immediate Storage Pattern
-
-Store data immediately after collection or generation:
-
-\`\`\`mermaid
-flowchart LR
-    Trigger --> Process_Data["Process Data"]
-    Process_Data --> Storage_Node["Storage Node"]
-    Storage_Node --> Continue_Workflow["Continue Workflow"]
-\`\`\`
-
-Best for: Raw data preservation, audit trails, form submissions
-
-### Batch Storage Pattern
-
-Collect multiple items and store them together:
-
-\`\`\`mermaid
-flowchart LR
-    Trigger --> Loop_Split["Loop/Split"]
-    Loop_Split --> Process["Process"]
-    Process --> Aggregate["Aggregate"]
-    Aggregate --> Storage_Node["Storage Node"]
-\`\`\`
-
-Best for: Processing lists, batch operations, scheduled aggregations
-
-### Update Pattern
-
-Retrieve, modify, and update existing records:
-
-\`\`\`mermaid
-flowchart LR
-    Trigger --> Retrieve["Retrieve from Storage"]
-    Retrieve --> Modify["Modify"]
-    Modify --> Update_Storage["Update Storage Node"]
-\`\`\`
-
-Best for: Maintaining state, updating records, tracking changes
-
-### Lookup Pattern
-
-Query storage to retrieve specific records:
-
-\`\`\`mermaid
-flowchart LR
-    Trigger --> Query_Storage["Query Storage Node"]
-    Query_Storage --> Use_Data["Use Retrieved Data"]
-    Use_Data --> Continue_Workflow["Continue Workflow"]
-\`\`\`
-
-Best for: Enrichment, validation, conditional logic based on stored data
-
-## Key Considerations
-
-### Data Structure
-
-- **Plan your schema ahead:** Define what fields you need before creating storage
-- **Use consistent field names:** Match field names across your workflow for easy mapping
-- **Consider data types:** Ensure your storage supports the data types you need
-- **Think about relationships:** If data is related, consider Airtable or use multiple tables
-
-### Performance
-
-- **Batch operations when possible:** Multiple small writes are slower than batch operations
-- **Use appropriate operations:** Use "append" for new records, "update" for modifications
-- **Consider API limits:** Google Sheets has rate limits; plan accordingly for high-volume workflows
-
-### Data Integrity
-
-- **Store raw data first:** Keep unmodified input before transformations
-- **Handle errors gracefully:** Use error handling to prevent data loss on failures
-- **Validate before storing:** Ensure data quality before persistence
-- **Avoid duplicates:** Use unique identifiers or upsert operations when appropriate
-
-## Referencing Documents, Sheets, or Tables
-
-When configuring storage nodes, use ResourceLocator mode "list". This will allow users to select from existing documents, sheets, or tables rather than passing IDs dynamically.
-Use modes "id", "url" or "name" only when user specifically mentions it in their prompt.
-
-## Important Distinctions
-
-### Storage vs. Transformation
-
-- **Set/Merge nodes are NOT storage:** They transform data in memory only
-- **Storage happens explicitly:** Data won't persist unless you explicitly write it to storage
-
-### Temporary vs. Persistent Storage
-
-- **NOT covered by this technique:** Redis, caching, session storage, in-memory operations
-- **This technique covers:** Durable storage that persists beyond workflow execution
-- **Focus on permanence:** Use these nodes when you need data to survive restarts and be queryable later
-
-## Common Pitfalls to Avoid
-
-### Not Handling Duplicates
-
-Without proper unique identifiers or upsert logic, you may create duplicate records. Use unique IDs or check for existing records before inserting.
-
-### Ignoring Storage Limits
-
-Each storage system has limits (row counts, API rates, file sizes). Design your workflow to work within these constraints or implement pagination/batching.
-
-### Not Handling Empty Query Results
-
-Data Tables and other storage nodes return 0 items when:
-- The table is freshly created and has no rows yet
-- A filter/lookup query matches nothing
-
-This silently breaks the downstream chain — all nodes after the empty result are skipped. Always set \`alwaysOutputData: true\` on data-fetching nodes (operation: 'get') when downstream nodes depend on their output.
-`;
-}
-//# sourceMappingURL=data-persistence.js.map

package/dist/tools/best-practices/guides/data-persistence.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"data-persistence.js","sourceRoot":"","sources":["../../../../src/tools/best-practices/guides/data-persistence.ts"],"names":[],"mappings":";;AAAA,4CAiMC;AAjMD,SAAgB,gBAAgB;IAC/B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+LP,CAAC;AACF,CAAC"}

package/dist/tools/best-practices/guides/data-transformation.d.ts

@@ -1 +0,0 @@
-export declare function getDocumentation(): string;

package/dist/tools/best-practices/guides/data-transformation.js

@@ -1,139 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDocumentation = getDocumentation;
-function getDocumentation() {
-    return `# Best Practices: Data Transformation
-
-## Workflow Design
-
-### Core Principles
-- **Structure**: Always follow Input -> Transform -> Output pattern
-- **Optimization**: Filter and reduce data early to improve performance
-
-### Design Best Practices
-- Plan transformation requirements in plain language before building
-- Use Modular Design: Create reusable sub-workflows for common tasks like "Data Cleaning" or "Error Handler"
-- Batch datasets over 100 items using Split In Batches node to prevent timeouts
-
-## Recommended Nodes
-
-### Essential Transformation Nodes
-
-#### Edit Fields (Set) (n8n-nodes-base.set)
-
-**Purpose**: Create, modify, rename fields; change data types
-
-**Key Setting**: "Keep Only Set" - drops all fields not explicitly defined (default: disabled)
-
-**Use Cases**:
-- Extract specific columns
-- Add calculated fields
-- Convert data types (string to number)
-- Format dates using expressions
-
-**Pitfalls**:
-- Not understanding "Keep Only Set" behavior can lead to data loss
-- Enabled: Drops all fields not explicitly defined (data loss risk)
-- Disabled: Carries forward all fields (potential bloat)
-- Always verify output structure after configuration
-
-**Testing tip**: When transforming data from a workflow trigger, you can set values with a fallback default e.g. set name to {{$json.name || 'Jane Doe'}} to help test the workflow.
-
-#### IF/Filter Nodes
-
-**IF Node** (n8n-nodes-base.if):
-- **Purpose**: Conditional processing and routing
-- **Best Practice**: Use early to validate inputs and remove bad data
-- **Example**: Check if required fields exist before processing
-
-**Filter Node** (n8n-nodes-base.filter):
-- **Purpose**: Filter items based on conditions
-- **Best Practice**: Use early in workflow to reduce data volume
-
-#### Merge Node (n8n-nodes-base.merge)
-
-**Purpose**: Combine two data streams
-
-**Modes**:
-- Merge by Key (like database join)
-- Merge by Index
-- Append
-
-**Pitfalls**:
-- **Missing Keys**: Trying to merge on non-existent fields
-- **Field Name Mismatch**: Different field names in sources
-- **Solution**: Use Edit Fields node to normalize field names before merging
-
-#### Code Node (n8n-nodes-base.code)
-
-**Execution Modes**:
-- "Run Once per Item": Process each item independently
-- "Run Once for All Items": Access entire dataset (for aggregation)
-
-**Return Format**: Must return array of objects with json property
-\`\`\`javascript
-return items; // or return [{ json: {...} }];
-\`\`\`
-
-**Pitfalls**:
-- Wrong return format: Not returning array of objects with json property
-- Overly complex: Stuffing entire workflow logic in one Code node
-- Keep code nodes focused on single transformation aspect
-
-#### Summarize Node (n8n-nodes-base.summarize)
-
-**Purpose**: Pivot table-style aggregations (count, sum, average, min/max)
-
-**Configuration**:
-- Fields to Summarize: Choose aggregation function
-- Fields to Split By: Grouping keys
-
-**Output**: Single item with summary or multiple items per group
-
-### Data Restructuring Nodes
-
-- **Split Out** (n8n-nodes-base.splitOut): Convert single item with array into multiple items
-- **Aggregate** (n8n-nodes-base.aggregate): Combine multiple items into one
-- **Remove Duplicates** (n8n-nodes-base.removeDuplicates): Delete duplicate items based on field criteria
-- **Sort** (n8n-nodes-base.sort): Order items alphabetically/numerically
-- **Limit** (n8n-nodes-base.limit): Trim to maximum number of items
-
-### Batch Processing
-
-**Split In Batches** (n8n-nodes-base.splitInBatches):
-- **Purpose**: Process large datasets in chunks
-- **Use When**: Handling 100+ items with expensive operations (API calls, AI)
-
-## Input Data Validation
-- Validate external data before processing: check for nulls, empty values, and edge cases (special chars, empty arrays)
-
-## Common Pitfalls to Avoid
-
-### Critical Mistakes
-
-#### Edit Fields Node Issues
-- **Mistake**: Not understanding "Keep Only Set" behavior
-  - Enabled: Drops all fields not explicitly defined (data loss risk)
-  - Disabled: Carries forward all fields (potential bloat)
-- **Solution**: Always verify output structure after configuration
-
-#### Code Node Errors
-- **Wrong Return Format**: Not returning array of objects with json property
-- **Fix**: Always return \`items\` or \`[{ json: {...} }]\`
-- **Overly Complex**: Stuffing entire workflow logic in one Code node
-- **Fix**: Keep code nodes focused on single transformation aspect
-
-#### Merge Node Problems
-- **Field Name Mismatch**: Different field names in sources
-- **Fix**: Normalize field names with Edit Fields before merging
-
-### Performance Pitfalls
-- Processing large datasets without batching -> timeouts
-- Not filtering early -> unnecessary processing overhead
-- Excessive node chaining -> visual clutter and slow execution
-
-### Data Validation Pitfalls
-- Assuming input data is always perfect -> runtime errors
-`;
-}
-//# sourceMappingURL=data-transformation.js.map

package/dist/tools/best-practices/guides/data-transformation.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"data-transformation.js","sourceRoot":"","sources":["../../../../src/tools/best-practices/guides/data-transformation.ts"],"names":[],"mappings":";;AAAA,4CAsIC;AAtID,SAAgB,gBAAgB;IAC/B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoIP,CAAC;AACF,CAAC"}

package/dist/tools/best-practices/guides/document-processing.d.ts

@@ -1 +0,0 @@
-export declare function getDocumentation(): string;

package/dist/tools/best-practices/guides/document-processing.js

@@ -1,326 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDocumentation = getDocumentation;
-function getDocumentation() {
-    return `# Best Practices: Document Processing Workflows
-
-## Workflow Design
-
-Document processing workflows extract and act on content from files like PDFs, images, Word documents, and spreadsheets. Design your workflow following these core patterns:
-
-### Core Architecture Pattern
-Trigger -> Capture Binary -> Extract Text -> Parse/Transform -> Route to Destination -> Notify
-
-### Common Flow Patterns
-
-**Simple Document Processing:**
-- Gmail Trigger -> Check file type -> Extract from File -> DataTable -> Slack notification
-- Best for: Basic text-based PDFs with straightforward data extraction
-
-**Complex Document Processing with AI:**
-- Webhook -> File Type Check -> OCR (if image) -> AI Extract -> Validate -> CRM Update -> Multiple notifications
-- Best for: Varied document formats requiring intelligent parsing
-
-**Batch Document Processing:**
-- Main workflow: Schedule Trigger -> Fetch Files -> Split In Batches -> Sub-workflow -> Merge Results -> Bulk Update
-- Sub-workflow When Executed by Another Workflow -> Process result
-- Best for: High-volume processing with API rate limits
-
-**Multi-Source Document Aggregation:**
-- Multiple Triggers (Email + Drive + Webhook) -> Set common fields -> Standardize -> Process -> Store
-- Best for: Documents from various channels needing unified processing
-
-### Branching Strategy
-
-Always branch early based on document characteristics:
-- **File Type Branching**: Use IF/Switch nodes immediately after ingestion to route PDFs vs images vs spreadsheets
-- **Provider Branching**: Route documents to provider-specific processing (e.g., different invoice formats)
-- **Quality Branching**: Separate high-confidence extractions from those needing manual review
-
-## Binary Data Management
-Documents in n8n are handled as binary data that must be carefully preserved throughout the workflow.
-
-### Referencing Binary Data from Other Nodes
-When you need to reference binary data from a previous node, use this syntax:
-- Expression: '{{ $('Node Name').item.binary.property_name }}' or {{ $binary.property_name }} if previous item
-- Example for Gmail attachments: '{{ $('Gmail Trigger').item.binary.attachment_0 }}' or {{ $binary.attachment_0 }} if previous item
-- Example for webhook data: '{{ $('Webhook').item.binary.data }}' or {{ $binary.data }} if previous item
-- Important: The property name depends on how the previous node names the binary data
-
-### Preserving Binary Data
-- Many nodes (Code, Edit Fields, AI nodes) output JSON and drop binary data by default
-- Use parallel branches: one for processing, one to preserve the original file
-- Rejoin branches with Merge node in pass-through mode
-- Alternative: Configure nodes to keep binary (e.g., Edit field node's "Include Other Input Fields" option ON)
-
-### Memory Optimization
-For high-volume processing:
-- Process files sequentially or in small batches
-- Drop unnecessary binary data after extraction to free memory
-
-### File Metadata
-Documents uploaded via a form trigger will have various bits of metadata available - filename, mimetype and size.
-These are accessible using an expression like {{ $json.documents[0].mimetype }} to access each of the document's details.
-Multiple files can be uploaded to a form which is the reason for the documents array.
-
-## Text Extraction Strategy
-
-Choose extraction method based on document type and content:
-
-### Critical: File Type Detection
-**ALWAYS check the file type before using Extract from File node** (unless the file type is already known):
-- Use IF node to check file extension or MIME type first
-- The Extract from File node has multiple operations, each for a specific file type:
-  - "Extract from PDF" for PDF files
-  - "Extract from MS Excel" for Excel files (.xlsx, .xls)
-  - "Extract from MS Word" for Word documents (.docx, .doc)
-  - "Extract from CSV" for CSV files
-  - "Extract from HTML" for HTML files
-  - "Extract from RTF" for Rich Text Format files
-  - "Extract from Text File" for plain text files
-- Using the wrong operation will result in errors or empty output
-
-### Decision Tree for Extraction
-1. **Check file type** -> Route to appropriate extraction method
-2. **Scanned image/PDF?** -> Use OCR service (OCR.space, AWS Textract, Google Vision)
-3. **Structured invoice/receipt?** -> Use specialized parser (Mindee) or AI extraction
-4. **Text-based document?** -> Use Extract from File with the correct operation for that file type
-
-### Fallback Strategy
-Always implement fallback for extraction failures:
-- Check if text extraction returns empty
-- If empty, automatically route to OCR
-- If OCR fails, send to manual review queue
-
-## Data Parsing & Classification
-
-### AI-Powered Extraction Pattern
-For varied or complex documents:
-
-Option 1 - Using Document Loader (Recommended for binary files):
-1. Pass binary data directly to Document Loader node (set Data Source to "Binary")
-2. Connect to AI Agent or LLM Chain for processing
-3. Validate extracted fields before processing
-
-Option 2 - Using text extraction:
-1. Extract raw text using Extract from File or OCR
-2. Pass to AI Agent or LLM Chain with structured prompt
-3. Validate extracted fields before processing
-
-Example system prompt structure:
-"Extract the following fields from the document: [field list]. Return as JSON with this schema: [schema example]"
-
-### Document Classification Flow
-Classify before processing for better accuracy:
-1. Initial AI classification (Invoice vs Receipt vs Contract)
-2. Route to specialized sub-workflow based on type
-3. Use type-specific prompts and validation rules
-4. This reduces errors and improves extraction quality
-
-## Error Handling Strategy
-
-Build resilience at every step:
-
-### Validation Checkpoints
-- After extraction: Verify text not empty
-- After AI parsing: Validate JSON schema
-- Before database insert: Check required fields
-- After API calls: Verify success response
-
-## Performance Optimization
-
-### Batch Processing Strategy
-- Use Split In Batches node: process 5-10 files at a time
-- Implement delays between batches for rate-limited APIs
-- Monitor memory usage and adjust batch size accordingly
-
-## Recommended Nodes
-
-### Triggers & Input
-
-**Gmail Trigger (n8n-nodes-base.gmailTrigger)**
-Purpose: Monitor Gmail for emails with attachments (Recommended over IMAP)
-Advantages: Real-time processing, simpler authentication, better integration with Google Workspace
-Critical Configuration for Attachments:
-- **MUST set "Simplify" to FALSE** - otherwise attachments won't be available
-- **MUST set "Download Attachments" to TRUE** to retrieve files
-- Set appropriate label filters
-- Set "Property Prefix Name" (e.g., "attachment_") - attachments will be named with this prefix plus index
-- Important: When referencing its binary data, it will be referenced "attachment_0", "attachment_1", etc., NOT "data"
-
-**Email Read (IMAP) (n8n-nodes-base.emailReadImap)**
-Purpose: Alternative email fetching if there's no specialized node for email provider
-Configuration:
-- Enable "Download Attachments" to retrieve files
-- Set "Property Prefix Name" (e.g., "attachment_") - attachments will be named with this prefix plus index
-- Important: When referencing binary data, it will be referenced "attachment_0", "attachment_1", etc., NOT "data"
-
-**HTTP Webhook (n8n-nodes-base.webhook)**
-Purpose: Receive file uploads from web forms
-Configuration: Enable "Raw Body" for binary data
-
-**Google Drive Trigger (n8n-nodes-base.googleDriveTrigger)**
-Purpose: Monitor folders for new documents
-Configuration: Set appropriate folder and file type filters
-
-### Text Extraction
-
-**Extract from File (n8n-nodes-base.extractFromFile)**
-Purpose: Extract text from various file formats using format-specific operations
-Critical: ALWAYS check file type first with an IF or Switch before and select the correct operation (Extract from PDF, Extract from MS Excel, etc.)
-Critical: If the user requests handling of multiple file types (PDF, CSV, JSON, etc) then a Switch (n8n-nodes-base.switch) node should be used
-to check the file type before text extraction. Multiple text extraction nodes should be used to handle each of the different file types. For example,
-if the workflow contains a form trigger node which receives a file, then a Switch node MUST be used to split the different options out to different extraction nodes.
-Output: Extracted text is returned under the "text" key in JSON (e.g., access with {{ $json.text }})
-Pitfalls:
-- Returns empty for scanned documents - always check and fallback to OCR; Using wrong operation causes errors
-- If connecting to a document upload form (n8n-nodes-base.formTrigger) use a File field type and then connect it to the extract from file node using the field name.
-For example if creating a form trigger with field "Upload Document" then set the extract from file input binary field to "Upload_Document"
-
-**AWS Textract (n8n-nodes-base.awsTextract)**
-Purpose: Advanced OCR with table and form detection
-Best for: Structured documents like invoices and forms
-
-**Mindee (n8n-nodes-base.mindee)**
-Purpose: Specialized invoice and receipt parsing
-Returns: Structured JSON with line items, totals, dates
-
-### Data Processing
-
-**AI Agent (@n8n/n8n-nodes-langchain.agent)**
-Purpose: Intelligent document parsing and decision making
-Configuration: Include structured output tools for consistent results
-
-**LLM Chain (@n8n/n8n-nodes-langchain.chainLlm)**
-Purpose: Document classification and data extraction
-
-**Document Loader (@n8n/n8n-nodes-langchain.documentLoader)**
-Purpose: Load and process documents directly from binary data for AI processing
-Critical: Use the "Binary" data source option to handle binary files directly - no need to convert to JSON first
-Configuration: Select "Binary" as Data Source, specify the binary property name (by default data unless renamed in a previous node)
-Best for: Direct document processing in AI workflows without intermediate extraction steps
-
-**Structured Output Parser (@n8n/n8n-nodes-langchain.outputParserStructured)**
-Purpose: Ensure AI outputs match expected JSON schema
-Critical for: Database inserts and API calls
-
-### Vector Storage (for RAG/Semantic Search)
-**Simple Vector Store (@n8n/n8n-nodes-langchain.vectorStore) - RECOMMENDED**
-Purpose: Easy-to-setup vector storage for document embeddings
-Advantages:
-- No external dependencies or API keys required
-- Works out of the box with local storage
-- Perfect for prototyping and small to medium datasets
-Configuration: Just connect and use - no complex setup needed
-Best for: Most document processing workflows that need semantic search
-
-### Flow Control
-
-**Split In Batches (n8n-nodes-base.splitInBatches)**
-Purpose: Process multiple documents in controlled batches
-Configuration: Set batch size based on API limits and memory
-Outputs (in order):
-- Output 0 "done": Executes after all batches are processed - use for final aggregation or notifications
-- Output 1 "loop": Connect processing nodes here - executes for each batch
-Important: Connect processing logic to the second output (loop), completion logic to the first output (done)
-
-**Merge (n8n-nodes-base.merge)**
-Purpose: Combine data from multiple branches that need to execute together
-Critical: Merge node waits for ALL input branches to complete - do NOT use for independent/optional branches
-Modes: Use "Pass Through" to preserve binary from one branch
-
-**Edit Fields (Set) (n8n-nodes-base.set)**
-Purpose: Better choice for combining data from separate/independent branches
-Use for: Adding fields from different sources, preserving binary while adding processed data
-Configuration: Set common fields and use "Include Other Input Fields" ON to preserve existing data including binary
-
-**Execute Workflow Trigger (n8n-nodes-base.executeWorkflowTrigger)**
-Purpose: Start point for sub-workflows that are called by other workflows
-Configuration: Automatically receives data from the calling workflow including binary data
-Best practice: Use for modular workflow design, heavy processing tasks, or reusable workflow components
-Pairing: Must be used with Execute Workflow node in the parent workflow
-
-**Execute Workflow (n8n-nodes-base.executeWorkflow)**
-Purpose: Call and execute another workflow from within the current workflow
-Critical configurations:
-- Workflow ID: Use expression "{{ $workflow.id }}" to reference sub-workflows in the same workflow
-- Choose execution mode: "Run Once for All Items" or "Run Once for Each Item"
-- Binary data is automatically passed to the sub-workflow
-Best practice: Use for delegating heavy processing, creating reusable modules, or managing memory in large batch operations
-
-### Data Destinations
-
-**DataTable (n8n-nodes-base.dataTable)**
-Purpose: Store extracted data in n8n's built-in data tables
-Operations: Insert, Update, Select rows without external dependencies
-Best for: Self-contained workflows that don't require external storage
-
-**Google Sheets (n8n-nodes-base.googleSheets)**
-Purpose: Log extracted data in external spreadsheet
-Operations: Use "Append" for new rows, "Update" with key column for existing
-Best for: Collaborative review and manual data validation
-
-**Database Nodes**
-- Postgres (n8n-nodes-base.postgres)
-- MySQL (n8n-nodes-base.mySql)
-- MongoDB (n8n-nodes-base.mongoDb)
-Purpose: Store structured extraction results in production databases
-Best Practice: Validate data schema before insert
-
-### Utilities
-
-**IF/Switch (n8n-nodes-base.if, n8n-nodes-base.switch)**
-Purpose: Route based on file type, extraction quality, or classification
-
-**Function/Code (n8n-nodes-base.function, n8n-nodes-base.code)**
-Purpose: Custom validation, data transformation, or regex extraction
-
-**HTTP Request (n8n-nodes-base.httpRequest)**
-Purpose: Call external OCR APIs (OCR.space, Google Vision, Mistral OCR)
-Configuration: Set "Response Format: File" for downloads
-Critical: NEVER set API keys directly in the request - user can set credentials from the UI for secure API key management
-
-## Common Pitfalls to Avoid
-
-### Binary Data Loss
-
-**Problem**: Binary file "disappears" after processing nodes
-**Solution**:
-- Use Merge node to reattach binary after processing
-- Or configure nodes to explicitly keep binary data
-- In Code nodes: copy items[0].binary to output
-
-### Incorrect OCR Fallback
-
-**Problem**: Not detecting when text extraction fails
-**Solution**:
-- Always check if extraction result is empty
-- Implement automatic OCR fallback for scanned documents
-- Don't assume all PDFs have extractable text
-
-### API Format Mismatches
-
-**Problem**: Sending files in wrong format to APIs
-**Solution**:
-- Check if API needs multipart/form-data vs Base64
-- Use "Extract from File" and "Convert to File" format conversion
-
-### Memory Overload
-
-**Problem**: Workflow crashes with large or multiple files
-**Solution**:
-- Process files sequentially or in small batches
-- Enable filesystem mode for binary data storage
-- Drop unnecessary data after extraction
-- Create a sub-workflow in the same workflow using "When Executed by Another Workflow" and "Execute Workflow". Delegate the heavy part of the workflow to the sub-workflow.
-
-### Duplicate Processing
-
-**Problem**: Same documents processed repeatedly
-**Solution**:
-- Configure email triggers to mark as read
-- Use "unseen" filters for email fetching
-- Implement deduplication logic based on file hash or name
-`;
-}
-//# sourceMappingURL=document-processing.js.map

package/dist/tools/best-practices/guides/document-processing.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"document-processing.js","sourceRoot":"","sources":["../../../../src/tools/best-practices/guides/document-processing.ts"],"names":[],"mappings":";;AAAA,4CAiUC;AAjUD,SAAgB,gBAAgB;IAC/B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+TP,CAAC;AACF,CAAC"}

package/dist/tools/best-practices/guides/form-input.d.ts

@@ -1 +0,0 @@
-export declare function getDocumentation(): string;