@n8n/ai-workflow-builder 0.28.0 → 0.29.0

package/dist/chains/prompt-categorization.d.ts

@@ -0,0 +1,3 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { type PromptCategorization } from '../types/categorization';
+export declare function promptCategorizationChain(llm: BaseChatModel, userPrompt: string): Promise<PromptCategorization>;

package/dist/chains/prompt-categorization.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptCategorizationChain = promptCategorizationChain;
+const prompts_1 = require("@langchain/core/prompts");
+const zod_1 = require("zod");
+const categorization_1 = require("../types/categorization");
+const examplePrompts = [
+    {
+        prompt: 'Monitor social channels for product mentions and auto-respond with campaign messages',
+        techniques: [
+            categorization_1.WorkflowTechnique.MONITORING,
+            categorization_1.WorkflowTechnique.CHATBOT,
+            categorization_1.WorkflowTechnique.CONTENT_GENERATION,
+        ],
+    },
+    {
+        prompt: 'Collect partner referral submissions and verify client instances via BigQuery',
+        techniques: [
+            categorization_1.WorkflowTechnique.FORM_INPUT,
+            categorization_1.WorkflowTechnique.HUMAN_IN_THE_LOOP,
+            categorization_1.WorkflowTechnique.NOTIFICATION,
+        ],
+    },
+    {
+        prompt: 'Scrape competitor pricing pages weekly and generate a summary report of changes',
+        techniques: [
+            categorization_1.WorkflowTechnique.SCHEDULING,
+            categorization_1.WorkflowTechnique.SCRAPING_AND_RESEARCH,
+            categorization_1.WorkflowTechnique.DATA_EXTRACTION,
+            categorization_1.WorkflowTechnique.DATA_ANALYSIS,
+        ],
+    },
+    {
+        prompt: 'Process uploaded PDF contracts to extract client details and update CRM records',
+        techniques: [
+            categorization_1.WorkflowTechnique.DOCUMENT_PROCESSING,
+            categorization_1.WorkflowTechnique.DATA_EXTRACTION,
+            categorization_1.WorkflowTechnique.DATA_TRANSFORMATION,
+            categorization_1.WorkflowTechnique.ENRICHMENT,
+        ],
+    },
+    {
+        prompt: 'Build a searchable internal knowledge base from past support tickets',
+        techniques: [
+            categorization_1.WorkflowTechnique.DATA_TRANSFORMATION,
+            categorization_1.WorkflowTechnique.DATA_ANALYSIS,
+            categorization_1.WorkflowTechnique.KNOWLEDGE_BASE,
+        ],
+    },
+];
+function formatExamplePrompts() {
+    return examplePrompts
+        .map((example) => `- ${example.prompt} → ${example.techniques.join(',')}`)
+        .join('\n');
+}
+const promptCategorizationTemplate = prompts_1.PromptTemplate.fromTemplate(`Analyze the following user prompt and identify the workflow techniques required to fulfill the request.
+Be specific and identify all relevant techniques.
+
+<user_prompt>
+{userPrompt}
+</user_prompt>
+
+<workflow_techniques>
+{techniques}
+</workflow_techniques>
+
+The following prompt categorization examples show a prompt → techniques involved to provide a sense
+of how the categorization should be carried out.
+<example_categorization>
+${formatExamplePrompts()}
+</example_categorization>
+
+Select a maximum of 5 techniques that you believe are applicable, but only select them if you are
+confident that they are applicable. If the prompt is ambigious or does not provide an obvious workflow
+do not provide any techniques - if confidence is low avoid providing techniques.
+
+Select ALL techniques that apply to this workflow. Most workflows use multiple techniques.
+Rate your confidence in this categorization from 0.0 to 1.0.
+`);
+function formatTechniqueList() {
+    return Object.entries(categorization_1.TechniqueDescription)
+        .map(([key, description]) => `- **${key}**: ${description}`)
+        .join('\n');
+}
+async function promptCategorizationChain(llm, userPrompt) {
+    const categorizationSchema = zod_1.z.object({
+        techniques: zod_1.z
+            .array(zod_1.z.nativeEnum(categorization_1.WorkflowTechnique))
+            .min(0)
+            .max(5)
+            .describe('Zero to five workflow techniques identified in the prompt (maximum of 5)'),
+        confidence: zod_1.z
+            .number()
+            .min(0)
+            .max(1)
+            .describe('Confidence level in this categorization from 0.0 to 1.0'),
+    });
+    const modelWithStructure = llm.withStructuredOutput(categorizationSchema);
+    const prompt = await promptCategorizationTemplate.invoke({
+        userPrompt,
+        techniques: formatTechniqueList(),
+    });
+    const structuredOutput = await modelWithStructure.invoke(prompt);
+    return {
+        techniques: structuredOutput.techniques,
+        confidence: structuredOutput.confidence,
+    };
+}
+//# sourceMappingURL=prompt-categorization.js.map

