n8n Automation Videos & Summaries

Email Automation Setup

• Create a Google Sheet with columns: Name, Email, Subject, Message, and Send.
• The 'Send' column indicates if an email has been sent (True/False).

n8n Workflow Configuration

• Start with a Schedule Trigger set to your desired interval (minutes, hours, days, etc.).
• Add a Google Sheet Trigger (Get Row in Sheet) to fetch data.
• Configure Google Cloud credentials (OAuth 2.0) by creating a project, setting up OAuth consent screen, and generating client ID/secret.
• Enable Google Sheet API and Google Drive API in your Google Cloud project.
• Add an If Node to check the 'Send' column value.
• If 'Send' is 'no', proceed to send an email.

Email Sending Configuration

• Add an Email Node (Send Email).
• Configure SMTP account details, using an App Password for Gmail.
• Set up SMTP server (smtp.gmail.com), port (465), and sender email.
• Map email recipient, subject, and message from the Google Sheet data.

Workflow Execution and Testing

• Execute the workflow to fetch data from the Google Sheet.
• The If node will filter rows where 'Send' is 'no'.
• The Email node will send emails to the specified recipients.
• The workflow can be set to run automatically based on the schedule trigger.

What is n8n?

• n8n is a workflow automation platform that connects apps visually using nodes.
• It allows users to build automated workflows triggered by events like schedules, webhooks, or app activity.
• Supports over 400 apps and can integrate with any API using HTTP nodes.
• Includes code nodes for JavaScript/Python and built-in AI nodes for OpenAI, Anthropic, and local models.

Pricing and Self-Hosting

• The Community Edition is free and self-hosted, offering unlimited executions.
• Self-hosting costs about $5/month for a virtual server.
• Managed cloud hosting starts at €20/month for 2500 executions, billed annually.
• Pricing is per workflow run, not per step, with unlimited users and active workflows.
• Self-hosting offers privacy benefits and allows connection to internal systems.

Building Your First Workflow

• Workflows consist of a trigger (what starts it), actions (what it does), and logic (if/then branches, filters, loops).
• Users can drag, connect, and configure nodes visually.
• Workflows can be tested directly in the editor.
• AI agents can be built visually to make decisions across multiple steps.

Example Workflow and Downsides

• An example workflow described automatically follows up on website leads, replies via email, adds them to a CRM, and notifies via Slack.
• n8n offers a library of thousands of community workflow templates for quick import.
• Downsides: Self-hosting requires technical comfort; fewer direct integrations than competitors (though HTTP nodes compensate); the interface has a learning curve.

n8n Value and Learning Curve

• Yes, n8n is still worth learning due to high demand on platforms like Upwork, Freelancer, and Fiverr.
• Learning n8n provides immediate access to thousands of job opportunities.
• The drag-and-drop interface makes it accessible, and proficiency can be gained in 5-10 hours.
• n8n knowledge helps companies modernize and transition to future technologies like AI agents.

Inspiration and Content Creation

• The creator draws inspiration from video game streamers for their authentic, off-the-cuff, and entertaining content style.
• Moist Critical is highlighted as a funny and influential streamer.
• Gravemind's content, which overlays motivational poetry on anime, is mentioned as impactful during tough times.

AI Predictions and Ed Zitron

• The creator dismisses Ed Zitron's negative AI predictions, citing a track record of being consistently wrong.
• Zitron's views are attributed to audience and financial incentives rather than accurate foresight.
• The rapid progress of AI in just four years since ChatGPT's release suggests future technological advancements will be immense.

Time Management and Goal Achievement

• Working 3-4 hours daily on weekdays (15-20 hours/week) might be insufficient for rapid goal achievement.
• Efficiency is key, but dedicating more time is often necessary for significant progress.

Client Onboarding Technique

• The creator prefers guiding clients to sign up for n8n directly during calls, sharing screens and credentials.
• This high-friction method establishes authority, allows for immediate support, and facilitates the use of discount codes.

Business and Channel Growth

• Revenue for Maker School membership is fluctuating but consistently above $300K monthly.
• Instagram growth is strong, nearing 700K followers.
• Podcast growth has plateaued due to increased competition.
• X (formerly Twitter) followers have significantly increased.
• Newer channels like "Maker Zero" and clipping channels are showing promising growth.

Importing Templates

• Templates are JSON files containing n8n workflows.
• Import via "Import from URL" or "Import from File" in the workflow menu.
• Alternatively, copy JSON text and paste it onto the canvas.

Essential Fixes for Imported Templates

• Fix 1: Credentials: Connect your accounts (e.g., Gmail, Google Sheets) for nodes that communicate with external apps. Imported templates don't save passwords.
• Fix 2: Values: Update specific values within nodes that contain author-specific information like business name, email, and pricing tiers.
• Fix 3: Address: Modify the workflow's path to avoid conflicts, especially if importing the same template twice. Rename the form path, title, and questions to match your business.
• Fix 4: Publish & Test: Publish the workflow and perform a real submission to ensure it works correctly and test in the "Executions" tab.

Additional Checks

• Pinned Data: Unpin sample data from nodes; test runs should use real inputs.
• Missing Nodes: Install required community nodes if a node appears as a question mark (not applicable on n8n Cloud for non-verified nodes).
• Code & HTTP Nodes: Review code and HTTP request nodes for suspicious activity or commands that could run on your server.

Finding and Using Templates

• Use the official n8n library (n8n.io/workflows) for reviewed templates.
• Search by job function (e.g., "review request") rather than just tools.
• Choose templates with fewer nodes and apps you're familiar with.
• Save your modified version of a template for future use.
• An imported template requires the five checks before it functions correctly with your data.

Introduction to Automation Tools

• Zapier, Make (formerly Integromat), and n8n are the dominant no-code automation platforms.
• The choice of tool impacts profitability due to different pricing and learning curves.
• Businesses pay for automation to eliminate repetitive work, creating freelancing opportunities.

Zapier: The Easy Start

• Ease of Use: Easiest to learn, with a simple top-to-bottom list of trigger and action steps.
• Integrations: Largest app library (over 7,000).
• Pricing: Starts around $20/month for 750 tasks; tasks are counted per action step, making costs scale quickly.
• Money-Making Potential: Fastest path to first clients (simple automations for small businesses) but lower profit margins.

Make: The Freelancer Favorite

• Ease of Use: Steeper learning curve than Zapier, but visual interface with drag-and-drop modules.
• Pricing: Starts around $9/month for 10,000 operations; operations are counted per module. Offers significantly more automation power per dollar than Zapier.
• Integrations: Around 1,500 integrations.
• Money-Making Potential: Ideal for client work due to cost-effectiveness and visual appeal. Enables productizing services (one automation, fixed price). Offers a good balance of learning curve, cost, and capability for beginners aiming for income.

n8n: The Powerful & Cost-Effective Option

• Ease of Use: Steepest learning curve, node-based canvas with code nodes (JavaScript, Python) and AI capabilities.
• Pricing: Cloud plan around €24/month for 2,500 executions (workflow runs). Can be self-hosted for free (server costs ~$5-20/month) offering unlimited executions.
• Integrations: Around 400 integrations, but can connect to anything with an API via HTTP node.
• Raw Power: Most powerful, especially for AI agent workflows and custom solutions.
• Money-Making Potential: Best for high-ticket client work and maximizing profit margins due to extremely low infrastructure costs. Recommended as a second tool after gaining experience and income.

Head-to-Head Comparison & Recommendation

• Ease of Use: Zapier (Winner), Make, n8n.
• Pricing: n8n (Winner - self-hosting), Make, Zapier.
• Integrations: Zapier (Winner), Make, n8n.
• Raw Power: n8n (Winner), Make, Zapier.
• Beginner Money-Making: Make (Winner).
• Recommendation for Beginners: Start with Make for 2-3 weeks, build portfolio projects, then pitch clients. Use Zapier for quick jobs. Learn n8n later for advanced projects and higher earnings.

Looping Over Items

• Purpose: Automate repetitive tasks like sending personalized emails to a list of customers.
• How it works: Processes items (e.g., customer records) one by one.
• Setup: Typically used after fetching data (e.g., from a Google Sheet) that contains multiple items.
• Integration: Connects to subsequent nodes (e.g., "Send Email") to perform an action on each item.

Batch Processing

• Purpose: Manage large volumes of data efficiently and avoid hitting external service limits (e.g., email sending limits).
• Concept: Processes data in chunks (batches) rather than all at once or one by one.
• 'Batch Size' Parameter: Controls how many items are processed in a single batch.
• Benefit: Prevents errors from overwhelming systems and speeds up processing compared to individual item handling for large datasets.

Split Out Node

• Purpose: Separate individual items from an array or a collection of objects.
• Use Case: When data is received as a single item containing multiple records (e.g., an array of customer objects), this node breaks it down.
• Functionality: Transforms one item containing multiple sub-items into multiple individual items, allowing for separate processing of each.
• Example: Takes an array of customers and outputs each customer as a distinct item, enabling personalized actions for each.

OpenAI Node Setup

• Connects to OpenAI's API (like ChatGPT) for text generation, summarization, classification, etc.
• Requires an OpenAI account and API key.
• Free credits are available upon signup, but a payment method is required.
• Set a monthly spending limit in billing settings.
• Generate a secret API key in the OpenAI platform (Platform.openai.com).
• Copy and securely store the API key.
• In n8n, add the OpenAI node and configure a new credential with the API key.
• Test the connection by prompting "Say hello".

Writing Effective Prompts

• Clear and specific prompts are crucial.
• Four key elements:
• Role/Context: Define the AI's persona (e.g., "You are a professional assistant").
• Task: State the action clearly (e.g., "Summarize the following email").
• Input/Data: Provide the information the AI needs.
• Output Format: Specify how the response should be structured (e.g., "in two sentences", "in bullet points").
• Examples: Use few-shot prompting for specific outputs.
• Chain of Thought: Ask AI to "think step by step" for complex reasoning.
• Constrain Output: Use strict rules for desired formats.
• Dynamic Data: Reference data from previous nodes (e.g., `$json.customerName`).
• Avoid common mistakes: Vague instructions, no output constraints, assuming context, not testing edge cases, overly complex prompts.

Structured Output with JSON Mode

• Problem: AI responses are free text, making them hard to use in workflows.
• Solution: JSON mode forces AI to return structured JSON data.
• Setup:
• In the OpenAI node, go to "Options" and add "Response Format".
• Set "Response Format" to "JSON Object".
• Prompting: Must explicitly tell the AI the desired JSON structure (e.g., "Respond with valid JSON in this exact format: Name, Email, Phone").
• Accessing Data: Use `$json.fieldName` in subsequent nodes.

Building AI-Powered Workflows