package/dist/chains/prompt-categorization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-categorization.js","sourceRoot":"","sources":["../../src/chains/prompt-categorization.ts"],"names":[],"mappings":";;AA8FA,8DA8BC;AA3HD,qDAAyD;AACzD,6BAAwB;AAExB,2DAIgC;AAEhC,MAAM,cAAc,GAAG;IACtB;QACC,MAAM,EAAE,sFAAsF;QAC9F,UAAU,EAAE;YACX,kCAAiB,CAAC,UAAU;YAC5B,kCAAiB,CAAC,OAAO;YACzB,kCAAiB,CAAC,kBAAkB;SACpC;KACD;IACD;QACC,MAAM,EAAE,+EAA+E;QACvF,UAAU,EAAE;YACX,kCAAiB,CAAC,UAAU;YAC5B,kCAAiB,CAAC,iBAAiB;YACnC,kCAAiB,CAAC,YAAY;SAC9B;KACD;IACD;QACC,MAAM,EAAE,iFAAiF;QACzF,UAAU,EAAE;YACX,kCAAiB,CAAC,UAAU;YAC5B,kCAAiB,CAAC,qBAAqB;YACvC,kCAAiB,CAAC,eAAe;YACjC,kCAAiB,CAAC,aAAa;SAC/B;KACD;IACD;QACC,MAAM,EAAE,iFAAiF;QACzF,UAAU,EAAE;YACX,kCAAiB,CAAC,mBAAmB;YACrC,kCAAiB,CAAC,eAAe;YACjC,kCAAiB,CAAC,mBAAmB;YACrC,kCAAiB,CAAC,UAAU;SAC5B;KACD;IACD;QACC,MAAM,EAAE,sEAAsE;QAC9E,UAAU,EAAE;YACX,kCAAiB,CAAC,mBAAmB;YACrC,kCAAiB,CAAC,aAAa;YAC/B,kCAAiB,CAAC,cAAc;SAChC;KACD;CACD,CAAC;AAEF,SAAS,oBAAoB;IAC5B,OAAO,cAAc;SACnB,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,KAAK,OAAO,CAAC,MAAM,MAAM,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;SACzE,IAAI,CAAC,IAAI,CAAC,CAAC;AACd,CAAC;AAED,MAAM,4BAA4B,GAAG,wBAAc,CAAC,YAAY,CAC/D;;;;;;;;;;;;;;EAcC,oBAAoB,EAAE;;;;;;;;;CASvB,CACA,CAAC;AAEF,SAAS,mBAAmB;IAC3B,OAAO,MAAM,CAAC,OAAO,CAAC,qCAAoB,CAAC;SACzC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,WAAW,CAAC,EAAE,EAAE,CAAC,OAAO,GAAG,OAAO,WAAW,EAAE,CAAC;SAC3D,IAAI,CAAC,IAAI,CAAC,CAAC;AACd,CAAC;AAEM,KAAK,UAAU,yBAAyB,CAC9C,GAAkB,EAClB,UAAkB;IAElB,MAAM,oBAAoB,GAAG,OAAC,CAAC,MAAM,CAAC;QACrC,UAAU,EAAE,OAAC;aACX,KAAK,CAAC,OAAC,CAAC,UAAU,CAAC,kCAAiB,CAAC,CAAC;aACtC,GAAG,CAAC,CAAC,CAAC;aACN,GAAG,CAAC,CAAC,CAAC;aACN,QAAQ,CAAC,0EAA0E,CAAC;QACtF,UAAU,EAAE,OAAC;aACX,MAAM,EAAE;aACR,GAAG,CAAC,CAAC,CAAC;aACN,GAAG,CAAC,CAAC,CAAC;aACN,QAAQ,CAAC,yDAAyD,CAAC;KACrE,CAAC,CAAC;IAEH,MAAM,kBAAkB,GAAG,GAAG,CAAC,oBAAoB,CAAuB,oBAAoB,CAAC,CAAC;IAEhG,MAAM,MAAM,GAAG,MAAM,4BAA4B,CAAC,MAAM,CAAC;QACxD,UAAU;QACV,UAAU,EAAE,mBAAmB,EAAE;KACjC,CAAC,CAAC;IAEH,MAAM,gBAAgB,GAAG,MAAM,kBAAkB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAEjE,OAAO;QACN,UAAU,EAAE,gBAAgB,CAAC,UAAU;QACvC,UAAU,EAAE,gBAAgB,CAAC,UAAU;KACvC,CAAC;AACH,CAAC"}

package/dist/chains/test/integration/test-helpers.d.ts

@@ -0,0 +1,3 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+export declare function setupIntegrationLLM(): Promise<BaseChatModel>;
+export declare function shouldRunIntegrationTests(): boolean;

package/dist/chains/test/integration/test-helpers.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupIntegrationLLM = setupIntegrationLLM;
+exports.shouldRunIntegrationTests = shouldRunIntegrationTests;
+const llm_config_1 = require("../../../llm-config");
+async function setupIntegrationLLM() {
+    const apiKey = process.env.N8N_AI_ANTHROPIC_KEY;
+    if (!apiKey) {
+        throw new Error('N8N_AI_ANTHROPIC_KEY environment variable is required for integration tests');
+    }
+    return await (0, llm_config_1.anthropicClaudeSonnet45)({ apiKey });
+}
+function shouldRunIntegrationTests() {
+    return process.env.ENABLE_INTEGRATION_TESTS === 'true';
+}
+//# sourceMappingURL=test-helpers.js.map

package/dist/chains/test/integration/test-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-helpers.js","sourceRoot":"","sources":["../../../../src/chains/test/integration/test-helpers.ts"],"names":[],"mappings":";;AAWA,kDAMC;AAQD,8DAEC;AAzBD,6CAAuD;AAShD,KAAK,UAAU,mBAAmB;IACxC,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC;IAChD,IAAI,CAAC,MAAM,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CAAC,6EAA6E,CAAC,CAAC;IAChG,CAAC;IACD,OAAO,MAAM,IAAA,oCAAuB,EAAC,EAAE,MAAM,EAAE,CAAC,CAAC;AAClD,CAAC;AAQD,SAAgB,yBAAyB;IACxC,OAAO,OAAO,CAAC,GAAG,CAAC,wBAAwB,KAAK,MAAM,CAAC;AACxD,CAAC"}

package/dist/tools/best-practices/chatbot.d.ts

@@ -0,0 +1,7 @@
+import type { BestPracticesDocument } from '../../types/best-practices';
+export declare class ChatbotBestPractices implements BestPracticesDocument {
+    readonly technique: "chatbot";
+    readonly version = "1.0.0";
+    private readonly documentation;
+    getDocumentation(): string;
+}