• Standard Pattern: Trigger -> Get Data -> OpenAI Processing -> Action.
• Example Workflow (Customer Message Analysis):
• Webhook Trigger receives customer message.
• OpenAI node classifies message (category, urgency, sentiment) using JSON mode.
• If node routes based on AI classification and urgency.
• Different actions for different routes (e.g., email alert for urgent complaints, log to Google Sheets for normal inquiries).
• Key Patterns: AI + Routing, AI + Enrichment, AI + Transformation, Multiple AI steps, AI + Human Review.

Advanced Techniques & Patterns

• AI Decision Making: Use AI to analyze data and make decisions, then route based on AI output (e.g., email priority).
• Traditional Logic vs. AI Logic: If/Switch nodes for hard-coded rules vs. AI for nuanced decisions.
• AI Confidence Check: Route based on AI's confidence score (e.g., auto-process if >90%, human review if 50-90%).
• Chaining AI Decisions: Use multiple AI nodes for complex analysis and routing.
• AI Agents vs. Automations: Automations follow rules; Agents use AI for reasoning and autonomy to achieve goals.
• Levels of AI Integration: From basic AI enhancement to multi-agent systems.

Error Handling & Reliability

• Importance: Essential for production-ready workflows.
• Common Failures: Missing data, invalid credentials, rate limits, service downtime, timeouts, format mismatches, unexpected AI outputs.
• Solutions:
• Validation: Check inputs at the start (required fields, data types, formats).
• Error Trigger Node: Catches workflow failures and initiates an error handling flow.
• Continue on Fail: Allows workflows to proceed even if a node fails.
• Retries & Fallbacks: Implement logic to retry failed operations or use alternative methods (e.g., cache data, email alerts).
• JSON Mode & Strict Prompts: Crucial for reliable AI output.
• Golden Rule: Assume everything will fail and plan accordingly.

AI Workflow Builder Best Practices

• Use AI for: Standard patterns, rapid prototyping, exploring integrations, creating boilerplate structure.
• Limitations: Struggles with complex logic, edge cases, optimization, security, and production reliability.
• Verification is Crucial: Never trust AI-generated workflows blindly.
• Audit Checklist: Verify triggers, integrations, AI prompts, routing logic, and error handling.
• Ideal Approach: AI generates the structure, humans review, validate, add reliability features, and test thoroughly.
• Prompt Quality Matters: Be specific about triggers, data, processing steps, outputs, conditions, and fallback behavior.

Installation

• Recommended installation: Docker with a single command: docker run -d --name n8n -p 5678:5678 -v n8n_data:/home/node/.n8n n8nio/n8n
• Docker benefits: Easy backups (folder copy), simple upgrades (one command), avoids OS conflicts.

Core Nodes (The 20% that covers 95% of workflows)

• Trigger: Handles starting workflows (Schedule, Webhook, Gmail trigger for email triage).
• Set: Cleans and shapes data (e.g., extracting subject, body, labels from email).
• HTTP Request: Connects to external services via APIs (e.g., sending email data to an LLM for classification).
• Code: For custom logic not covered by other nodes (e.g., handling specific invoice formats).
• Merge: Combines data from different workflow branches.

Data Flow & Logic

• Data moves between nodes as items (JSON objects).
• A real-world email triage workflow uses a Gmail trigger, Set node, HTTP Request to an LLM for classification (Reply Now, Reply Later, Delegate, Ignore).
• Uses an If node to route based on classification.
• Crucial pattern: Ambiguous classifications are flagged for human review, not automated guesses.

Error Handling

• Two layers: Node-specific retries with waits, and a dedicated Error Workflow.
• Error workflow catches all failures, sending an alert (e.g., Telegram, email) with workflow name, node, and error message.
• This provides context for quick fixes, preventing silent failures.

Deployment & ROI

• Workflow on laptop is a demo; deploy to N8N Cloud (approx. $20-24/month) or own server via Docker.
• Docker on an existing server is cost-effective for small teams (zero ongoing cost).
• Automating email triage can save 10 hours/week for small businesses.
• Payback period is typically within the first month.
• The core architecture is reusable for various tasks (invoicing, lead routing, etc.).

Workflow Setup

• Create a new workflow and name it.
• Add an RSS feed node (using Google News RSS as an example).
• Add a limit node to restrict the number of items (e.g., 10).

Formatting and Webhook

• Add a JavaScript node for formatting the output.
• Add a webhook node to listen for incoming requests.
• Configure the webhook with a specific path (e.g., "RSS viewer") and set it to respond using a webhook node.

Finalizing and Activation

• Add a "Respond to Webhook" node.
• Set the response type to "text" and the response body to "json.html".
• Test each node individually, ensuring all pass.
• Turn off webhook testing before proceeding.
• Activate the workflow.
• Access the workflow output via the webhook URL in a browser.

Svelte 5 Revolution

• Svelte 5 is a ground-up rewrite, not just an update.
• It aims for faster, smaller applications and improved TypeScript support.
• Svelte has a 91% satisfaction rate according to Stack Overflow.

Ditching the Virtual DOM

• Traditional frameworks (React, Vue) use a Virtual DOM for reactivity, causing diffing overhead.
• Svelte 5 eliminates the Virtual DOM and diffing overhead.
• It relies on compile-time reactivity, compiling components into optimized JavaScript for direct DOM updates.

Introducing Runes

• Runes are explicit reactive markers.
• Key runes: $state (reactive state), $derived (computed state), $effect (side effects), $props (component inputs).
• Runes replace Svelte 4's implicit magic syntax for cleaner, explicit reactivity.

Compile-Time Reactivity Workflow

• User event occurs.
• Event updates a variable marked with $state.
• Dependent $derived values recalculate.
• Optimized JavaScript performs direct DOM updates.

Upgrading to Explicit Reactivity

• Svelte 4 used implicit reactivity (e.g., let amount = 0; with magic syntax).
• Svelte 5 requires explicit declarations: let amount = $state(0);, let double = $derived(amount * 2);.
• Component inputs now use $props: let { amount, price } = $props();.

Best Practices and Pitfalls

• Avoid overusing $state for static data; use state.immutable() instead.
• Use $effect only for imperative code or external syncing, not for computing values.
• Do not update state within an $effect to prevent infinite loops.
• Avoid checking for the browser inside $effect, as effects don't run on the server.
• Use keyed {#each} blocks for efficient list rendering.
• Svelte 5 introduces snippets for reusable UI chunks within components.

Debugging

• The $inspectTrace() tool helps debug reactivity issues by logging dependencies.

System Overview

• N8 automation system for pool servicing companies.
• Transforms messy technician notes and chemical readings into structured records.
• Automates follow-up work orders and polished customer reports.
• Uses rule-based thresholds, AI triage, and human-in-the-loop approvals.
• Ensures critical pool issues are caught and resolved before customer updates.

Workflow Process (Post-Visit)

• Technician submits a post-visit form.
• Workflow triggers, grabbing customer information.
• Retrieves visit history from Google Sheets.
• Prepares context for an AI agent.
• Logs failed visits and notifies via Slack.
• If successful:
• Records and logs the visit.
• AI agent determines if a follow-up is needed based on service notes.
• If follow-up needed, automatically creates a work order.
• Updates customer information (e.g., last visit) in the Google Sheet.

AI Triage and Approvals

• AI agent identifies potential issues and need for follow-up.
• System checks if manager approval is required.
• If no approval needed, customer report is sent directly.
• If approval needed (e.g., for created work orders):
• AI sends an approval request to the manager.
• Workflow pauses, waiting for manager approval.
• Upon approval, a customer report is automatically sent.
• If manager marks as "held," draft work order is logged.

Notifications and Reporting

• Automated notifications for single node failures.
• Slack notifications for specific events (e.g., manager approvals, agent-related issues).
• Customer reports are generated and sent after successful processing and approvals.
• Separate workflow handles daily updates and open work orders.

Introduction

• The video demonstrates building a WhatsApp AI agent using n8n for a local business.
• It connects to Google Sheets for business details and uses Gemini as the AI chat model with simple memory.

n8n Setup and Integration

• n8n is used for workflow automation due to its easy app integration via a '+' icon.
• A Google Doc contains necessary details and API keys for the automation.
• A Google Sheet is used to store menu items, pricing, order details, and FAQs.
• n8n offers a 14-day trial; paid plans start at $20/month.
• Affordable self-hosting options for n8n are available on Bluehost (starting around $18/month) and Hostinger.

AI Agent Configuration

• The workflow starts with a trigger (initially 'On Chat Message', later replaced with WhatsApp).
• An 'AI Agent' node is added.
• Chat Model: Gemini is chosen for its accessibility. Users need to generate an API key from the Gemini API website and input it into n8n.
• Memory: Simple memory is used to allow the AI to recall past conversations. The context limit can be adjusted (e.g., to 50 messages).

Tools and Data Integration

• Google Sheets: Connected to n8n via 'Sign in with Google'.
• Inventory Sheet: Fetched using 'Get Rows' operation to retrieve menu items.
• Orders Sheet: Used with 'Append Row' to add new orders, automatically populated with customer details, order, quantity, date, status, and price.
• FAQ Sheet: Fetched using 'Get Rows' to provide answers to frequently asked questions.
• Switching to a different Gemini model (e.g., Flash 3 preview) resolved an issue where the AI wasn't retrieving menu items correctly.

WhatsApp Integration

• WhatsApp Cloud API is used for integration.
• Credentials: Requires Client ID and Client Secret obtained from Meta for Developers.
• An app needs to be created in Meta for Developers, specifying WhatsApp as a feature.
• The WhatsApp setup in n8n requires an Access Token and Business Account ID, retrievable from the WhatsApp API setup section within Meta.
• A test number is provided for initial setup; users can later add their own verified phone number.
• Send Message Node: Configured to send the AI agent's response back to the customer via WhatsApp. The AI agent's output is dragged and dropped into the text body.

Final Workflow and Testing

• The trigger is set to 'On Message' for WhatsApp.
• The AI agent is connected to receive WhatsApp messages and respond.
• A system message is added to the AI agent, providing context about the restaurant (name, hours, workflow instructions, how to handle orders and inventory checks).
• The AI agent, when prompted via WhatsApp, can now respond according to the provided instructions, confirming orders, checking inventory, and handling queries.
• The final automation allows customers to interact with an AI agent on WhatsApp for inquiries, orders, and bookings.

n8n Form Submission Trigger

• The video demonstrates how to use the "Form Submission" trigger in n8n to automate AI workflows.
• This is presented as a no-code solution suitable for users without coding backgrounds.

Creating a Custom Form

• Users can build custom forms directly within n8n.
• For a "Job Hiring" form example, fields like "Name", "Email", "Mobile Number", and "Profession" can be added.
• Each form field uses a "Label" and "Text Input" type.

Integrating with Google Sheets

• The workflow connects the form submission to a Google Sheet using the "Append Row" operation.
• This ensures that each new form submission adds a new row of data to the specified Google Sheet.
• Crucially, field mappings (e.g., form "Name" to Google Sheet "Name" column) should use expressions from the trigger data, not fixed values, to ensure correct data entry for each submission.

Workflow Execution

• After setting up the form and the Google Sheets integration, submitting the form populates the Google Sheet with the entered information.
• The video showcases successful submissions, demonstrating that data like name, email, mobile number, and profession are correctly added to the sheet.

Workflow Setup

• A five-step lead-intake automation was used for pricing comparison across n8n, Make, and Zapier.
• Steps include: form submission trigger, email validation, CRM contact creation, lead scoring, and Slack notification.
• Pricing was based on official documentation as of September 30, 2026, without actual account builds.

Pricing Unit Differences

• n8n: Bills per execution, regardless of the number of steps.
• Make: Bills per credit, with each module (trigger, action) costing one credit.
• Zapier: Triggers are free; actions cost one task per successful run.

Cost at 500 Runs/Month

• n8n: $20-$24/month (Starter plan covers 2500 executions).
• Make: $12/month (Core plan for 10,000 credits).
• Zapier: Professional tier needed (free plan limited to 2 steps).

Cost at 5000 Runs/Month

• n8n: $50/month (Pro plan for 10,000 executions).
• Make: $38/month (Core plan, 40,000 credits).
• Zapier: Professional tier, 20,000 task tier (price not quoted as not advertised).

Pricing Traps

• Make: Polling checks consume credits even if no data is found.
• Zapier: Free plan is strictly limited to two steps (trigger + one action).
• n8n: No free-forever cloud tier; self-hosting is an option.
• AI Tax: Advanced/premium AI models on Zapier significantly increase task costs.

Error Handling

• n8n: Dedicated error workflows can be assigned to catch failures.
• Make: Module-level error handlers (Skip, Retry) and an optional "incomplete executions" feature.
• Zapier: Auto-replay for failed steps (up to 5 attempts) and a potential Zap deactivation for high error rates.

Conclusion

• n8n: Best for complex workflows due to predictable per-execution pricing.
• Make: Often cheapest for short workflows and high volume.
• Zapier: Easiest for non-technical teams, despite being the priciest per run.
• The "winner" depends on specific workflow complexity, volume, and team technical skill.

n8n Automation Overview

• n8n is a developer-friendly, scalable, open-source, and self-hostable workflow automation platform, an alternative to Zapier and Make.
• It combines visual ease with full code control, enabling automation of business processes without logic limits.
• Key features include visual building for fast iterations, native code, custom code integration, and suitability for both everyday and complex AI agent workflows.
• Use cases range from building AI agents and RAG workflows to IT operations and supercharging CRMs.

Installation and Setup

• Installation can be done via npm (`npm install n8n`) or Docker. The video focuses on the npm method.
• After installation, run `n8n start` in the command prompt to launch the instance.
• Access n8n via `localhost:5678` in your web browser.
• Initial setup requires email, name, and password. A free license key for advanced features can be requested.

Workflows and Nodes

• Workflows are visual, node-based automation chains connecting apps, APIs, and AI models.
• Core elements:
• Trigger Node: Event that starts the process (manual, schedule, webhook, etc.).
• Action Node: Steps that perform work (fetching data, sending messages).
• Data Control Logic: Built-in rules like filters, switches, loops, and custom code (JS/Python) for data manipulation.
• Nodes can be added, configured, tested, and executed individually or as part of a workflow.
• The editor interface includes options for triggers, actions, data transformation, and AI integrations.

Key n8n Features and Integrations

• Templates: Over 11,000 pre-built workflow templates are available on the n8n website for various use cases (AI, sales, IT, marketing, etc.).
• Scheduled Workflows: Workflows can be scheduled to run automatically at specific intervals or times using the "On a Schedule" trigger. Timezone configuration is crucial.
• AI Integrations:
• Gemini: Integrate Google Gemini by using your API key, specifying the resource (text) and operation (message model).
• Claude (Anthropic): Set up credentials with your Anthropic API key (requires funds in your account) and choose a model like Claude Haiku for text messaging.
• OpenAI: Connect using your OpenAI API key, select a model (e.g., GPT-3.5 Turbo), and define the prompt. Requires sufficient credit balance.
• Ollama: Interact with local Ollama models by providing your API key and base URL.
• Webhooks: Turn n8n into a mini web service that listens for HTTP requests. Use "Respond to Webhook" to send responses back. Useful for creating custom translators or password generators.
• HTTP Requests: Fetch data from public APIs (like GitHub stars) or any URL. The "Edit Fields" node can help clean and extract specific data.
• Forms: Create custom forms directly within n8n using the "Form" trigger node, allowing users to submit data (text, email, radio buttons, etc.) that can then be processed by the workflow.
• Web Scraping: Build scrapers to extract clean text, titles, descriptions, and images from web pages by combining webhook, fetch page, and text cleaning nodes.
• Password Generator: Create a web service that generates random passwords based on user-defined length and count parameters using webhook and code nodes.
• Webhook Security: Protect webhooks from unauthorized access by using a "Bouncer" or "If" node to check for a secret API key in headers or URL parameters, returning a 401 error if invalid.
• Async Webhooks: Fix webhook timeouts by replying immediately with an "Accepted" status (2022) using the "Respond to Webhook" node early in the workflow, allowing the heavy processing to continue in the background.
• Data Tables: Use built-in, lightweight databases for persistent storage within n8n, eliminating the need for external services like Google Sheets. Supports basic field types and automatic system columns.

Settings and Configuration

• Access settings via the bottom-left corner.
• Includes sections for Usage & Plan, Personal Settings (profile, security, theme), Users, Roles (enterprise feature), API key generation, External Secrets (enterprise), Environments (enterprise), SSO (enterprise), Security & Policies, Personal Space, LDAP (enterprise), Log Streaming, Open Telemetry, Community Nodes, Instance MCP, and Chat Preview.

Encryption Basics

• Encryption uses a key to scramble data, making it unreadable without the corresponding decryption key.
• Encryption and decryption keys can be different, which can enhance security (e.g., Edward Snowden case).

Types of Data Encryption

• Data at Rest: Data that is idle and stored on devices.
• Data in Transit: Data that is moving between systems over a network.
• SSL/TLS certificates are used to encrypt data in transit.

AWS Data Protection

• Built-in Protection: Services like S3, EBS, and DynamoDB offer automatic encryption at rest.
• AWS Key Management Service (KMS): Used to create and manage cryptographic keys for encryption and decryption.
• AWS Macie: Uses machine learning to discover and protect sensitive data at rest in S3.
• AWS Certificate Manager (ACM): Manages SSL/TLS certificates for data encryption in transit (HTTPS).

Identifying Addictive Behaviors

• Test for addiction by removing a substance or behavior for a week and observing the effects.
• Common reasons for substance use include "Dutch courage" (avoiding problems), peer pressure, and poor mentorship.

Routing Nodes Overview

• Introduces n8n IF, Switch, and Filter nodes for easy data routing.
• Demonstrates a workflow for a plumbing company to route job requests.
• The example workflow was built in 20 minutes and is free to run.

Filter Node

• Acts as a "bouncer", allowing only matching items to pass.
• Useful for removing unwanted items like spam, test entries, or out-of-area jobs.
• Dropped items vanish quietly; use IF for a visible "no" path.
• Example: Filters by zip code (starts with 217) to keep only local jobs.

IF Node

• Acts as a "fork with two exits" (true/false).
• Each item is checked individually, allowing some to go up and others down.
• Uses "matches rejects" for conditions (e.g., keywords like "leak" OR "burst" OR "flood").
• One IF node asks one question; avoid chaining multiple IFs.

Switch Node

• Handles three or more outcomes or potential future additions.
• Each rule is one output, checked from top to bottom; the first match wins.
• Crucially, the fallback output catches items that don't match any rule.
• Example: Routes jobs to "Water Heater," "Drain," or "Everything Else" (fallback).

Workflow Implementation

• The real workflow starts with a job request form.
• A "clean up" step trims spaces and lowercases text for reliable matching.
• The routed jobs end in SET nodes to display tailored headlines and messages.
• Example: "Burst pipe" goes to emergency, "no hot water" goes to water heater.

Common Mistakes & AI Integration

• Mistakes to avoid: case sensitivity, numbers as text, empty fields, missing fallback in Switch.
• Suggests using AI (like n8n's text classifier) for complex sorting but recommends starting with keyword-based nodes (Switch) for cost-effectiveness and explainability.
• Recommends using AI only for the "everything else" lane after initial keyword routing.

Node Selection Guide

• Filter: When you only want some items and discard the rest.
• IF: For exactly two outcomes (yes/no).
• Switch: For three or more outcomes, with the fallback always on.
• Order: Filter first, then IF, then Switch.

Core Concepts: Workflows and Triggers

• Workflow: A sequence of steps (nodes) executed in order to complete a task.
• Nodes: Individual applications or actions within a workflow (e.g., email, Google Sheets).
• Trigger: An event that initiates a workflow. Without a trigger, a workflow cannot run.

Types of Triggers and Their Use Cases

• Manual Trigger: Initiated by the user, primarily for testing or when human intervention is required.
• Scheduled Trigger: Runs a workflow automatically at a set time (e.g., daily at 9 AM). Ideal for routine tasks.
• Other triggers mentioned include: Email, Form, WhatsApp, Webhook.

Practical Demonstration and Homework

• The session demonstrated creating a workflow using a Manual Trigger and the "Edit Fields" node to manually input data (name, email, message) for sending an email.
• Homework: Create a workflow that takes your name, a friend's email, and a message, then sends it via email using the Manual Trigger and Edit Fields nodes.

Future Topics and Tool Benefits

• Upcoming topics include JSON expressions, fundamental programming concepts (variables, keywords), and advanced workflows.
• n8n allows for rapid creation of automations and tools like chatbots in minutes, saving significant development time.
• The course aims to equip participants with skills for high-demand roles in automation and AI engineering.

Introduction to AI Agents

• AI agents can make decisions for you, simplifying complex tasks.
• They act as a brain (LLM like Claude) connected to tools (n8n).

Setting Up n8n

• n8n is an open-source workflow automation tool, self-hostable for free.
• Recommended to self-host n8n on a VPS (e.g., Hostinger KVM1) for cost-effectiveness and more executions.
• The video provides a step-by-step guide to self-hosting n8n, including setup and activation.

Connecting Claude and n8n

• Claude's "Code" feature can be used to instruct n8n.
• Connect n8n's instance-level webhook or a community webhook (GitHub) to Claude.
• Claude can automatically generate n8n workflows based on prompts.

Building a Feedback Form Agent

• Objective: Create a workflow that collects user feedback, saves it to Airtable, and sends a Slack notification for low ratings.
• Steps:
• Use Claude to generate the initial n8n workflow (form, data cleaning, Airtable save, Slack alert).
• Set up Airtable base and table for feedback storage.
• Configure Airtable credentials in n8n.
• Connect Slack and set up a dedicated channel (e.g., "Customer Feedback").
• Test the workflow with sample feedback and verify data in Airtable and Slack.

Enhancing the Feedback Agent with AI Analysis

• Objective: Use AI (OpenAI/ChatGPT) to analyze feedback, categorize it, determine sentiment/urgency, and tag relevant teams/individuals on Slack.
• Steps:
• Connect OpenAI API key as a credential in n8n.
• Prompt Claude to add an AI analysis node to the existing workflow.
• Claude generates prompts for AI to categorize feedback (design, development, etc.), assess sentiment, and urgency.
• Update Airtable with new columns for AI analysis results (sentiment, urgency, category, summary).
• Configure Slack tagging based on AI-determined categories.
• Test the enhanced workflow with feedback and verify Slack notifications with AI-driven analysis and tags.

Creating an RSS Digest Agent

• Objective: Build an AI agent that reads RSS feeds from Airtable, identifies top news, and sends a digest to Slack.
• Steps:
• Create an Airtable base with RSS feed entries.
• Prompt Claude to create an n8n workflow to read RSS feeds, use OpenAI/ChatGPT for summarization, and send a digest to Slack.
• Claude generates complex prompts for AI to determine "top news" based on factors like impact, relevancy, and frequency.
• The AI agent formats the output, highlighting top 3 news stories and providing a digest of others.

API Keys Explained

• API keys authenticate AI workflows and grant permission to access external services.
• They are essential for connecting AI automation platforms (like n8n) to AI models and other services.
• API keys are alphanumeric and unique to the user and service.
• Never share your API key; protect this sensitive information.

Obtaining and Managing API Keys

• For OpenAI, API keys are generated in your account dashboard under "API keys".
• You can name your keys and set expiration dates (e.g., one day, never).
• Creating multiple keys doesn't affect usage credits; usage is based on the number of requests made.
• The platform (n8n) uses API keys in its "Credentials" section or within specific nodes like "HTTP Request" via headers.

Understanding Model Limits & Usage

• Rate limits prevent excessive use of AI models and services.
• The most common errors relate to reaching these rate limits (e.g., "Rate limit reached").
• TPM (Tokens Per Minute): The number of words or parts of words (tokens) you can send/receive per minute. Higher TPM allows for longer conversations.
• RPM (Requests Per Minute): The number of separate API calls you can make per minute. Higher RPM allows for more simultaneous workflows.

Choosing the Right AI Model

• Different AI models have varying capabilities (text, image, video) and associated costs.
• Models like GPT-3.5 Turbo are less expensive but may offer less accuracy or creativity.
• Newer models like GPT-4o or GPT-4 Mini offer better performance but can consume more tokens.
• Models like Deepseek V4 and Qwen 2.5 have high TPM/RPM but may be less creative; they can be affordable and precise.
• Consider your specific use case and budget when selecting a model.
• Services like OpenRouter allow you to switch between different AI models, potentially with different rate limits than using a model directly from its provider.

n8n Chain Nodes Explained

• Chain nodes in n8n are components that sequence AI functionalities, including Large Language Models (LLMs).
• They differ significantly from LangChain instances or AI agent nodes because they cannot incorporate memory.
• Examples include: Basic LLM Chain, Information Extractor, Question and Answer Chain, Sentiment Analysis, Summarization Chain, and Text Classifier.

Information Extractor Example

• The Information Extractor node has a predefined system prompt to extract specific data.
• It's designed for single, focused tasks and cannot be augmented with tools for broader functionality.

Summarization Chain Example

• This node takes input, chunks it, and uses predefined prompts for summarization.
• It performs a single function (summarization) without memory or tool integration.

When to Use Chain Nodes

• Chain nodes are ideal for basic, straightforward functionalities within a workflow.
• For complex workflows requiring tool integration and decision-making, AI agent nodes are more suitable.

n8n Workflow Examples

• Many n8n nodes, including chain nodes, offer example workflows that can be imported to demonstrate usage.

Workflow Setup

• Create a new workflow in n8n.
• Use "Add First Step" to begin.

Form Creation

• Add "Form" node and select "On New NAT Form Event".
• Set "Form Title" to "Feedback".
• Set "Form Description" to "Feedback about Apple products".
• Add form elements:
• Name (Text Input, Required)
• Email (Email Input, Required)
• Feedback (Text Input, Required)

Email Automation

• Add a "Gmail" node and select "Send a Message".
• Configure the first Gmail node to send an acknowledgement email to the customer:
• "To": Use the email from the form submission.
• "Subject": "Thank you for your valuable feedback".
• "Message": "Hi [Name], thank you for the feedback on our products. I really appreciate the time you have taken to reach out to us. Appreciate your support."
• Add a second "Gmail" node to send feedback to the internal team:
• "To": Internal team email address (e.g., chatgpt user 289289@gmail.com).
• "Subject": "Hello, please check the feedback from customer".
• "Message": "Hi team, please check the feedback from the user [Name]: [Feedback]".

Testing and Execution

• Execute the workflow to test the form submission and email sending.
• Submit a test form with name, email, and feedback.
• Verify that both acknowledgement and internal team emails are sent and received correctly.

Google Cloud Free Trial & Credits

• Obtain $300 free credits for 90 days from Google Cloud.
• A small initial payment (e.g., $10) might be required, which can be refunded.
• To get a refund, navigate to Billing, then Linked billing account, and click Request refund.

Setting Up n8n on Google Cloud Compute Engine

• Go to Compute Engine and click Create instance to create a virtual machine (VM).
• Give the instance a name (e.g., "demo").
• Select a region close to your location for faster response.
• Choose the E2 machine series and E2-standard-2 machine type.
• Set provisioning to Spot for cost savings (monthly estimate around $30).
• Select Ubuntu 22.04 as the OS and choose a Standard persistent disk.
• Ensure networking allows necessary traffic and click Create.

Installing n8n via SSH

• Connect to your VM using SSH by clicking the SSH button.
• Copy and paste commands from a provided setup guide into the SSH terminal.
• Install necessary components, including Docker.
• Verify Docker installation and check if n8n is running using docker ps.

Configuring Firewall and Accessing n8n

• Obtain the VM's external IP address from the Compute Engine instances page.
• Navigate to VPC network -> Firewall and create a new rule.
• Name the rule (e.g., "allow-nan").
• Set direction to Ingress, targets to All instances in the network.
• In IPv4 range, use 0.0.0.0/0.
• Set protocol to TCP and port to 5678.
• Create the firewall rule.
• Edit your VM instance and add the firewall rule name ("allow-nan") to the Network tags.
• Access n8n by pasting the VM's external IP followed by port 5678 (e.g., IP_ADDRESS:5678) in your browser.

Activating n8n License

• Set up your n8n account with email and password.
• Click Send me a free license key.
• Copy the license key from your email.
• Paste the key into n8n to activate it, granting unlimited access.

What is n8n?

• n8n is a workflow automation platform that connects different applications and automates tasks between them without writing code.
• It functions like a visual pipeline where you connect "nodes" representing steps in a process.

How n8n Works (Example: Customer Form Automation)

• Trigger: A customer fills out a form on your website.
• Webhook Node: The form submission triggers a webhook, acting as the entry point for n8n.
• AI Processing: The customer's message is sent to an AI model to understand and classify the request (e.g., sales inquiry, support).
• Data Saving: The customer's data is saved to a database or CRM.
• Email Notification: Simultaneously, an email is sent to the admin team with lead details.

Why n8n is Popular

• Modern applications use many disparate services; n8n simplifies integration compared to manual, code-intensive point-to-point connections.
• It supports numerous integrations including APIs, webhooks, and databases, enabling simple to complex automation.

n8n vs. Traditional Coding

• n8n offers a visual, node-based approach, drastically speeding up development compared to writing code from scratch.
• It provides high accessibility for users to understand workflows due to its visual interface and clear steps.
• While coding offers maximum control, n8n allows injecting custom JavaScript for complex logic within nodes, bridging the gap.

Use Cases

• E-commerce: Automating order processing, payment checks, and customer confirmation emails.
• Customer Support: Analyzing messages, classifying issues, and creating support tickets.
• Content Creation: Using AI to generate scripts, create videos, and schedule posts.
• DevOps: Analyzing GitHub events, reviewing code, and sending reports.
• Employee Onboarding: Automating user creation, ticket assignment, and team notifications.

Introduction to Automation

• Automation is used for repetitive tasks to eliminate manual effort.
• Two types of automation: coding automation (e.g., LangChain) and non-coding automation (e.g., n8n, Zapier, Make.com).

What is n8n?

• n8n is a workflow automation platform that connects different applications to automate repetitive work.
• The name "n8n" is derived from "node automation," with "n" representing the eight letters between the first and last "n".

Installation Methods

• Cloud-based: Available at n8n.io, offers a 14-day free trial, then paid plans starting from €24/month.
• Local Installation:
• Requires Node.js and npm.
• Command: npm install -g n8n
• Run using the command: n8n
• Docker: A container-based platform that simplifies setup. Requires Docker Desktop and a docker-compose.yml file.

Cloud vs. Self-Hosted (Local)

• Cloud: No installation needed, fully hosted by n8n, requires no technical expertise for setup, maintenance handled by n8n. Limited customization.
• Self-Hosted: Requires setup (Node.js, Docker, or own servers), technical expertise needed, user is responsible for maintenance, deployment, and hosting. Offers full customization.

Course Structure

• 30-day duration, daily sessions at 8 PM IST.
• Covers workflows, trigger nodes, logic, data structures, and practical use cases like Google Sheets, WordPress, email, Slack, Telegram, and WhatsApp automation.
• Future sessions will delve into RAG applications and chatbot flows.

Invoice Processing Workflow

• The video compares Zapier, Make, and n8n for processing supplier invoices via email.
• The workflow involves: receiving an invoice email (Gmail trigger), extracting data (AI step), creating a bill (QuickBooks), and sending a notification (Slack).
• Human review is a critical step after AI extraction and before bill approval.

Costing Models and Units

• Zapier: Bills per "task" (actions that succeed). Trigger steps are free.
• Make: Bills per "credit". The trigger counts as one credit per check, and subsequent modules cost credits per item processed.
• n8n: Bills per "execution" (one run of the entire workflow).

Platform-Specific Costs (500 Invoices/Month Scenario)

• Zapier: At least 2 tasks per invoice (QuickBooks + Slack) + AI cost. Entry-level tiers are insufficient. The "Team" plan (2000 tasks, ~$69/month annually) is a likely starting point.
• Make: Around 3 credits per invoice + polling costs. The "Core" plan (10,000 credits, $9/month) might be sufficient, depending on polling frequency. AI costs are separate if using your own provider.
• n8n Cloud: If one invoice is one execution, "Starter" (2500 executions, 20 euros/month annually) might fit. If polling counts as executions, "Pro" (~50 euros/month annually) may be needed.

AI and Failure Costs

• The AI step adds significant cost and complexity, sometimes billed separately.
• Zapier bills AI differently. Make bills AI tokens through them or directly if using your own provider.
• Failures (e.g., AI misreading, duplicate invoices) can incur full billing cycles on Zapier and Make if not handled carefully. Replaying runs incurs costs again.
• n8n's cloud has a limit on concurrent runs; queued runs might not be retried easily.

Hidden Costs and Considerations

• Polling Frequency: Frequent checks on Make or n8n can significantly increase costs, potentially exceeding invoice processing costs.
• Self-Hosting n8n: Free for the community edition but incurs costs for servers, maintenance, and staff time.
• Human Review: The time spent by a person reviewing AI extractions and approving bills is a significant, unpriced cost.
• Overage Costs: Exceeding limits on Zapier incurs higher per-task rates and can pause workflows.
• AI Provider Bills: If using your own AI, remember to account for separate bills from those providers.

Conclusion and Recommendations

• Zapier: Clear billing, least setup, highest cost per invoice.
• Make: Lowest cloud price at this volume, requires tuning polling.
• n8n (Self-hosted): Cheapest on paper if maintaining a server is feasible.
• Key advice: Count actions per invoice, understand trigger billing for empty checks, set the slowest viable polling interval, budget for AI and human review.

Workflow Setup

• Utilizes n8n, Google Sheets, and Gmail for daily AI news automation.
• Uses a scheduled trigger to define the newsletter sending time (note: UTC time zone).

Data Fetching and Filtering

• Connects to Google Sheets to fetch topics.
• Filters rows where the 'Status' column is 'not done'.
• Uses a 'limit' node to select only one item (topic) at a time.

AI Integration

• Integrates with an AI agent (e.g., OpenAI).
• Demonstrates the use of 'memory' to retain context within the AI agent for subsequent interactions.

Email Sending

• Configures Gmail to send emails.
• Sends a newsletter with a custom subject and content generated by the AI agent.

Status Update

• Updates the Google Sheet, marking the sent topic's 'Status' as 'done'.
• This prevents the same topic from being sent again.

Webhooks Explained

• Webhooks act like a doorbell, notifying n8n when an event occurs in another application, instead of n8n manually checking.
• To set up a webhook in n8n, configure the Set node to use the POST method.
• Once listening, the webhook node will trigger when an application sends data to the provided URL.

Data Formats: Objects and Arrays

• Objects are data structures enclosed in curly brackets {}, containing key-value pairs (e.g., {"name": "value"}).
• Arrays are collections of objects, enclosed in square brackets [], used when there are multiple instances of an object (e.g., [{"customer": "A"}, {"customer": "B"}]).

Data Mapping in n8n

• n8n allows mapping specific data fields from incoming webhook data to fields in your workflow.
• Example: Mapping the total cost of an agent's call by navigating through the call data object (duration, latency, call cost).
• Other data points like call summary and voicemail can also be mapped.
• Incoming webhook data is typically in JSON format, which n8n interprets as dictionaries (objects) and lists (arrays).

Automated Client Acquisition System

• The video introduces a 100% automated system to find and connect with clients using AI, focusing on Part 2 which utilizes n8n.
• The system aims to automate the entire process from finding leads to pitching, eliminating the need for manual effort and coding.
• The core idea is to use AI to research potential clients, identify their pain points, and craft personalized connection requests and messages.

AI Integration and Workflow

• The system uses AI, like "Cloud Code," to gather client information and pain points, suggesting what kind of note or pitch to send.
• Instead of manual work, the AI handles research and preparation, even for crafting the initial connection requests.
• The workflow starts with a scheduled trigger (e.g., 9:00 AM) to initiate the client outreach process.

Targeting and Outreach Strategy

• The system focuses on reaching clients in "rich countries" (e.g., US, Canada) and avoids clients from Pakistan or India.
• It emphasizes connecting with potential clients on multiple platforms, including LinkedIn, websites, Gmail, and WhatsApp.
• A key strategy is to send a friendly connection request ("note") first, rather than a direct sales pitch, to "open the door."

WhatsApp as a Primary Channel

• WhatsApp is highlighted as the most effective platform for quick responses and direct client communication, more so than LinkedIn or Gmail.
• The system can integrate with WhatsApp to initiate conversations or even handle appointment bookings via a chat agent.

n8n and MCB Server

• n8n is used for automation, with the possibility of integrating with MCB Server for extended capabilities if n8n's limits are reached.
• Users can describe their desired automation idea, and the AI (via MCB Server) can build it for them.
• The video references a previous video for details on connecting the MCB Server.

API Key Acquisition (Places API)

• The video explains how to obtain an API key for the Places API from Google Cloud Platform (console.cloud.google.com).
• Steps include enabling the Places API, navigating to "APIs & Services" > "Credentials," and creating an API key.

Client Profile Analysis and Connection

• The AI analyzes client profiles to identify potential opportunities, such as a clinic owner with 20 years of experience who might need website automation.
• The system aims to send personalized connection notes, avoiding direct pitches initially.
• The AI can identify potential clients who might benefit from services like website creation or booking automation.

Future Steps and Personalization

• The next video is promised to focus on building personal AI skills and how to share them.
• It will cover how to work with clients after the connection request has been accepted.

Claude Sonnet 5.5 Game Development

• Claude Sonnet 5.5 was tested by generating a 3D game with a single prompt.
• The game created was similar to the previous Oppo 5.5 video, featuring a Pune auto-rickshaw theme.
• The AI generated assets like trees, electric poles, road chunks, shops, and details like awnings and signboards.
• It also created auto-rickshaw and scooter models, vessels for a tea stall, and engine audio automation.
• The entire game was built in a single HTML file from one prompt without manual coding.

Performance and Comparison

• Sonnet 5.5 showed improvements in speed compared to previous models.
• In agentic coding benchmarks, Sonnet 5.5 performed slightly better than Oppo 5.5 in some areas, but Oppo 5.5 generally led.
• Sonnet 5.5 is significantly more affordable than Oppo 5.5.
• The generated game was playable and fun, with a new high score achieved.
• However, for design perspective and presentation quality, Oppo 5.5 was preferred by the creator.
• The generated auto-rickshaw model in Sonnet 5.5 was noted as less realistic compared to Oppo 5.5.

Future Testing

• The creator plans to conduct more extensive testing on Sonnet 5.5 to fully assess its capabilities.
• A side-by-side comparison with Oppo 5.5 was provided to highlight the differences.

AI Agent Definition

• An AI agent is a brain (language model) with hands (tools).
• It operates in a loop: think, use tool, read results, decide next step.
• Agents decide which steps to take, unlike fixed workflows.

Building the Agent

• Requires N8N (workflow automation), Ollama (local LLM hosting), and a Gmail connection.
• Running locally: no data sent to companies, no per-message cost.
• Model used: Qwen 3.5 9B, run via Ollama command: Ollama pull Qwen 3.5 9B.

Agent Setup in N8N

• Triggers: Schedule (daily briefing), Gmail trigger (customer emails), chat (ad-hoc requests).
• Instructions: Clearly define agent's role and constraints (e.g., "You're my assistant for my coffee shop...").
• Brain: Ollama chat node configured with local model (e.g., 127.0.0.1:11434), increased context size (16,000 tokens).
• Hands (Tools): Read inbox, check weather, access FAQ, Wikipedia lookup, send email, reply to customer, draft email.
• Key Instruction: "When a task says to email me or send me something, send it with send an email, never just write it in the chat."

Agent Jobs & Results

• Morning Briefing: Delivered daily at 7:00 AM, includes email summaries, weather, and delivery info. (Completed in 23 seconds).
• Customer Emails: Answers shipping queries accurately from FAQ within 10.5 seconds.
• Uncertain Queries: Uses "draft for me" tool for complex requests (e.g., custom orders) to allow manual review before sending.
• Call Briefing: Provides quick company research (e.g., Shopify) via email before scheduled calls. (Completed in 15 seconds).

Key Takeaways

• Describe tools clearly for the agent to select them effectively.
• Spell out actions precisely, especially for sending emails.
• Use the drafting tool for uncertain responses to maintain safety.

AI Agent Setup

• N8N is used to build a 24/7 WhatsApp AI agent.
• The agent can answer customer queries, take orders, and provide business information.
• Gemini (specifically Gemini 2.5 Flash) is used as the AI chat model.
• The workflow utilizes Google Sheets for inventory, order management, and FAQs.

Workflow Configuration

• Trigger: "On chat message" (initially) and later "On message" from WhatsApp Business Cloud.
• AI Agent: Connects to Gemini for responses.
• Memory: Simple memory is configured with a context window of 50 messages.
• Tools: Google Sheets are connected for "Inventory", "Orders", and "FAQ" sections.
• Orders: The "Orders" sheet is set to "append row" and AI is used to manage columns like customer name, item, quantity, etc.

WhatsApp Integration

• WhatsApp Business Cloud is integrated using "On message" trigger.
• Meta for Business is used to create an app to obtain Client ID and Client Secret.
• WhatsApp API setup is required to get an Access Token and Business ID.
• The "Send message" node is used to send responses back to WhatsApp.
• The AI agent's output is connected to the "Send message" node's text body.
• A system message with custom instructions about the business is provided to the AI agent for professional responses.
• The memory node is updated to work with WhatsApp messages.

Demo and Testing

• A demo showcases the bot handling menu inquiries and order taking for a restaurant.
• The bot successfully remembers previous conversation details (like name) due to the memory configuration.
• The workflow is tested by sending messages to WhatsApp and receiving AI-generated responses.
• The final workflow connects the WhatsApp trigger directly to the AI agent and the "Send message" node.

Server Setup

• Rent a low-cost VPS (e.g., Hetzner CX23 for ~$6/month).
• Install Docker and Docker Compose on the VPS using their official script.
• Connect to the VPS via SSH using the provided IP address and root password.

n8n Installation

• Create a directory for n8n and a docker-compose.yml file.
• Specify a fixed, non-latest version of n8n (e.g., 2.41.0).
• Generate a strong, unique N8N_ENCRYPTION_KEY for securing credentials and save it securely.
• Define a volume for n8n_data to persist workflows separately from the container.
• Start n8n using docker compose up -d.

Access and Security

• Access n8n via HTTP://YOUR_SERVER_IP:5678.
• Crucially, create the owner account immediately upon first access to secure the instance.
• Ensure port 5678 is open in the VPS firewall.

Cost and Maintenance

• Self-hosting n8n on a $6/month VPS offers unlimited runs compared to n8n Cloud's $24/month for 2500 runs.
• User is responsible for updates and backups.
• Monthly updates involve changing the version in docker-compose.yml and running docker compose pull and docker compose up -d.

Understanding n8n Chain Nodes

• Chain nodes in n8n combine AI components for cohesive systems, setting up sequences of calls that can include large language models (LLMs).
• Key Difference: Chain nodes are NOT the same as LangChain instances (AI agents). Chain nodes lack memory, meaning they don't remember previous interactions. AI agents, however, can have memory for conversational context.
• Chain nodes are found under "Advanced AI" and cannot have memory added, unlike AI agents.

Types and Functionality of Chain Nodes

• Examples include: Basic LLM Chain, Information Extractor, Question and Answer Chain, Sentiment Analysis, Summarization Chain, and Text Classifiers.
• Information Extractor: Extracts relevant information using a predefined system prompt. It's limited to one job and cannot have tools added.
• Summarization Chain: Splits input text into chunks and summarizes it. It's a simple, single-function node.
• Chain nodes are useful for basic, single-function tasks where memory is not required.
• AI agents offer more robust functionalities, decision-making abilities, and the use of tools, making them better for complex workflows.

Utilizing n8n Features

• Many chain nodes offer example workflows: click "save time with an example" to access templates that demonstrate their usage.
• These examples can be imported to examine how specific nodes are used in automation.

Next Steps

• The video will further explore AI agent nodes, detailing their differences from chain nodes and showcasing various types of AI agents.

Workflow Setup

• The workflow is triggered by a new email arriving in Gmail.
• N8N automatically sends the email content to an AI agent.
• The AI agent generates a professional response.
• Gmail then sends the AI-generated reply.

N8N Configuration

• A Gmail trigger node is configured to watch for new emails.
• An AI agent node is added, connected to an AI model.
• System instructions define the AI agent's role as a professional email assistant, with rules to avoid inventing information.
• The sender, subject, and email body from the Gmail trigger are passed to the AI agent.
• Another Gmail node is configured to reply to the original email using the message ID.
• The AI agent's generated response is used as the message body for the reply.

Enhancements and Safety

• A human approval step can be added before sending the email.
• This allows for review of sensitive or important emails, making the workflow safer for business use.
• The final workflow can either automatically send the AI response or route it for human approval.

General AI Assistance

• ChatGPT: Chats, writes, explains, reads files/images. GPT 5.6 family released. Tip: State goal and audience.
• Claude: Natural writing, handles long docs. Opus 4.8 available. Tip: Upload PDF, ask for key points simply.
• Gemini: Integrates with Google apps. Tip: Draft using your documents.
• Microsoft Copilot: Integrates with Windows, Office. Tip: Summarize email threads.

Research Tools

• Perplexity: Answers questions with sources. Tip: Check cited sources.

App Building & Coding

• Lovable: Builds web apps from chat descriptions. Tip: Start small, add features incrementally.
• Cursor: AI code editor. Cursor 3 allows multiple AI agents. Tip: Ask it to explain code before editing.
• Bolt: Builds/runs in-browser apps. Tip: Clearly describe pages and buttons.
• V0 by Versal: Generates web pages/app screens from prompts. Tip: Use design screenshots as reference.

Image Generation

• Midjourney: Creates artistic images. Tip: Add style words (e.g., watercolor).
• Idog: Adds clear text to images. Tip: Use quotation marks for exact text.
• Google Image Generation (within Gemini): Tip: Describe light, place, camera angle.

Video Generation

• VO3.1: Creates short cinematic video clips with sound. Tip: Describe shot, action, desired sound.
• Cling: Turns text/images into video. Tip: Start with a strong image.
• Synthesia: Creates videos with AI presenters from scripts. Tip: Keep scenes to one idea.
• Runway: Video generation and editing. Tip: Use short prompts, improve step-by-step.

Voice & Audio

• 11 Labs: Natural voices, video dubbing. Tip: Use punctuation for pauses.
• Hume: Emotionally expressive voice AI. Tip: Describe desired emotion.
• Speechify: Reads text aloud. Tip: Gradually increase speed.

Automation & AI Agents

• Zapier: Connects apps, automates tasks. Tip: Automate one boring task first.
• N8: Visual workflows, AI agents, self-hostable. Tip: Use templates.
• Lindy: AI assistants for email, meetings, calendar. Tip: Provide clear rules.
• Botress: Builds chatbots/agents. Tip: Input FAQs first.

Notes & Knowledge Management

• NotebookLM: Ask questions about uploaded documents. Tip: Try Audio Overview.
• Notion AI: Works within Notion. Tip: Turn notes into task lists.
• MEM: AI notes app that organizes thoughts. Tip: Capture thoughts, let AI sort.

2026 Updates & Getting Started

• New Releases: GPT 5.6, Claude Opus 4.8, Cursor 3, VO3.1, Grock 4.7, Perplexity Comet.
• Gemini 3.5 Pro: Announced, not yet public.
• How to Start: Pick one assistant, one job-specific tool. Use daily for two weeks. Always check facts.

Triggers

• Manual Trigger: Executes a workflow manually for testing or on-demand tasks.
• Schedule Trigger: Starts workflows at set intervals (seconds, minutes, hours, days). Useful for recurring tasks like social media posting.
• External Event Triggers: Integrates with third-party platforms like Typeform or Google Sheets to initiate workflows based on external events.

Data Storage and Management

• Data Table: n8n's built-in node for saving and retrieving data between workflow runs, similar to a spreadsheet.
• Google Sheets: Integrates with Google Sheets to append rows or perform other actions. Requires credential setup.

Universal Data Processing

• Edit Field (Set Node): Used to rename, add, or change fields, and structure data for cleaner output. Can combine multiple data points into a single structured output.
• Split Out Node: Splits a single input item into multiple separate items, useful for processing individual elements within a dataset.
• Aggregate Node: Combines multiple incoming data items into a single JSON object or list, performing a similar function to the Edit Field node.
• If Node: Routes data into two branches (true or false) based on a specified condition.
• Switch Node: Routes data to multiple branches based on various conditions, offering more routing options than the If node.
• Merge Node: Combines data from multiple branches into a single output.
• Loop Over Items: Allows operations to be repeated or sent back to an earlier stage in the workflow.

Code and Connectivity

• Code Node: Allows writing custom code (JavaScript, Python) to perform complex operations or logic not covered by existing nodes.
• HTTP Request: Connects to external web APIs to fetch or send data, enabling interaction with services that don't have dedicated n8n nodes.
• Webhook: Listens for incoming data from external platforms and pushes it to n8n automatically. Often used with services like Postman for testing.

AI Integration

• OpenAI Node: Direct integration with OpenAI models for tasks like generating text.
• AI Agent Node: A more advanced node that allows selection from various AI models (Anthropic, Google Gemini, etc.) and supports adding memory and tools (like Gmail, calculators) to create intelligent agents. This is recommended for most AI tasks.

What is an AI Agent?

• An AI agent is a system that can reason, plan, and take actions based on given information.
• It differs from automation, which follows predefined, static steps. Agents are dynamic and capable of reasoning.
• Key components: Brain (LLM), Memory (past interactions/context), and Tools (external interactions).

Components of an AI Agent

• Brain: The large language model (e.g., ChatGPT, Claude, Gemini) that handles reasoning and language generation.
• Memory: Allows the agent to remember past interactions and use context for better decisions.
• Tools: Enable interaction with the outside world (data retrieval, action execution, orchestration). Examples include Gmail, Google Sheets, APIs.

Building Your First AI Agent (No-Code)

• The video uses the platform NADN for building agents visually without coding.
• NADN has a dedicated AI agent node that integrates the Brain, Memory, and Tools.
• A practical example involves building a personalized trail running recommendation agent.

Agent Development Steps

• Trigger: Set up a schedule (e.g., daily at 5 AM) to run the agent.
• AI Agent Node: Add the core agent node.
• Brain Setup: Connect an LLM (e.g., OpenAI's GPT-4 Mini) by adding API keys.
• Memory Setup: Configure memory for context (e.g., remember last 5 messages).
• Tools Integration:
  • Connect Google Calendar to check schedule.
  • Connect OpenWeatherMap API for weather data.
  • Connect Google Sheets for trail information.
  • Connect Gmail to send recommendations.
  • Use HTTP requests for custom APIs (e.g., AirNow.gov for air quality).
• Prompt Engineering: Define the agent's role, task, available inputs, tools, constraints, and desired output using a structured prompt.

APIs and HTTP Requests

• API (Application Programming Interface): How software systems communicate and share information (like a vending machine interface).
• HTTP Request: The actual action of interacting with an API (e.g., GET to retrieve data, POST to send data).
• NADN simplifies tool integration, but custom tools can be built using HTTP requests to any public API.

Testing and Refinement

• Test the workflow to identify and fix errors.
• Use ChatGPT to help debug errors by providing screenshots and explanations.
• Refine prompts and tool configurations for desired output and functionality.
• The agent can be tested via chat interface within NADN or through integrated communication channels.

Foundational Understanding of AI Agents

• AI agents are digital workers that understand instructions and take actions to complete tasks.
• Key components: Large Language Model (LLM) as the brain, prompting for behavior, memory, optional external knowledge, and tools for actions.
• Focus on three core ingredients for building: prompting, knowledge, and tools.
• Understanding APIs (Application Programming Interfaces) is crucial for how agents use tools online.

AI Agent Capabilities and Applications

• Tools transform agents from chatbots to action-takers, interacting with software via APIs.
• Tools can be pre-made integrations or custom-built.
• Schemas act as instruction manuals for agents to use APIs.
• Agents can combine multiple tools to solve complex problems, with advanced models enabling planning, action, reflection, and replanning.
• Two main categories: conversational agents (direct human interaction) and automated agents (triggered by events or schedules).
• Real-world use cases include co-pilots for specific roles, lead generation, appointment setting, and research agents.

Building AI Agents (Tutorials)

• Build 1: Sales Co-pilot (Relevance AI) - Created custom research tools (company researcher, prospect researcher, pre-call report generator) to prepare sales reps for calls.
• Build 2: Automated Lead Qualification (N8N) - Built a workflow triggered by form submissions to research leads, qualify them, and notify the appropriate sales rep or send a rejection email. Reused the Relevance AI researcher tool.
• Build 3: Website & Phone Agent (Voiceflow) - Developed a conversational agent capable of answering questions from a knowledge base, generating instant quotes using a Relevance AI tool, and capturing lead information. Deployed as both a website chat widget and a voice agent accessible via phone.
• Build 4: WhatsApp Agent (Agentive) - Created a WhatsApp-based agent using Agentive (built on OpenAI's Assistants API) with a knowledge base, quote generation tool (Relevance AI), and lead capture to Airtable.

Monetizing AI Agent Skills

• Opportunity lies in helping businesses implement AI, not necessarily building revolutionary tech.
• Services include:
• Education: Teaching businesses about AI and its applications.
• Consulting: Analyzing business operations to identify AI solutions.
• Implementation: Building and deploying AI systems for businesses.
• A significant market gap exists for AI services, especially for small to medium-sized businesses.
• Build your knowledge gap by practicing with more agents (e.g., via the free course on School) and choosing a monetization path (building, educating, or consulting) based on your interests.
• Strategies for getting clients: warm outreach and content creation (community content flywheel).

• Summary unavailable

Course Structure and Foundations

• The course covers the opportunity in AI agents, foundational n8n setup, UI familiarization, and step-by-step workflow builds.
• Topics include APIs, HTTP requests, AI agent tools, memory, multi-agent architectures, prompting, webhooks, self-hosting n8n, and lessons learned from building AI agents.

Understanding AI Agents vs. Workflows

• AI Agents: Possess a 'brain' (LLM + memory) and instructions (system prompt) to make autonomous decisions and act using tools. Suitable for non-deterministic or unpredictable processes.
• AI Workflows: Follow predefined, linear steps with integrated tools. More reliable, cost-efficient, easier to debug, and scalable for deterministic processes.
• The course emphasizes building workflows before agents ("crawl, walk, run").

Getting Started with n8n

• Sign up for a free 14-day trial of n8n.
• Familiarize with the n8n dashboard: overview, projects, credentials, and admin panel.
• Understand workflow triggers (manual, scheduled, webhooks, etc.) and nodes (actions, data transformation, AI).
• Learn about JSON data format and its importance in n8n and LLMs.
• Difference between active and inactive workflows.
• Understanding data types: string, number, boolean, array, object.

Building AI Workflows (Step-by-Step Examples)

• RAG Pipeline and Chatbot: Integrates Google Drive, Pine Cone (vector database), and Open Router (for various LLMs) to create a retrieval-augmented generation system.
• Customer Support Workflow: Uses Gmail triggers, text classification (AI node) to route emails, and an AI agent with a Pine Cone knowledge base to draft and send automated email responses.
• LinkedIn Content Creation: Automates content generation by using Google Sheets for topics, Tavi (web search API) for research, an AI agent for writing posts, and updating the Google Sheet with the results.
• Invoice Processing Workflow: Uses Google Drive triggers, PDF text extraction, an AI information extractor for specific fields (invoice number, client details, dates, amount), updates a Google Sheet database, and crafts/sends emails to a billing team using AI.

APIs and HTTP Requests

• APIs (Application Programming Interfaces) allow systems to communicate.
• Native integrations in n8n are essentially pre-configured HTTP requests.
• Use HTTP Request nodes when a native integration is unavailable.
• Key components of API documentation and HTTP requests: Method (GET, POST), Endpoint (URL), Query Parameters, Header Parameters (for authorization/API keys), and Body Parameters (data sent in the request).
• Emphasis on using `curl` commands to import API configurations into n8n for ease of setup.
• Demonstrates setting up HTTP requests for Perplexity (web search), Firecrawl (web scraping/data extraction), and Apify (web scraping marketplace).
• Explains common HTTP error codes (400, 401, 404, 500) and how to debug them.
• Covers setting up API keys as generic credentials in n8n for reusability.
• Demonstrates creating images with OpenAI's DALL-E API and videos with Runway's API by handling binary data and base64 encoding.

Agentic Frameworks and Prompting

• Workflows vs. Agents: Reinforces that workflows are for deterministic tasks, while agents are for non-deterministic tasks requiring decision-making.
• Agent Components: Input, Agent (LLM + Memory), Tools, System Prompt (Instructions).
• Multi-Agent Systems: Discusses orchestrator/sub-agent architecture for complex tasks, allowing specialization and reusability. Frameworks include prompt chaining, routing, parallelization, and evaluator-optimizer loops.
• Prompting Methodology: Emphasizes reactive prompting (start small, observe errors, fix incrementally) over proactive prompting (writing a large prompt upfront).
• Key Prompt Components: Overview (Role/Purpose), Tools (Description & When to Use), Rules/Instructions, Examples (for correcting errors), Final Notes.
• Memory Management: Simple memory vs. external databases (Postgres via Superbase) for storing conversation history. Session IDs are crucial for multi-user/multi-conversation contexts.
• Output Parsing: Using structured output parsers (JSON schema) to ensure agents provide data in a usable format for subsequent nodes.
• Human in the Loop: Implementing steps where the workflow pauses for human feedback (approval/denial or text-based input) to refine outputs or confirm actions.
• Error Workflows: Setting up a dedicated workflow to capture and log errors from active workflows, sending notifications via Slack or Google Sheets.
• Dynamic Model Selection: Using a model selector agent (via Open Router) to choose the most cost-effective or suitable LLM based on the input query's complexity.
• MCP Servers: Explains Model Context Protocol servers as a standardized way for agents to interact with tools, providing schema and resource information. Demonstrates self-hosting n8n and connecting to community MCP nodes (e.g., Airbnb, Brave Search) and discusses limitations.
• Lovable Integration: Building a front-end web app with Lovable that communicates with n8n via webhooks for backend AI processing (e.g., generating excuses).
• Lessons Learned: Build workflows first, wireframe before building, context is crucial, vector databases aren't always needed, prompting is critical (reactive vs. proactive), scaling agents is complex, and no-code tools have limitations.

Introduction to n8n

• n8n is a powerful, open-source, no-code workflow automation tool.
• The course aims to teach practical business applications of n8n for revenue generation and cost savings.
• It covers setting up n8n, understanding its interface, and building workflows from scratch.

Getting Started with n8n

• Sign up for n8n cloud is recommended for beginners due to ease of setup.
• The n8n interface features a canvas for building workflows, nodes for actions/triggers, and credentials for app connections.
• Key features include projects for organization, a template library with pre-built workflows, and an AI assistant for help.
• Self-hosting options (Render, Railway, Digital Ocean, Heroku, Docker) are discussed for cost savings and data privacy.

Building Your First n8n Workflows

• Workflow 1: Manual Trigger & Email Sending
  • Starts with a manual trigger.
  • Connects to Gmail using OAuth2 for authentication.
  • Sends a personalized email using dynamic data.
  • Demonstrates testing steps and understanding node input/output.
• Workflow 2: Form Submission & AI Autoresponder
  • Uses a form submission as a trigger.
  • Collects user data via a custom form (name, email, phone).
  • Integrates with OpenAI (GPT-4o) to process data and generate a personalized email response.
  • Explains API key connection for OpenAI and prompt engineering (system prompt, user prompt).
  • Shows how to pin data for easier testing and reuse across nodes.
  • Includes a 120-second delay node before sending the final email.
  • Demonstrates activating a workflow for live use.
• Workflow 3: Calendar Booking & CRM Integration
  • Triggers on a booking created via Cal.com (using API key authentication).
  • Sends a personalized HTML email reply to the booked person.
  • Demonstrates date formatting using Luxon datetime functions (add, subtract, diff, extract, format).
  • Integrates with ClickUp (CRM) via API key to create a task with booking details.
  • Explains handling custom fields in ClickUp using JSON format.
  • Shows referencing data from multiple nodes back using specific syntax ($`).

n8n Functions and Data Handling

• Fields: Differentiates between fixed fields (static values) and expression fields (dynamic values using JavaScript/n8n syntax). Advocates for using expression fields.
• JSON: Explains JavaScript Object Notation (keys, values, data types like string, number, boolean, array, object), and how data is represented in n8n (array of objects).
• Core Functions: Covers manipulation of strings (includes, split, startsWith, endsWith, replaceAll, length, base64 encode/decode, concat, extract domain/email/URL, hash, quote, remove markdown/tags, slice, trim, URL encode), numbers (round, floor, ceil, absolute, format), arrays (length, last, first, includes, append, chunk, compact, concat, difference, intersection, find, indexOf, lastIndexOf, match, push, remove, replace, reverse, slice, unique, join, map, filter, reduce), objects (keys, values, isEmpty, hasField, compact, keepFieldsContaining, removeField, toJSON string, URL encode), booleans (toNumber, toString), datetimes (format, add, subtract, diff, extract, startOf, endOf, components, zone, isWeekend), and custom logic.
• Flow Control Nodes: Explains nodes like 'if' (conditional branching), 'filter' (data filtering), 'merge' (combining data streams), and 'split into batches'/'loop over items' (iterating over data).
• Advanced Concepts: Covers HTTP requests (GET, POST), webhooks (receiving data), OpenAI integrations (message model, AI agents), and using JavaScript/functions within n8n for complex data transformations.

n8n vs. Make.com Comparison

• Module Availability: Make.com has a wider range of native integrations.
• JSON & Code Integration: n8n excels with native JavaScript/expression support.
• Flow Control: n8n offers superior flow control with built-in if statements, loops, merge, filter, and error handling.
• Testing: n8n's data pinning feature significantly simplifies workflow testing compared to Make.com's manual API calls.
• Connections: Make.com generally has simpler, one-click authentication for services; n8n can be more complex, requiring manual API setup.
• Webhooks & Mailhooks: Make.com is considered superior for ease of use and setup, especially with its mailhook feature.
• AI Features: n8n has strong native AI integrations (AI agents, chat interfaces, tool usage), while Make.com requires more manual setup.
• Sharing & Collaboration: n8n offers better template sharing and importing via URLs/copy-pasting, with a richer template library.
• Hotkeys & Documentation: n8n has excellent built-in hotkeys and inline documentation, enhancing usability.
• Financials: n8n is free if self-hosted (cost of server only) and scales affordably. Cloud plan is $24/month for limited workflows. Make.com is more accessible initially ($0 free plan, $10.59/month for core) but scales expensively with operations (modules).
• Recommendation: Make.com is better for simpler tasks and less technical users. n8n is superior for complex, operationally intensive, and AI-focused workflows, especially with self-hosting.

Conclusion and Next Steps

• The course provides a comprehensive understanding of n8n, from basic setup to advanced functions and self-hosting.
• The emphasis is on practical application for business value and revenue generation.
• Encourages viewers to practice and utilize the knowledge gained.
• Promotes the "Maker School" community for further development of automation business skills, offering a roadmap, accountability, templates, and coaching.

What is n8n?

• n8n is presented as a free, open-source, and self-hostable alternative to Zapier.
• It allows users to create automation workflows by connecting various input triggers (e.g., website forms, databases, GitHub issues) to a series of steps involving third-party apps or custom code.
• Workflows are designed using a visual, flowchart-style editor, making them accessible to non-technical users.

Use Cases and Examples

• Developers: Trigger workflows on GitHub PR merges to build Docker images and notify on Discord.
• YouTubers: Automatically share new video content across social media platforms.
• IoT Enthusiasts: Set up alarms triggered by smart cameras detecting law enforcement.
• Gamblers: Scrape football stats and use AI for bet suggestions.
• Personal Automation: Trigger a workflow when a specific message is received on Telegram.

Getting Started and Deployment

• n8n can be run locally for testing via the command `npx n8n` in the terminal.
• For serious use, self-hosting on a VPS is recommended.
• The video demonstrates deploying n8n on a Linux VPS provided by Hostinger, using a pre-built Ubuntu template with n8n pre-installed.
• The cost for a VPS is shown to be around $5 per month.

Building a Workflow

• Workflows start with a trigger node, which can be manual, scheduled, or connected to a third-party app (e.g., Telegram).
• Data from the trigger can be processed through subsequent nodes, including:
• AI nodes for analysis or generating content (e.g., apology letters) using custom prompts and models.
• Conditional logic nodes (if/else statements) to handle different scenarios based on data.
• Custom code nodes for executing arbitrary code or API calls.
• Integration with various apps for actions like ordering flowers or posting to X (formerly Twitter).
• Workflows can also log interactions to platforms like Google Sheets.

Introduction to n8n and WhatsApp Automation

• Demonstrates a WhatsApp automation bot for a restaurant, handling orders, inquiries, and confirmations without manual intervention.
• Highlights the potential for earning by offering this service to local businesses.
• Explains that the fundamentals learned can be applied to various automations beyond WhatsApp, such as email, social media, and CRM.

Setting up n8n and Basic Bot Functionality

• Explains how to set up n8n, an open-source automation tool.
• Covers different trigger types: manual, on app event, and on a schedule.
• Focuses on using "on chat message" as the trigger for this project.
• Introduces connecting an AI agent (using Gemini as the LLM) and the necessity of an API key to bridge n8n and the AI model.

AI Agent Capabilities: Memory and Tools

• Explains the concept of "memory" in AI agents, allowing them to retain conversation history.
• Demonstrates connecting to a Google Sheet as a database with "Inventory," "Orders," and "FAQ" sheets.
• Shows how to use "Tools" in n8n to interact with the Google Sheet, retrieving inventory and answering FAQs.
• Details setting up the "Orders" sheet to append new order data, using AI to prompt the user for necessary information (name, quantity).
• Includes a JavaScript expression for automatically adding the order date.
• Addresses a flaw where the bot accepted orders for out-of-stock items and shows how to fix it by adding system instructions to the AI agent, enforcing inventory rules.

Integrating WhatsApp Business

• Details the process of integrating WhatsApp Business with n8n.
• Requires setting up a Meta for Business account and creating an App ID.
• Explains how to obtain Client ID and Client Secret from Meta.
• Covers setting up the WhatsApp Business API, including generating an access token and business account ID.
• Troubleshoots common issues like missing country codes in phone numbers.
• Connects the AI agent's output to the WhatsApp "Send Message" node for bot replies.
• Tests the complete WhatsApp integration, showing the bot responding to messages sent via WhatsApp.

AI Agent Setup and Hosting

• Introduces "Terry," an AI agent built with n8n, designed to monitor, troubleshoot, and fix home lab issues.
• Recommends self-hosting n8n in the cloud (e.g., via Hostinger using coupon code "network chuck") for reliability, immune to home lab tinkering.
• Suggests using TwinGate for secure remote access to the home lab.

Core Functionality: Monitoring and Basic Troubleshooting

• Terry is initially taught to monitor a website by using an HTTP request tool.
• Demonstrates how to give Terry tools and a system prompt to define his role (IT administrator).
• Introduces an SSH tool (as a sub-workflow) to allow Terry to execute commands on the server.
• Teaches Terry to troubleshoot by checking Docker container status using docker ps.
• Terry's troubleshooting capabilities are expanded to include docker inspect and checking logs based on prompt updates.

Automation and Fixing Capabilities

• Terry is automated using a schedule trigger (e.g., every 5 minutes) instead of manual chat prompts.
• Introduces "Set Field" nodes to provide Terry with a prompt and a chat ID for scheduled tasks.
• Terry is configured to send notifications (via Telegram in the example) only when issues are detected.
• Implements "structured output" to allow for conditional logic (e.g., only notify if the website is down).
• Terry is taught to fix issues, starting with restarting a Docker container when a website is down.

Advanced Troubleshooting and Human-in-the-Loop

• Tests Terry's ability to troubleshoot novel issues, like a port conflict, by updating his prompt to use a generic "CLI tool."
• Highlights the need for a "human-in-the-loop" system for safety and control.
• Configures Terry to request explicit approval before running potentially critical commands via Telegram.
• Explains how to set up the approval workflow, including using "if" nodes and "Set Field" nodes to manage the approval state and context.
• Introduces a "switch" node for more granular notification logic (e.g., notify if a fix is applied or if the website is down).

Integration with Home Lab Services

• Demonstrates connecting Terry to real home lab services like UniFi (using its API), Proxmox (via SSH), and Plex (via API).
• Terry is given personas (e.g., Network Engineer) and tasks like identifying bandwidth hogs or checking VM status.
• Emphasizes that this setup is a starting point to spark ideas for integration with other services like NAS devices.

Future Development and Limitations

• Acknowledges limitations: Terry needs help (suggests sub-agents), documentation is crucial, and a help desk system is needed.
• These future steps (sub-agents, documentation, help desk) will be covered in subsequent videos.
• Encourages viewers to build their own Terry, start simple, and share their experiences.

Introduction to n8n

• n8n is an open-source workflow automation platform for integrating APIs and orchestrating workflows without extensive coding.
• The course covers foundational concepts like nodes, architecture, data types, and how workflows run.
• It includes configuring API keys for services like OpenAI and Anthropic.

AI Agent Workflows

• Build AI agents for tasks like auto-replying to emails and multi-agent research.
• Utilize the HTTP request node for API interactions, web scraping, and external tools.
• Explore creative workflows for text-to-image and text-to-video generation using models like Google's V3 and Canon.
• Create a Slack workflow where AI can reply to messages on your behalf.

Retrieval Augmented Generation (RAG) and Advanced Concepts

• Implement RAG agents using vector databases like Pinecone for context and memory.
• Build a customer support RAG agent for intelligent, context-aware support.
• Understand MCPs and their comparison to traditional workflows for reusability and scalability.
• Orchestrate enterprise-style systems by combining multiple agents using sub-workflows.
• Learn about retries, error handling, best practices, and using the workflow template marketplace.

n8n Foundations and AI Agents

• n8n (notation) is a free, open-source tool for connecting apps and services visually using nodes.
• Workflows have trigger events and action nodes.
• AI agents in n8n use an LLM (like OpenAI, Anthropic), a context window/memory, and tools (like Gmail, web scrapers).
• Workflows can run sequentially or in parallel branches.
• Memory types include short-term context memory (for chat history) and long-term vector database/document RAG memory.

Data Handling and Expressions

• Nodes have input and output panels displaying data payloads.
• Data representations include schema, table, and JSON formats.
• Expressions allow dynamic data pulling from earlier nodes, unlike fixed values.
• n8n supports five data types: strings, numbers, booleans, arrays, and objects.
• Community nodes extend n8n's capabilities beyond official integrations.

Building an AI Email Agent

• Start with a trigger node (e.g., on chat message).
• Add an AI agent node, connecting it to an LLM (e.g., OpenAI GPT-4.1).
• Configure memory (e.g., simple memory) for conversational context.
• Attach tools like Gmail for specific actions (e.g., sending emails).
• Use system and user messages to guide the AI agent's behavior.
• Expressions are crucial for dynamic inputs in prompts.
• Learn to activate workflows for production and make them publicly available via a URL.

API Keys and Hosting Options

• Obtain API keys from providers like OpenAI or use platforms like CodeCloud Keyspace for unified access to multiple LLMs.
• Understand how to connect to LLM APIs using base URLs and API keys.
• Compare n8n Cloud (simplicity, managed updates) vs. self-hosting (control, cost-effectiveness, custom integrations).
• Self-hosting can be done locally with Docker or on cloud instances like AWS EC2.
• Setting up Google Cloud Console for n8n involves creating projects, enabling APIs (Gmail, Drive, etc.), and configuring OAuth credentials.

Advanced Workflows and Tools

• Create an AI research agent that searches for AI news using Perplexity, checks against a Google Sheet log for duplicates, summarizes, and emails the findings.
• Use scheduled triggers for daily automation.
• Integrate Slack for AI to reply to messages and act on your behalf, requiring specific user token scopes and event subscriptions.
• Implement RAG by connecting an AI agent to a Google Doc for project updates.

HTTP Request Node and API Calls

• Use the HTTP request node to interact with external APIs not natively supported by n8n.
• Connect to public APIs (e.g., cat facts), weather APIs (OpenWeatherMap), and web scraping services (Firecrawl).
• Configure authentication using header-based methods with generic credentials for security and reusability.
• Handle complex API interactions involving POST requests for initiating tasks and GET requests for retrieving results, often with wait nodes and if loops for asynchronous processes.

Multimedia Generation Workflows

• Build text-to-image workflows using models like DALL-E via OpenAI and image generation platforms like W&B AI.
• Construct text-to-video workflows using models like V3 on platforms like W&B AI or Google Cloud Vertex AI.
• Develop image-to-video workflows that take an image and a text prompt to generate video content.
• These workflows often involve multiple API calls (POST for generation, GET for results), wait nodes, if loops for status checking, and base64 conversion for handling media data.

Sub-workflows and Error Handling

• Utilize sub-workflows to segment complex logic into reusable and manageable parts.
• The "Execute sub-workflow" node triggers another workflow, allowing data transfer between them.
• The "Execute by another workflow" trigger allows a workflow to be called as a sub-workflow.
• Configure data transfer between main and sub-workflows ("Accept all data" vs. "Define using fields below").
• Splitting workflows into smaller parts aids in troubleshooting and error isolation.

Conclusion and Next Steps

• Automation with n8n enhances productivity, extends AI capabilities, and frees up time for strategic tasks.
• Encouragement to build, experiment with new APIs, join the community, and apply automation to various business functions.
• Automation augments human capabilities rather than replacing them.

Workflow Fundamentals

• Triggers vs. Actions: Workflows start with a trigger that initiates the process, followed by actions that perform specific tasks.
• Data Items: Nodes process data in the form of items. Each node outputs an array of items, which can be zero to many. Most nodes perform their actions on each incoming item.
• Data Mapping & Transformation: Data from previous nodes can be mapped into the parameters of subsequent nodes. Expressions, enclosed in curly brackets `{}`, allow for dynamic data manipulation and use of helper functions like `$now` for date/time operations.

Building the Installation Request Workflow

• Trigger: On Form Submission A web form is used to kick off the workflow. Users fill out fields like email and preferred install date.
• Conditional Routing: If Node An "If" node routes the workflow based on a condition. In this case, it checks if the preferred install date is within seven days.
• Action: Slack Notification If the install date is within seven days, a message is sent to a specific Slack channel containing the user's contact information and preferred install date.

Advanced Techniques & Tips

• Pinned Data: To avoid repeatedly entering test data, node output can be "pinned." This allows for testing without re-executing the trigger step. Pinned data is not used in production.
• Workflow Annotation: Renaming nodes, especially conditional ones (e.g., phrasing as a question like "Is within seven days?"), improves workflow clarity.
• No Operation (NoOp) Node: A placeholder node that doesn't perform any action but can be used to mark future development points in the workflow.
• Credentials: Connecting to external services like Slack requires setting up credentials, which securely store API keys or OAuth tokens.
• Workflow Activation: After building and saving, workflows must be activated to run automatically. Production executions are distinct from test executions (marked with a beaker icon).
• Copying to Editor: A pro-tip allows unpinning current data and pinning data from a specific production execution, useful for troubleshooting and workflow evolution.