package/dist/tools/best-practices/chatbot.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatbotBestPractices = void 0;
+const categorization_1 = require("../../types/categorization");
+class ChatbotBestPractices {
+    technique = categorization_1.WorkflowTechnique.CHATBOT;
+    version = '1.0.0';
+    documentation = `# Best Practices: Chatbot Workflows
+
+## Workflow Design
+
+Break chatbot logic into manageable steps and use error handling nodes (IF, Switch) with fallback mechanisms to manage unexpected inputs.
+
+Most chatbots run through external platforms like Slack, Telegram, or WhatsApp rather than through the n8n chat interface - if the user
+requests a service like this don't use the built in chat interface nodes. If the user mentions chatting but does not mention a service
+then use the built in n8n chat node.
+
+CRITICAL: The user may ask to be able to chat to a workflow as well as trigger it via some other method, for example scheduling information
+gathering but also being able to chat with the agent - in scenarios like this the two separate workflows MUST be connected through shared memory,
+vector stores, data storage, or direct connections.
+
+Example pattern:
+- Schedule Trigger → News Gathering Agent → [memory node via ai_memory]
+- Chat Trigger → Chatbot Agent → [SAME memory node via ai_memory]
+- Result: Both agents share conversation/context history, enabling the chatbot to discuss gathered news
+
+For the chatbot always use the same chat node type as used for response. If Telegram has been requested trigger the chatbot via telegram AND
+respond via telegram - do not mix chatbot interfaces.
+
+## Context & Memory Management
+
+Always utilise memory in chatbot agent nodes - providing context gives you full conversation history and more control over context.
+Memory nodes enable the bot to handle follow-up questions by maintaining short-term conversation history.
+
+Include information with the user prompt such as timestamp, user ID, or session metadata. This enriches context without relying solely on memory and user prompt.
+
+If there are other agents involved in the workflow you should share memory between the chatbot and those other agents where it makes sense.
+Connect the same memory node to multiple agents to enable data sharing and context continuity.
+
+## Context Engineering & AI Agent Output
+
+It can be beneficial to respond to the user as a tool of the chatbot agent rather than using the agent output - this allows the agent to loop/carry out multiple responses if necessary.
+This will require adding a note to the system prompt for the agent to tell it to use the tool to respond to the user.
+
+## Message Attribution
+
+n8n chatbots often attach the attribution "n8n workflow" to messages by default - you must disable this setting which will
+often be called "Append n8n Attribution" for nodes that support it, add this setting and set it to false.
+
+## Recommended Nodes
+
+### Chat Trigger (@n8n/n8n-nodes-langchain.chatTrigger)
+
+Purpose: Entry point for user messages in n8n-hosted chat interfaces
+
+Pitfalls:
+
+- Most production chatbots use external platforms (Slack, Telegram) rather than n8n's chat interface
+
+### AI Agent (@n8n/n8n-nodes-langchain.agent)
+
+Purpose: Orchestrates logic, tool use, and LLM calls for intelligent responses
+
+### Chat Model Nodes
+
+- OpenAI Chat Model (@n8n/n8n-nodes-langchain.lmChatOpenAi)
+- Google Gemini Chat Model (@n8n/n8n-nodes-langchain.lmChatGoogleGemini)
+- xAI Grok Chat Model (@n8n/n8n-nodes-langchain.lmChatXAiGrok)
+- DeepSeek Chat Model (@n8n/n8n-nodes-langchain.lmChatDeepSeek)
+
+Purpose: Connect to LLMs for natural, context-aware responses
+
+### Simple Memory (@n8n/n8n-nodes-langchain.memoryBufferWindow)
+
+Purpose: Maintains short-term conversation history for context continuity
+
+### HTTP Request (n8n-nodes-base.httpRequest)
+
+Purpose: Fetches external data to enrich chatbot responses with real-time or organizational information
+
+### Database Nodes & Google Sheets
+
+- Postgres (n8n-nodes-base.postgres)
+- MySQL (n8n-nodes-base.mySql)
+- MongoDB (n8n-nodes-base.mongoDb)
+- Google Sheets (n8n-nodes-base.googleSheets)
+
+Purpose: Store conversation logs, retrieve structured data, or maintain user preferences
+
+### IF / Switch
+
+- If (n8n-nodes-base.if)
+- Switch (n8n-nodes-base.switch)
+
+Purpose: Conditional logic and error handling for routing messages or managing conversation state
+
+### Integration Nodes
+
+- Slack (n8n-nodes-base.slack)
+- Telegram (n8n-nodes-base.telegram)
+- WhatsApp Business Cloud (n8n-nodes-base.whatsApp)
+- Discord (n8n-nodes-base.discord)
+
+Purpose: Multi-channel support for deploying chatbots on popular messaging platforms
+
+## Common Pitfalls to Avoid
+
+### Leaving Chatbot Disconnected
+
+When a workflow has multiple triggers (e.g., scheduled data collection + chatbot interaction), the chatbot MUST have access to the data
+generated by the workflow. Connect the chatbot through shared memory, vector stores, data storage, or direct data flow connections.
+`;
+    getDocumentation() {
+        return this.documentation;
+    }
+}
+exports.ChatbotBestPractices = ChatbotBestPractices;
+//# sourceMappingURL=chatbot.js.map

package/dist/tools/best-practices/chatbot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chatbot.js","sourceRoot":"","sources":["../../../src/tools/best-practices/chatbot.ts"],"names":[],"mappings":";;;AACA,2DAA2D;AAE3D,MAAa,oBAAoB;IACvB,SAAS,GAAG,kCAAiB,CAAC,OAAO,CAAC;IACtC,OAAO,GAAG,OAAO,CAAC;IAEV,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwGjC,CAAC;IAED,gBAAgB;QACf,OAAO,IAAI,CAAC,aAAa,CAAC;IAC3B,CAAC;CACD;AAjHD,oDAiHC"}

package/dist/tools/best-practices/content-generation.d.ts

@@ -0,0 +1,7 @@
+import type { BestPracticesDocument } from '../../types/best-practices';
+export declare class ContentGenerationBestPractices implements BestPracticesDocument {
+    readonly technique: "content_generation";
+    readonly version = "1.0.0";
+    private readonly documentation;
+    getDocumentation(): string;
+}

package/dist/tools/best-practices/content-generation.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentGenerationBestPractices = void 0;
+const categorization_1 = require("../../types/categorization");
+class ContentGenerationBestPractices {
+    technique = categorization_1.WorkflowTechnique.CONTENT_GENERATION;
+    version = '1.0.0';
+    documentation = `# Best Practices: Content Generation Workflows
+
+## Workflow Design
+
+Break complex tasks into sequential steps (e.g., generate text, create image, compose video) for modularity and easier troubleshooting.
+
+## Content-Specific Guidance
+
+For text generation, validate and sanitize input/output to avoid malformed data. When generating images, prefer binary data over URLs for uploads to avoid media type errors.
+
+## Recommended Nodes
+
+### OpenAI (@n8n/n8n-nodes-langchain.openAi)
+
+Purpose: GPT-based text generation, DALL-E image generation, text-to-speech (TTS), and audio transcription
+
+### xAI Grok Chat Model (@n8n/n8n-nodes-langchain.lmChatXAiGrok)
+
+Purpose: Conversational AI and text generation
+
+### Google Gemini Chat Model (@n8n/n8n-nodes-langchain.lmChatGoogleGemini)
+
+Purpose: Image analysis and generation, video generation from text prompts, multimodal content creation
+
+### ElevenLabs
+
+Purpose: Natural-sounding AI voice generation
+
+Note: Use HTTP Request node or a community node to integrate with ElevenLabs API
+
+### HTTP Request (n8n-nodes-base.httpRequest)
+
+Purpose: Integrating with other LLM and content generation APIs (e.g., Jasper, Writesonic, Anthropic, HuggingFace)
+
+### Edit Image (n8n-nodes-base.editImage)
+
+Purpose: Manipulating images - resize, crop, rotate, and format conversion
+
+Pitfalls:
+
+- Ensure input is valid binary image data
+- Check output format compatibility with downstream nodes
+
+### Markdown (n8n-nodes-base.markdown)
+
+Purpose: Formatting and converting text to HTML or Markdown reports
+
+### Facebook Graph API (n8n-nodes-base.facebookGraphApi)
+
+Purpose: Uploading videos and images to Instagram and Facebook
+
+Pitfalls:
+
+- Use binary data fields rather than URLs for media uploads to prevent "media type" errors
+- Verify page IDs and access tokens have correct permissions
+
+### Wait (n8n-nodes-base.wait)
+
+Purpose: Handling delays in video processing/uploading and respecting API rate limits
+
+## Common Pitfalls to Avoid
+
+Binary Data Handling: For media uploads, use binary fields rather than URLs to prevent "media type" errors, especially with Facebook and Instagram APIs. Download media to binary data first, then upload from binary rather than passing URLs.
+
+Async Processing: For long-running content generation tasks (especially video), implement proper wait/polling mechanisms. Don't assume instant completion - many AI services process requests asynchronously.
+`;
+    getDocumentation() {
+        return this.documentation;
+    }
+}
+exports.ContentGenerationBestPractices = ContentGenerationBestPractices;
+//# sourceMappingURL=content-generation.js.map

package/dist/tools/best-practices/content-generation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-generation.js","sourceRoot":"","sources":["../../../src/tools/best-practices/content-generation.ts"],"names":[],"mappings":";;;AACA,2DAA2D;AAE3D,MAAa,8BAA8B;IACjC,SAAS,GAAG,kCAAiB,CAAC,kBAAkB,CAAC;IACjD,OAAO,GAAG,OAAO,CAAC;IAEV,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiEjC,CAAC;IAED,gBAAgB;QACf,OAAO,IAAI,CAAC,aAAa,CAAC;IAC3B,CAAC;CACD;AA1ED,wEA0EC"}

package/dist/tools/best-practices/data-extraction.d.ts

@@ -0,0 +1,7 @@
+import type { BestPracticesDocument } from '../../types/best-practices';
+export declare class DataExtractionBestPractices implements BestPracticesDocument {
+    readonly technique: "data_extraction";
+    readonly version = "1.0.0";
+    private readonly documentation;
+    getDocumentation(): string;
+}

package/dist/tools/best-practices/data-extraction.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataExtractionBestPractices = void 0;
+const categorization_1 = require("../../types/categorization");
+class DataExtractionBestPractices {
+    technique = categorization_1.WorkflowTechnique.DATA_EXTRACTION;
+    version = '1.0.0';
+    documentation = `# Best Practices: Data Extraction Workflows
+
+## Node Selection by Data Type
+
+Choose the right node for your data source. Use Extract From File for CSV, Excel, PDF, and text files to convert binary data to JSON for further processing.
+
+Use Information Extractor or AI nodes for extracting structured data from unstructured text such as PDFs or emails using LLMs.
+
+For binary data, ensure you use nodes like Extract From File to handle files properly.
+
+## Data Structure & Type Management
+
+Normalize data structure early in your workflow. Use transformation nodes like Split Out, Aggregate, or Set to ensure your data matches n8n's expected structure: an array of objects with a json key.
+Not transforming incoming data to n8n's expected format causes downstream node failures.
+
+When working with large amounts of information, n8n's display can be hard to view. Use the Edit Fields node to help organize and view data more clearly during development and debugging.
+
+## Large File Handling
+
+Process files in batches or use sub-workflows to avoid memory issues. For large binary files, consider enabling filesystem mode (N8N_DEFAULT_BINARY_DATA_MODE=filesystem) if self-hosted, to store binary data on disk instead of memory.
+
+Processing too many items or large files at once can crash your instance. Always batch or split processing for large datasets to manage memory effectively.
+
+## Binary Data Management
+
+Binary data can be lost if intermediate nodes (like Set or Code) do not have "Include Other Input Fields" enabled, especially in sub-workflows. Always verify binary data is preserved through your workflow pipeline.
+
+## AI-Powered Extraction
+
+Leverage AI for unstructured data using nodes like Information Extractor or Summarization Chain to extract structured data from unstructured sources such as PDFs, emails, or web pages.
+
+## Recommended Nodes
+
+### Extract From File (n8n-nodes-base.extractFromFile)
+
+Purpose: Converts binary data from CSV, Excel, PDF, and text files to JSON for processing
+
+Pitfalls:
+
+- Ensure the correct binary field name is specified in the node configuration
+- Verify file format compatibility before extraction
+
+### HTML Extract (n8n-nodes-base.htmlExtract)
+
+Purpose: Scrapes data from web pages using CSS selectors
+
+### Split Out (n8n-nodes-base.splitOut)
+
+Purpose: Processes arrays of items individually for sequential operations
+
+### Edit Fields (Set) (n8n-nodes-base.set)
+
+Purpose: Data transformation and mapping to normalize structure
+
+Pitfalls:
+
+- Enable "Include Other Input Fields" to preserve binary data
+- Pay attention to data types - mixing types causes unexpected failures
+
+### Information Extractor (@n8n/n8n-nodes-langchain.informationExtractor)
+
+Purpose: AI-powered extraction of structured data from unstructured text
+
+Pitfalls:
+
+- Requires proper schema definition for extraction
+
+### Summarization Chain (@n8n/n8n-nodes-langchain.chainSummarization)
+
+Purpose: Summarizes large text blocks using AI for condensed information extraction
+
+Pitfalls:
+
+- Context window limits may truncate very long documents
+- Verify summary quality matches requirements
+
+### HTTP Request (n8n-nodes-base.httpRequest)
+
+Purpose: Fetches data from APIs or web pages for extraction
+
+### Code (n8n-nodes-base.code)
+
+Purpose: Custom logic for complex data transformations
+
+## Common Pitfalls to Avoid
+
+Data Type Confusion: People often mix up data types - n8n can be very lenient but it can lead to problems. Pay close attention to what type you are getting and ensure consistency throughout the workflow.
+
+Binary Data Loss: Binary data can be lost if intermediate nodes (Set, Code) do not have "Include Other Input Fields" enabled, especially in sub-workflows. Always verify binary data preservation.
+
+Large Data Display Issues: n8n displaying large amounts of information can be hard to view during development. Use the Edit Fields node to help organize and view data more clearly.
+`;
+    getDocumentation() {
+        return this.documentation;
+    }
+}
+exports.DataExtractionBestPractices = DataExtractionBestPractices;
+//# sourceMappingURL=data-extraction.js.map

package/dist/tools/best-practices/data-extraction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-extraction.js","sourceRoot":"","sources":["../../../src/tools/best-practices/data-extraction.ts"],"names":[],"mappings":";;;AACA,2DAA2D;AAE3D,MAAa,2BAA2B;IAC9B,SAAS,GAAG,kCAAiB,CAAC,eAAe,CAAC;IAC9C,OAAO,GAAG,OAAO,CAAC;IAEV,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2FjC,CAAC;IAED,gBAAgB;QACf,OAAO,IAAI,CAAC,aAAa,CAAC;IAC3B,CAAC;CACD;AApGD,kEAoGC"}

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

@@ -0,0 +1,7 @@
+import type { BestPracticesDocument } from '../../types/best-practices';
+export declare class FormInputBestPractices implements BestPracticesDocument {
+    readonly technique: "form_input";
+    readonly version = "1.0.0";
+    private readonly documentation;
+    getDocumentation(): string;
+}

package/dist/tools/best-practices/form-input.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormInputBestPractices = void 0;
+const categorization_1 = require("../../types/categorization");
+class FormInputBestPractices {
+    technique = categorization_1.WorkflowTechnique.FORM_INPUT;
+    version = '1.0.0';
+    documentation = `# Best Practices: Form Input Workflows
+
+## Workflow Design
+
+### Critical: Always Store Raw Form Data
+
+ALWAYS store raw form responses to a persistent data storage destination even if the primary purpose of the workflow is
+to trigger another action (like sending to an API or triggering a notification). This allows users to monitor
+form responses as part of the administration of their workflow.
+
+Required storage destinations include:
+- Google Sheets node
+- Airtable node
+- n8n Data Tables
+- PostgreSQL/MySQL/MongoDB nodes
+- Any other database or spreadsheet service
+
+IMPORTANT: Simply using Set or Merge nodes is NOT sufficient. These nodes only transform data in memory - they do not
+persist data. You must use an actual storage node (like Google Sheets, Airtable, or Data Tables) to write the data.
+
+Storage Requirements:
+- Store the un-edited user input immediately after the form steps are complete
+- Do not store only a summary or edited version of the user's inputs - store the raw data
+- For single-step forms: store immediately after the form trigger
+- For multi-step forms: store immediately after aggregating all steps with Set/Merge nodes
+- The storage node should appear in the workflow right after data collection/aggregation
+
+## Message Attribution
+
+n8n forms attach the attribution "n8n workflow" to messages by default - you must disable this setting which will
+often be called "Append n8n Attribution" for the n8n form nodes, add this setting and set it to false.
+
+## Multi-Step Forms
+
+Build multi-step forms by chaining multiple Form nodes together. Each Form node represents a page or step in your form
+sequence. Use the n8n Form Trigger node to start the workflow and display the first form page to the user.
+
+## Data Collection & Aggregation
+
+Collect and merge all user responses from each form step before writing to your destination (e.g., Google Sheets). Use
+Set or Merge nodes to combine data as needed. Make sure your JSON keys match the column names in your destination for
+automatic mapping.
+
+## Conditional Logic & Branching
+
+Use IF or Switch nodes to direct users to different form pages based on their previous answers. This enables dynamic
+form flows where the path changes based on user input, creating personalized form experiences.
+
+## Dynamic Form Fields
+
+For forms that require dynamic options (e.g., dropdowns populated from an API or previous step), generate the form
+definition in a Code node and pass it to the Form node as JSON. You can define forms using JSON for dynamic or
+conditional fields, and even generate form fields dynamically using a Code node if needed.
+
+## Input Validation
+
+Validate user input between steps to ensure data quality. If input is invalid, loop back to the relevant form step with
+an error message to guide the user to correct their submission. This prevents bad data from entering your system.
+
+## Recommended Nodes
+
+### n8n Form Trigger (n8n-nodes-base.formTrigger)
+
+Purpose: Starts the workflow and displays the first form page to the user
+
+Pitfalls:
+
+- Use the Production URL for live forms; the Test URL is for development and debugging only
+- Ensure the form trigger is properly configured before sharing URLs with users
+
+### n8n Form (n8n-nodes-base.form)
+
+Purpose: Displays form pages in multi-step form sequences
+
+Pitfalls:
+
+- Each Form node represents one page/step in your form
+- You can define forms using JSON for dynamic or conditional fields
+- Generate form fields dynamically using a Code node if needed for complex scenarios
+
+### Storage Nodes
+
+Purpose: Persist raw form data to a storage destination, preference should be for built-in n8n tables
+but use the most applicable node depending on the user's request.
+
+Required nodes (use at least one):
+- Data table (n8n-nodes-base.dataTable): Built-in n8n storage for quick setup
+- Google Sheets (n8n-nodes-base.googleSheets): Best for simple spreadsheet storage
+- Airtable (n8n-nodes-base.airtable): Best for structured database with relationships
+- Postgres (n8n-nodes-base.postgres) / MySQL (n8n-nodes-base.mySql) / MongoDB (n8n-nodes-base.mongoDb): For production database storage
+
+Pitfalls:
+
+- Every form workflow MUST include a storage node that actually writes data to a destination
+- Set and Merge nodes alone are NOT sufficient - they only transform data in memory
+- The storage node should be placed immediately after the form trigger (single-step) or after data aggregation (multi-step)
+
+### Code (n8n-nodes-base.code)
+
+Purpose: Processes form data, generates dynamic form definitions, or implements custom validation logic
+
+### Edit Fields (Set) (n8n-nodes-base.set)
+
+Purpose: Aggregates and transforms form data between steps (NOT for storage - use a storage node)
+
+### Merge (n8n-nodes-base.merge)
+
+Purpose: Combines data from multiple form steps into a single dataset (NOT for storage - use a storage node)
+
+Pitfalls:
+
+- Ensure data from all form steps is properly merged before writing to destination
+- Use appropriate merge modes (append, merge by key, etc.) for your use case
+- Remember: Merge prepares data but does not store it - add a storage node after Merge
+
+### If (n8n-nodes-base.if)
+
+Purpose: Routes users to different form pages based on their previous answers
+
+### Switch (n8n-nodes-base.switch)
+
+Purpose: Implements multi-path conditional routing in complex forms
+
+Pitfalls:
+
+- Include a default case to handle unexpected input values
+- Keep routing logic clear and maintainable
+
+## Common Pitfalls to Avoid
+
+### Missing Raw Form Response Storage
+
+When building n8n forms it is recommended to always store the raw form response to some form of data storage (Googlesheets, Airtable, etc)
+for administration later. It is CRITICAL if you create a n8n form node that you store the raw output with a storage node.
+
+### Data Loss in Multi-Step Forms
+
+Aggregate all form step data using Set/Merge nodes before writing to your destination. Failing to merge data from multiple steps
+can result in incomplete form submissions being stored. After merging, ensure you write the complete dataset to a storage node.
+
+### Poor User Experience
+
+Use the Form Ending page type to show a completion message or redirect users after submission.
+Without a proper ending, users may be confused about whether their submission was successful.
+
+### Invalid Data
+
+Implement validation between form steps to catch errors early. Without validation, invalid data can
+propagate through your workflow and corrupt your destination data.
+
+### Complex Field Generation
+
+When generating dynamic form fields, ensure the JSON structure exactly matches what the Form
+node expects. Test thoroughly with the Test URL before going live.
+
+### Mapping Errors
+
+When writing to Google Sheets or other destinations, ensure field names match exactly. Mismatched names
+will cause data to be written to wrong columns or fail entirely.
+`;
+    getDocumentation() {
+        return this.documentation;
+    }
+}
+exports.FormInputBestPractices = FormInputBestPractices;
+//# sourceMappingURL=form-input.js.map