n8n Automation Videos & Summaries

Automated Lead Enrichment

• Transforms raw form submissions into enriched assets.
• Eliminates manual data entry and verification using API integrations (e.g., Hunter.io).
• Automatically scrapes the internet for company name, domain, social profiles, location, and industry.
• Validates email deliverability with a confidence score, discarding low-scoring leads.

Intelligent Data Routing and Prioritization

• Cross-references new leads with existing CRM data (e.g., Airtable) to prevent duplicate entries.
• Identifies VIP clients based on historical revenue data.
• Calculates lead value using a dynamic point-based algorithm considering email confidence, region, and industry.
• Routes leads based on their score: high value for direct outreach, medium for manager review, low for nurture sequences.

AI-Powered Automation

• Moves beyond rule-based automation to cognitive decision-making using Large Language Models (LLMs) like OpenAI's GPT.
• Enables workflows to understand context, reason through problems, and generate humanlike responses.
• AI can read and categorize emails (support tickets, sales inquiries, spam) based on sentiment.
• Automates context-aware draft responses and dynamic routing decisions.

Workflow Examples

• Generates personalized sales brief documents (Google Doc -> PDF) for high-value leads.
• Orchestrates automated handoffs: Slack alerts, welcome emails, follow-up emails, and calendar invites.
• Implements human-in-the-loop for medium-value leads with clickable approve/disapprove buttons in emails.

Introduction to Conditional Logic

• Conditional logic allows workflows to make decisions based on incoming data.
• This makes automation "smarter" by enabling different actions for different scenarios (e.g., urgent vs. non-urgent requests).

The IF Node

• The IF node acts like a fork in the road, checking a set condition.
• It directs data down one of two paths: true or false.
• Important: Conditions must match data exactly (case-sensitive).

Setting up the IF Node

• Added a "priority" field to the form (short answer type).
• Configured the webhook to use a test URL for testing.
• Filled out the form with "urgent" priority and captured the test event.
• Mapped the "priority" label from the form data into the IF node.
• Set the condition in the IF node to check if the "label" is equal to "urgent".

Testing Conditions

• Tested with "urgent" priority: The IF node outputted true.
• Tested with "not urgent" priority: The IF node outputted false.
• The true path was set to send an email.
• The false path was set to log details to a Google Sheet.

Switch Node (Alternative)

• For multiple conditions (more than true/false), the Switch node is recommended.
• The Switch node has multiple outputs, unlike the IF node's two.

Mapping and Publishing

• Ensured data was mapped correctly from the appropriate node (the IF node, not the preceding edit feed) to the subsequent nodes (email and Google Sheets).
• Published the workflow to a production URL after successful testing.
• The presenter experienced network/connection issues during live testing but instructed viewers on how to test and share results.

Introduction to n8n and AI Automation

• n8n is a platform for creating AI automations, similar to make.com.
• The tutorial uses a local, free version of n8n.
• To use n8n, you first need to install Node.js.
• AI automation involves using AI to perform tasks typically done by humans.

Building a Workflow in n8n

• Workflows in n8n connect different "nodes" (tools) to accomplish tasks.
• A workflow must start with a trigger (e.g., form submission, webhook, Slack).
• The tutorial demonstrates creating a form as a trigger.
• Form elements include name, email, phone number, age, and expected income, with specified data types (text, email, number).
• Data types are crucial for the computer to process information correctly.
• After form submission, the data is presented in JSON, table, or schema format.
• A mistake in data type (e.g., text for income) can cause errors.

Integrating with Google Sheets

• The next step is to connect the form submission to a Google Sheet using an "append row" action.
• This requires setting up credentials to link your Google account.
• A Google Sheet with appropriate column headers (Name, Email, Phone Number, Age, Expected Income) is created.
• Data from the form is dynamically mapped to the corresponding columns in the Google Sheet.

AI Lead Qualification with AI Agent

• An "AI agent" node is added to qualify leads based on age and expected income.
• The AI agent is prompted with a system message to evaluate leads based on these criteria.
• The AI provides a qualification status (qualified/not qualified) and a reason.
• The AI's output is initially a string and needs to be parsed into a structured format (JSON) using a JavaScript code node.
• The structured output can then be added back to the Google Sheet, including the qualification status.

Conditional Logic and Notifications

• An "if" node is used to create conditional logic based on the qualification status.
• If a lead is qualified (status is "qualify"), a notification is sent to a Slack channel and an email is sent to the client.
• If a lead is not qualified, a different email is sent to the client with a "better luck next time" message.
• Credentials need to be set up for Slack and email services.
• The tutorial shows how to send dynamic messages using data from previous nodes.

Deployment and Next Steps

• The workflow can be published with versioning.
• The current setup is a local version, requiring the computer to be on continuously.
• For broader use, a cloud version of n8n is recommended.
• Mistakes and getting stuck are part of the learning process.
• Additional resources and tutorials are available online.

Introduction to n8n

• n8n is a developer-friendly workflow automation platform, combining visual no-code ease with custom code control.
• It's a scalable, source-available, and self-hostable alternative to tools like Zapier and Make.
• Key use cases include building AI agents, RAG workflows, IT operations, back-end prototyping, and supercharging CRMs.
• The platform is primarily built using TypeScript, with support for JavaScript, SCSS, Python, and Handlebars.

n8n Features & Benefits

• Offers a visual editor for fast iterations and instant results.
• Automates business processes without limitations on logic.
• Can handle both everyday automations and complex AI agent workflows.
• Provides pre-built templates for various automations, including AI chat, API endpoints, and chatbots.
• The self-hosted version is free for personal users.

Installation Guide (Self-Hosted via NPM)

• The video demonstrates the NPM installation method for self-hosting n8n.
• Open Command Prompt as administrator.
• Install n8n globally using the command: npm install n8n -g
• Once installed, launch n8n using the command: n8n start
• Access n8n through your web browser at the provided localhost link (e.g., http://localhost:5678).
• Initial setup requires entering email, first name, last name, and password.
• Users can opt to receive a free license key for advanced features.

Getting Started with n8n Workflows

• The n8n interface includes a command bar for searching commands and actions.
• Key sections include Overview, Templates, and Help.
• The Insights section tracks production executions, failures, and time saved.
• Settings allow for plan management (personal/manual).
• Future videos will cover n8n features and workflow building in detail.

What is AI Automation?

• Automation: Computers performing tasks automatically instead of manually.
• AI Automation: Automation combined with AI's ability to think, understand language, make decisions, summarize, classify, and generate text.
• It's like a smart, tireless employee working 24/7.

Real-World Examples of AI Automation

• Customer Support: Automatically resetting passwords and updating tickets.
• Sales Lead Generation: Searching for businesses, collecting info, personalizing emails, and sending them automatically.

Tools for AI Automation

• Automation Platforms: N8N, Make, Zapier.
• AI Tools: ChatGPT (OpenAI API), Claude, Gemini, open-source models.
• Data Storage: Google Sheets, Notion, Supabase.
• Communication: Gmail, Slack, Discord, WhatsApp, Telegram, Microsoft Teams.
• Business Tools: HubSpot, Salesforce, PipeDrive.

Why Learn AI Automation?

• Businesses need to automate repetitive tasks to save time and reduce errors.
• High demand for AI automation specialists across various roles.
• Creates opportunities for freelancers, business owners, and individuals to increase productivity or build AI products.
• A valuable skill in the digital economy.

How AI Automation Works

• Trigger: Initiates the automation (e.g., new email, form submission).
• Collect Data: Gathers necessary information.
• AI Analysis: AI understands, decides, or generates content.
• Perform Actions: Executes tasks like sending emails or updating spreadsheets.
• The process: Trigger -> Collect Data -> AI Thinks -> Automation Acts.

What is a Workflow?

• A sequence of connected steps to complete a process.
• Example: Customer submits form -> AI analyzes message -> Response is written -> Email sent -> Data saved -> Notification sent.
• N8N, Make, and Zapier allow non-experts to build these workflows.

RAG AI Agent Introduction

• Introduces Retrieval Augmented Generation (RAG) to give AI models access to private documents.
• RAG allows AI agents to reference specific business data, acting like an expert employee.

Workflow 1: Data Ingestion

• Purpose: Uploads private documents from Google Drive to a Supabase vector store.
• Steps:
  • Manual trigger.
  • Search for specific folder (e.g., "N8N") in Google Drive.
  • Download files by ID from the identified folder.
  • Add documents to Supabase vector store.
  • Embed text data using an embedding model (OpenAI 3 small recommended).
  • Use a text splitter (recursive character) to chunk documents.
• Supabase Setup:
• Create a Supabase project.
• Obtain Host URL and Service Role Secret.
• Run SQL code from Supabase documentation to create a 'documents' table for the vector store.

Workflow 2: AI Agent Interaction

• Purpose: Creates an AI agent that can query the data stored in Supabase.
• Setup:
  • Trigger: On Chat Message (enables chat UI).
  • AI Agent Node: Configured with OpenAI chat model (40 mini suggested for property data).
  • Memory: Window buffer memory.
  • Tools:
    • Answer questions with vector store tool configured.
    • Description for data: "listings of real estate and commercial properties".
  • Connect to Supabase Vector Store:
  • Retrieve documents from the 'documents' table.
  • Use the same embedding model as Workflow 1 (OpenAI 3 small).
  • Model for Answering Questions: OpenAI 40 mini.

Testing and Demonstration

• Workflow 1 test confirms data is uploaded to Supabase, showing six text chunks.
• Workflow 2 test demonstrates the agent's capabilities:
  • Answers questions about the number of residential properties (e.g., "How many residential properties do you have on your listings?").
  • Provides specific details like property prices (e.g., "What is the price of Lakeside Retreat?").
• Highlights the personalization of AI agents by integrating private business data, making them act like employees.

Local Installation (Docker)

• Download and install Docker Desktop from docker.com.
• Create a Docker volume named "n8n_data" (or similar) to persist data.
• Pull the official n8n Docker image: n8nio/n8n.
• Run the n8n container, configuring:
  • Container name (e.g., n8n)
  • Port mapping (e.g., 5678:5678)
  • Volume mapping (e.g., n8n_data:/home/node/.n8n)
  • Environment variables: TIME_ZONE (e.g., "Europe/Berlin"), N8N_ENFORCE_SETTINGS=true, N8N_USER_ [optional]
• Access n8n via localhost:5678 and set up your initial user account.
• To stop/restart, use Docker Desktop; data persists due to the volume.

Local Installation (CLI)

• Install Node.js from nodejs.org.
• Open your terminal or command prompt.
• Run the command: npx n8n.
• This automatically sets up and runs n8n.
• Access n8n via the provided URL (usually localhost:5678).
• Limitation: Requires running the command each time you want to start n8n. Webhooks might require tunneling to be accessible from external services.

Self-Hosting (Railway)

• Use platforms like Railway for self-hosting.
• Railway offers simple deployment with documentation.
• Cost: Starts around $5/month on Railway, significantly cheaper than n8n Cloud.
• Advantages: More control, privacy, and cost-effectiveness compared to cloud options.
• Supports external webhook connections, unlike basic local CLI setup without tunneling.

n8n Cloud

• Official managed service by n8n.
• Zero setup required; sign up and start using.
• Scalable and production-ready.
• Pricing: Starts at €20/month (approx. $24) for the Starter plan.
• Features (Starter Plan): 2500 unlimited step executions/month, 1 shared project, 5 concurrent executions, unlimited users.
• Includes a 14-day free trial.
• Easier credential management compared to self-hosted options.
• Register at n8n.cloud by providing email and setting up your workspace.

Creating a Telegram Bot with n8n

• The tutorial demonstrates how to create a Telegram bot without coding using n8n.
• It involves setting up a workflow in n8n, starting with a Telegram trigger.
• An access token is generated via Telegram's BotFather by creating a new bot and copying the provided token.
• This token is then pasted into the n8n Telegram trigger node.

Integrating AI and Memory

• An AI agent node is added to the workflow.
• For the AI model, Gemini is chosen for its free API key.
• The workflow is executed, and a message is sent to the bot on Telegram to test the connection.
• Initially, there might be errors, requiring the chat ID to be correctly mapped from the Telegram message to the AI agent.
• A simple memory node is added to allow the AI to remember previous parts of the conversation.

Sending Responses and Customization

• A Telegram "Send Message" node is added to send replies back to the user.
• The chat ID and message content need to be correctly configured.
• To customize the AI's personality, a system message can be added to the AI agent node, defining its role and name.
• A potential issue of a watermark in the bot's response is addressed by adjusting settings in the "Send Message" node.
• The tutorial concludes by mentioning future topics like handling voice and image messages.

Workflow Overview

• The n8n automation consists of three nodes: Form Submission, Google Sheets, and Gmail.
• It automates the process of event invitations by collecting registrant data, confirming registration via email, and providing a link to a WhatsApp group.

Problem Solved

• Solves the problem of manually collecting data and inviting people to groups, especially from online ads.
• Saves time and money compared to manual data entry or hiring virtual assistants.
• Ensures accurate data collection for future marketing or event invitations, even if participants leave the group.

Workflow Demonstration

• A sample form with fields for Full Name, Email, and Phone Number is shown.
• When a user submits the form, their details are automatically recorded in a linked Google Sheet.
• An automated confirmation email is sent to the registrant, including a link to a designated WhatsApp group.
• The demonstration shows a successful form submission, data appearing in Google Sheets, and the receipt of the confirmation email with the WhatsApp group link.

Benefits Highlighted

• Data Collection: Gathers valuable contact information for future use.
• Efficiency: Automates repetitive tasks, freeing up the user's time.
• Cost-Effectiveness: Reduces the need for manual labor.
• Engagement: Directly invites users to a community group.

Account Creation and Setup

• Sign up for n8n using your Gmail account.
• You will receive a 14-day free trial.
• Enter your name and choose a password.
• Name your n8n account.
• Click "Keep me signed in" and then "Start free trial".

Basic Settings and Overview

• Answer questions about your usage (e.g., "Only me", "IT", "YouTube").
• You will be taken to the n8n dashboard.
• The dashboard shows an AI assistant for workflow creation.
• You can also read n8n documentation.

Dashboard Navigation

• The dashboard displays your created workflows.
• Currently, there are no workflows as it's a new account.
• Concepts like "Creational Execution" and "Variable Data Tables" will be covered later.

Creating Workflows and Projects

• Click the "+" icon to create a new workflow or project.
• Creating a "New Project" helps organize related workflows (e.g., WhatsApp Automation, YouTube Automation).
• Alternatively, you can create a "New Workflow" directly, but workflows will be saved randomly.
• Click "Create a Workflow" within a project to start building.

Workflow Editor Interface

• The workflow editor screen is where you build automations.
• You can use the AI assistant by providing prompts.
• Alternatively, build workflows manually.
• Use zoom in/out buttons to adjust the view.
• Click the "adjust screen" button to fit the workflow to your screen size.

Workflow Management Options

• Workflows can be published once created.
• Click the three dots for more options: edit description, duplicate, download, share, move, rename.
• Import workflows from a URL or existing projects.
• Workflows are saved with a .json extension.

Adding and Managing Nodes

• The "+" icon allows you to add triggers and nodes to your workflow.
• You can search for specific nodes.
• The file icon allows you to add information (description, color) to your workflow.
• AI Agents can be added and managed.

Future Chapters and Next Steps

• This video covers account creation, basic setup, and dashboard overview.
• The next chapter will cover specific triggers, nodes, and building AI agents.

AI & Automation Insights

• Differentiate by "Receipts": Stand out in AI by documenting tangible business outcomes (time saved, leads captured) rather than just portfolios of builds.
• Tools Evolve, Skills Endure: Focus on foundational skills (communication, problem-solving, error handling) as AI tools will constantly change.
• Be AI-Native: Default to asking "Can AI do this?" for any task, recognizing that even partial AI assistance provides a significant advantage.
• Context Engineering is Key: The real value in AI isn't the model itself, but how you apply your expertise, knowledge, and prompting to it.
• Manage, Don't Just Chat: Treat AI as an employee, guide its problem-solving process, and ensure it asks clarifying questions.
• AI Agents Need Strict Management: Assume AI will use any access it has; implement tool and API permissioning layers rather than just prompt restrictions.
• Verification is Crucial: AI agents should verify their own work against defined criteria (human-like evaluation) before delivery.
• Find the "Clog or Leak": Focus on solving the core business problems (inefficiencies, losses) that clients may not articulate directly.
• Establish a "Northstar Metric": Define a single, measurable goal for AI projects (e.g., increase leads from 5 to 15 per week) to ensure clear outcomes.
• Token Cost Management: Match AI models to the complexity of tasks to optimize costs; use cheaper models for simpler tasks and expensive ones only when necessary.
• "Do the Work, Then Get the Role": Prove your AI capabilities through practical application and results before seeking formal roles or clients.

Pricing AI Solutions

• Value-Based Pricing is Essential: Move away from hourly billing, which incentivizes slowness. Price based on the tangible value and savings delivered to the client.
• Understand the Client's "Ceiling": Discover the maximum value the client places on the solution through in-depth discovery questions about their current costs, pain points, and desired outcomes.
• Focus on Savings, Not Just Revenue: Quantify the money a client saves by implementing AI solutions, as this is often more provable and less risky than guaranteeing revenue growth.
• Offer Tiered Packages: Present multiple pricing options (e.g., starter, growth, scale) to give clients choices and psychologically guide them towards a preferred option.
• Objective Milestones are Key: Break down projects into clearly defined, provable milestones to ensure smooth payment schedules and avoid scope creep.
• Manage API/Token Costs Separately: Invoice clients directly for utility-like costs (API usage, cloud subscriptions) to maintain transparency and avoid babysitting billing.
• Factor in Testing Costs: Include a buffer in your pricing for rigorous testing and quality assurance, especially for complex AI systems.
• Build Relationships, Not Just Deliver Solutions: Position yourself as a trusted partner, not just a vendor, to foster long-term business.
• Learn to Say No: Decline low-value or misaligned projects to focus on opportunities that offer significant value and fit your expertise.
• Don't Rush Proposals: Take time to thoroughly understand the client's needs and craft a detailed proposal that justifies your pricing.

Automated YouTube Dream

• AI agents act as tireless digital assistants, executing sequences of tasks automatically.
• The only required human input is an initial creative spark via a web form.

Setting Up The Brain (AI Prompt Generation)

• The workflow begins with a simple form trigger for a one-sentence concept.
• OpenAI expands the idea into a comprehensive prompt (500-2000 characters) with specific stylistic choices (action, cinematic lighting, etc.) and content rules.
• An optimized YouTube title (under 99 characters) is generated simultaneously, leaving space for hashtags.

Generating The Video

• The Key AI service, specifically the Sora 2 text-to-video engine, is used.
• Exactly 10 seconds of high-quality footage are generated based on the detailed prompt.
• A "remove watermark" command is set to true.
• A 200-second wait timer is programmed to ensure the video fully renders before pickup, preventing system crashes.

Automating The Upload

• The automation connects to By Tat O for hands-free posting.
• Video data is uploaded, formatted as a YouTube post, and combined with the generated title.
• Content must be tagged as synthetic or altered media for transparency with YouTube to avoid bans.

Cost Of Automation

• Generating a 10-second Sora 2 video costs approximately $0.15.
• A small monthly budget ($5-$10) for API costs is recommended for consistent asset generation.
• Daily credit limits should be set to prevent overspending due to automation errors.
• Expect initial failures during testing; use wait timers and text clean-up commands as fail-safes.

What is JSON?

• JSON (JavaScript Object Notation) is a lightweight, human-readable text format for structured data.
• It's widely used in web APIs, AI services, configuration files, and automation flows like n8n.
• JSON enables applications to communicate and exchange information using a common language.

JSON Syntax and Structure

• JSON data is enclosed in curly braces {}.
• Keys must be double-quoted strings.
• Key-value pairs are separated by a colon :.
• Multiple key-value pairs within an object are separated by commas ,.
• JSON is case-sensitive.

JSON Data Types and Components

• Objects: Containers for related key-value pairs.
• Keys: Labels or identifiers for data fields.
• Values: The actual data assigned to keys.
• Data Types: Strings (in double quotes), numbers (integers/floats without quotes), booleans (true/false), null, arrays, and nested objects.
• Arrays: Ordered lists of values enclosed in square brackets []. Items can be any JSON data type.

Nested JSON

• Used for complex structures, modeling relationships (e.g., an order with items, each item with product details).
• Organizes data in layers for better understanding.

Common Errors and Validation

• Always use double quotes for keys and strings.
• Do not leave trailing commas.
• Ensure all brackets are properly closed.
• Check for misplaced colons or missing values.
• Use JSON beautifiers for practice and validation.

JSON in n8n

• n8n passes JSON between nodes as an array of items.
• Expressions are used to read or modify JSON data.
• Example demonstrates receiving JSON data (name, age) via a webhook node after sending it through an API tester.
• Expressions like .email or .total access specific values.

Introduction to n8n

• n8n is a workflow automation tool that connects applications and services to automate tasks.
• It uses a visual, node-based editor, eliminating the need for complex coding.
• Self-hosted n8n offers data control and predictable costs, ideal for privacy-conscious users.

n8n Interface and Core Concepts

• The dashboard displays saved workflows, their status, and execution history.
• The canvas is the visual editor where workflows are built by connecting nodes.
• Credentials securely store API keys and permissions needed to connect to external services.

Types of Nodes

• Trigger Nodes: Initiate workflows (schedule-based, event-based, or webhook-based).
• Action Nodes: Perform tasks like sending emails, updating records, or posting messages.
• Logic Nodes: Enhance workflows with conditional routing (If, Switch) and data merging/splitting.

Building a Gmail to Slack Workflow

• Goal: Send Slack notifications for important Gmail emails.
• Setup:
• Create a "n8n priority" label in Gmail.
• Set up Google Cloud Project, enable Gmail API, and configure the OAuth consent screen.
• Obtain Client ID and Client Secret from Google Cloud, and the Redirect URI from n8n.
• Create a Gmail credential in n8n using the obtained Google Cloud details.
• Create a Slack app, add "chat:write" and "channels:read" scopes, and install it to your workspace.
• Copy the Bot User OAuth Token from Slack and create a Slack credential in n8n.
• Workflow Configuration:
• Use the Gmail trigger node, select the Gmail credential, set event to "message received," and filter by the "n8n priority" label.
• Add the Slack node, select the Slack credential, set resource to "message" and operation to "send."
• Specify the channel and compose the message using dynamic data from the Gmail trigger (e.g., sender, subject) via expressions.
• Testing and Activation:
• Execute the workflow to test it.
• Name and publish the workflow to activate it.

Conclusion and Next Steps

• Automate repetitive tasks to save time and reduce errors.
• Start simple, build automations gradually, and test thoroughly.
• Consider self-hosting n8n for complete data control.

Introduction to Private RAG

• Problem: Companies have data in SharePoint and AI licenses but AI cannot answer specific questions due to lack of data connection.
• Solution: Build a private RAG (Retrieval Augmented Generation) system using SharePoint as data source, N8N as orchestrator, Mistral OCR for eyes, and a vector database for memory.
• RAG Explained: A retrieval layer sits between user questions and the language model, finding and providing relevant content. The model only processes provided context, not the entire data source.
• Failure Point: RAG systems fail due to issues in the retrieval layer, not the language model.

Core Components of Retrieval

• Document Store: SharePoint.
• Vector Index: Stores document meaning as numerical vectors. Similar meanings have close vectors.
• Language Model: Generates the final answer based on retrieved context.
• Vector Search vs. Keyword Search: Vector search finds ideas, keyword search finds exact words.

Why Standard Search Fails

• SharePoint Search: Keyword-based, assumes user vocabulary matches document vocabulary, struggles with synonyms and inferred meaning.
• Agentic RAG: Uses tools like vector search, full document retrieval, and SQL queries for different question types.
• Example: "Total revenue in 2024" requires calculation (SQL), not just semantic search.

System Architecture

• Layers: SharePoint (Source), Microsoft Graph API (Connector), N8N (Orchestrator), Mistral OCR (Processor), Superbase/Postgress (Memory).
• User Interface: Open Web UI (ChatGPT-like, self-hosted).
• Pipelines: 1. Ingestion (scheduled, processes new/changed files). 2. Retrieval (real-time, answers user questions).
• Data Sovereignty: All components hosted within the EU (Germany, Sweden) to comply with GDPR.
• Infrastructure Cost: Can run on a single VPS (€7-€20/month), scalable to dedicated containers.
• Self-Hosting Requirement: Agentic chunking requires specific LangChain modules only available on self-hosted N8N.

Connecting N8N to SharePoint

• Graph API vs. SharePoint Module: SharePoint module lacks file IDs for dynamic downloads; Graph API provides file IDs but may miss reliable timestamps.
• Solution: Parallel paths in N8N – one for Graph API (file IDs), one for SharePoint module (timestamps). Merged based on file name.
• Rate Limiting: Implement exponential backoff to handle Graph API's 429 (Too Many Requests) responses.

Azure App Registration Steps

• Create App Registration: Name it descriptively, select "Accounts in any organizational directory".
• Redirect URL: Use the exact URL generated by N8N's OAuth2 credential.
• API Permissions: Grant `offline_access`, `files.readwrite.all`, `sites.read.all` (Microsoft Graph) and `My files.ReadWrite` (SharePoint).
• Permissions Type: Use "Delegated permissions" for user context.
• Certificates & Secrets: Create a client secret (max 730 days expiration), copy the value immediately.
• Application ID: Copy from app overview (Client ID).

Configuring N8N Credentials

• SharePoint Credential: Client ID, Client Secret, Subdomain.
• Microsoft OAuth2 API Credential: Client ID, Client Secret, Permission Scopes (`files.readwrite.all sites.read.all offline_access openid`).
• `offline_access` Scope: Crucial for token refresh, keeps connection alive.
• Testing: Test Graph and SharePoint nodes individually before merging.
• Secret Expiration: Set calendar reminders for client secret renewal.

File Sync Logic

• Metadata Table: Postgress table with file ID, name, and last modified timestamp to track changes.
• Comparison: Compares current SharePoint state with the metadata table.
• Scenarios:
• New File: Add to metadata, process through pipeline.
• Edited File: Delete old data from vector DB, reprocess, update timestamp.
• Deleted File: Scrub from vector DB and metadata.
• URL Encoding Fix: Decode URL-encoded file names (e.g., `%20` for space) before merging lists to prevent join failures.

Downloading and Routing Files

• Downloading: Uses Graph API file ID to download binary data.
• Routing: Splits files based on extension (Excel/CSV vs. others).
• Tabular Data (Excel/CSV): Stored as JSON records in a Postgress table (`document_rows`) for SQL querying. Skips vectorization.
• Text/Docs/PDFs: Processed through OCR, chunked, and vectorized.

Mistral OCR: Why it's Crucial

• Limitations of Native Tools: Can't see images, struggles with complex layouts/tables, fails silently on scans.
• Mistral OCR Advantages: Analyzes layout, identifies text/tables/reading order, reconstructs as structured markdown, higher accuracy (99% on scans, 96% on tables).
• Markdown Output: Preserves structure (headings, tables) for better chunking.
• Image Handling: Generates descriptions and placeholders for images, which are later replaced with URLs.
• Cost & Compliance: Affordable ($2/1000 pages), runs in Azure AI Foundry (EU compliance).

Agentic Chunking

• Problem: Large documents exceed embedding model context limits; single large vectors lack specific meaning.
• Naive Chunking: Fixed character count cuts can split sentences, tables, or disconnect headings from content.
• Context Cliff: Accuracy drops significantly beyond ~2500 tokens per chunk.
• Agentic Chunking Solution: Uses an LLM (Azure OpenAI GPT) to identify logical boundaries (headings, list items, semantic shifts) for smarter chunking.
• Cost-Benefit: Small overhead for ingestion, but significantly improves retrieval quality for typical corporate libraries.

Image Processing and Storage

• Annotation: Mistral OCR annotates images with descriptions and placeholders in markdown.
• Storage: Images uploaded to Superbase storage buckets, given public URLs.
• URL Replacement: Placeholders in markdown are replaced with public image URLs.
• GDPR Caveat: Public buckets are unsuitable for images containing personal data; consider private buckets with short-lived links or filtering.
• User Experience: Inline images appear exactly where they belong in the retrieved content.

Vectorization and Embedding Model

• Purpose: Converts text chunks into numerical vectors for similarity search.
• Embedding Model: Azure OpenAI text embedding model, deployed on EU data zone servers (Sweden) for GDPR compliance.
• Vector Database: Superbase with PGVector extension.
• Index Type: HNSW (Hierarchical Navigable Small World) for faster approximate nearest neighbor search.
• Metadata: Each vector row stores embedding, file ID, original file name, and chunk index for traceability.

How the Agent Retrieves Information

• Retrieval Pipeline: User question -> N8N -> Embedding Model (question vector) -> Similarity Search (Superbase) -> 25 Candidates.
• Re-ranking: Coher rank v3.5 re-ranks the 25 candidates based on relevance to the specific question.
• Top 4 Chunks: Selects the top 4 re-ranked chunks for the agent's context.
• GDPR Note (Coher): Coher is Canadian, considered adequate by EU GDPR, but verify for highly regulated sectors.
• Agent's Role: Generates the answer based on the 4 chunks and original question.

The Three Agent Tools

• Tool 1: Vector Store Retrieval (Default). Uses re-ranked chunks for semantic questions.
• Tool 2: Full Document Retrieval. If initial retrieval is insufficient, reconstructs the entire relevant document from chunks using file ID.
• Tool 3: SQL Query Tool. For calculations and data comparisons; agent writes SQL queries against the `document_rows` table (for tabular data). Avoids LLM arithmetic errors.

Writing the System Prompt

• Purpose: Defines agent's behavior, tool usage, and constraints.
• Core Instructions:
• Always start with RAG (vector search).
• Escalate to full document retrieval if RAG is insufficient.
• Use SQL for any numerical questions/calculations.
• Render inline images where they appear in the document.
• Always cite the source file name.
• Be honest if the answer is unknown; do not fabricate.
• Living Document: Prompt should be updated based on agent failures and edge cases.

Self-Hosting Infrastructure Decisions

• N8N Self-Hosting: Required for agentic chunking (LangChain modules). N8N Cloud lacks these.
• Cost & Limits: Self-hosting avoids N8N Cloud's execution limits and potential cost overruns.
• Production Setup: N8N in Q mode (main instance + workers), dedicated Postgress/Redis for stability and performance.
• Data Residency: Hosting in Germany ensures EU jurisdiction and GDPR compliance (avoids Cloud Act exposure).
• Cost Example: €15-€25/month for full infrastructure.
• Updates: Regular self-updates of N8N via Docker Compose.

GDPR Architecture Essentials

• Proactive Design: Compliance shaped architecture from the start.
• Data Flows:
• Ingestion: All steps after Graph API call run on controlled EU infrastructure.
• Embedding: Use Azure AI "data zone standard" to keep processing within EU member states.
• Vector Database: Use EU-based providers (e.g., PG Vector on German VPS, Qwant in Berlin) to avoid Cloud Act exposure.
• Operational Areas: Manage N8N logs, Postgress logs, and Open Web UI conversation history with clear retention and deletion policies.
• Right to Erasure: Ensure automatic deletion of associated data (vectors, metadata, history) when a document is removed from source.

Failure Modes and Handling

• Graph API Throttling (429 errors): Honor `retry-after` header, implement exponential backoff.
• Silent OCR Failures: Add validation node after OCR to check for minimum content length and valid markdown structure.
• Stale Vectors: Implement content hash check as a fallback alongside timestamp checks.
• Merge Step Failures: Decode URL-encoded file names from both Graph API and SharePoint paths before merging.
• Monitoring: Beyond N8N logs, use explicit logging nodes for OCR, vector writes, and SQL operations, storing detailed info in a dedicated table.

User Experience (Open Web UI)

• Familiar Interface: Mimics ChatGPT to reduce user training friction.
• Performance: Answers typically under 10 seconds; complex SQL queries may take longer but still feel conversational.
• Inline Images: Images appear in context within the answer, not at the end.
• Source Citation: Every answer includes the source file name for traceability and trust.
• Honesty: System clearly states when it doesn't know an answer; avoids speculation.
• Conversation History: Persists across sessions for continuity.
• Extensibility: Open Web UI can be replaced with any frontend using webhooks.

Extending the System

• Ingestion Pipeline: Swappable (e.g., Nextcloud, Google Drive, OneDrive).
• Multi-language Support: Mistral OCR handles over 25 languages; vector store is language-agnostic with multilingual embedding models. System prompt may need adjustment.
• Role-Based Access Control: Filter retrieval results based on user identity and document permissions (mapped during ingestion).
• SQL Tool: Extend to query other structured data sources (databases, APIs) by describing schema in system prompt.
• Vector Store Scaling: PG Vector for millions, Superbase Vector Buckets for tens of millions, dedicated Qdrant for higher scale.
• Additional Tools: Integrate new tools (web search, calendar access) as N8N sub-workflows described in the system prompt.

Deep Dive Research & Validation

• Core Premise: RAG quality depends on retrieval, not generative model.
• Re-ranking Importance: Essential for precision; selects most meaningful evidence over topically related chunks. Coher rank v3.5 used for N8N compatibility and GDPR compliance.
• Mistral OCR vs. Native Tools: Higher accuracy, handles images/tables/scans reliably, cost-effective ($2/1000 pages), EU compliant via Azure AI Foundry.
• Agentic Chunking Benefits: Preserves logical structure, stays within optimal token limits (~500-2000 tokens), quality gain outweighs small ingestion overhead for knowledge bases.
• N8N vs. Azure Logic Apps: N8N offers flexibility, LangChain support, unlimited executions, and better cost control for self-hosted sovereign stacks.
• Data Sovereignty (Cloud Act): Avoid US-based vector DBs; PG Vector on German VPS offers zero Cloud Act exposure.
• Cost Efficiency: Low infrastructure cost (€15-€25/month) combined with affordable API fees.
• Performance: Fast retrieval (<100ms DB search, ~0.5s total retrieval), responsive user experience due to Q mode N8N.

Telegram Bot Part 2 Postponement

• The scheduled tutorial for building a Telegram Bot (Part 2) is postponed to the next day.
• The postponement is due to expired API keys and limitations on free-tier usage, requiring adjustments to the workflow.

Course Status and Remaining Topics

• The instructor will use this session to discuss the course syllabus and address student doubts.
• Remaining topics include: Debugging, Webhooks, MCP, AI Automation as a Business, Optimizing RAG Applications, AI Security, Privacy, and Compliance.
• Advanced topics like "Jailbreaking" LLMs will also be covered.

Q&A and Future Schedule

• The instructor encourages students to ask questions about the course content covered so far.
• The AI Automation course is expected to conclude in about 10-12 classes.
• Other scheduled classes include CCL lab (Static Routing), Python for Network Automation, VIP T, and English.
• The instructor will fix the API key issues and proceed with the Telegram Bot tutorial tomorrow.

Introduction to the Problem

• The video argues against learning n8n in 2026, suggesting a more efficient method exists.
• Traditional node-based automation tools like n8n are presented as complex and costly.

The n8n Automation Example

• A competitor monitoring automation built with n8n involved 10 nodes and 40 lines of JavaScript.
• It faced issues like being blocked by Reddit, errors in code execution, and file access restrictions due to n8n's security sandbox.
• The email node also required SMTP configuration and app passwords, indicating a barrier to immediate use.
• n8n's pricing model ($20/month for 2,500 runs) is highlighted as a potential cost issue for scaled automation.

The "One File" Solution

• The same automation was rebuilt as a single markdown file, readable and executable as instructions.
• This file defines watch terms, data sources, skipping logic, ranking, summarization, and output location.
• It requires no canvas, JavaScript, or per-run meter, functioning like a directive to a smart assistant.
• The process was executed with a single command, producing a ranked digest in about 2.5 minutes.
• The one-file version handled an error (Reddit block) by retrying, flagging the issue, and completing the job, unlike n8n which would have failed.
• Scheduling is done via a simple cron line.

Benefits of the "One File" Approach

• Easier to update: Changing watch terms involves editing a sentence, not rewiring nodes.
• Future-proof: The "precise description" skill transfers to new tools, unlike node-based workflows that become obsolete.
• Cost-effective: Avoids subscription meters associated with some platforms.

When n8n Might Still Be Suitable

• Teams requiring visual, shared workflows on a canvas.
• Environments needing extensive pre-built integrations (n8n lists over 2,000).
• Situations where non-developers need to maintain automation flows.
• High-volume webhook routing.

Call to Action

• The video offers a free resource ("rewire" bot) including the annotated watchdog file, other automations, cron patterns, and an n8n checklist.
• Resources are available at hyperautomationlabs.co/free/rewire.

Installation & Resource Usage

• Node-RED: Installs in 23 seconds, uses 277 packages, 109 MB disk space, and is ready in 2 seconds.
• n8n: Installs in 2 minutes 44 seconds, uses 2,176 packages, 2.5 GB disk space, and is usable in 16 seconds.

Out-of-the-Box Features

• Node-RED: Ships with 50 general-purpose nodes. Requires adding nodes for RSS feeds and AI calls via npm.
• n8n: Ships with 682 nodes, including 135 specifically for AI, and nodes for RSS and AI calls are pre-installed.

Workflow Building Experience

• Node-RED: Workflow involved 7 boxes, requiring 3 custom JavaScript "function" nodes for API calls and data manipulation.
• n8n: Workflow involved 5 boxes, with all actions (trigger, RSS, limit, OpenAI, listener) handled by pre-built nodes requiring no code.

Performance & Output

• Both tools successfully completed the workflow, fetching, summarizing, and posting articles.
• Node-RED completed in 4.1 seconds, n8n in 5.3 seconds (single run, not a benchmark).
• Both produced identical summaries, including the same factual error from the AI model.

Licensing & Commercial Use

• Node-RED: Uses Apache License 2.0, allowing unrestricted commercial use.
• n8n: Uses a "Sustainable Use License" which restricts use to internal, non-commercial, or personal purposes. Commercial distribution requires careful review and may be restricted. An enterprise license and cloud version are available.

Key Differences & Decision Factors

• Node-RED: Best for those prioritizing small footprint, speed, and complete commercial freedom, if comfortable writing JavaScript for advanced tasks.
• n8n: Best for those prioritizing out-of-the-box AI capabilities and a no-code experience, accepting larger resource usage and a more restrictive license.

Platform Overviews

• Zapier: Launched in 2011, known for ease of use and the widest integration range (8000+ apps). Bills per task, with a free tier of 100 tasks and a starting paid tier at $20/month for 750 tasks.
• Make (formerly Integromat): Positioned as a visual middle ground. Bills per operation (module), offering 1000 operations on the free tier and $9/month for 10,000 operations. Visually different canvas for complex logic.
• n8n: Open-source, allowing self-hosting for maximum cost savings and control. Bills for hosting infrastructure if self-hosted (approx. $20-30/month flat). Paid cloud version is $22/month for 2500 executions. Supports custom JavaScript/Python logic.

Key Differences & Pricing

• Billing Model Impact: Zapier's per-task billing can become very expensive for complex, high-volume workflows. Make's per-operation and n8n's self-hosted model offer significantly lower costs at scale.
• Cost Example: A 10-step automation running 10,000 times/month could cost $400 on Zapier, but only $20-30 on n8n (self-hosted).
• Learning Curve: Zapier is the easiest (easy mode). Make has a steeper learning curve but offers more visual control (normal mode). n8n requires technical skill (expert mode).

Choosing the Right Platform

• Zapier: Best for non-technical users needing quick setup and maximum integrations. Budget for higher costs as usage scales.
• Make: Suitable for users willing to learn for more visual control and better pricing than Zapier.
• n8n: Ideal for developers or technically inclined users seeking maximum control, customization (code support), and cost-efficiency, especially with self-hosting.
• Recommendation: Start with free tiers and build the same workflow on multiple platforms to compare usability and pricing before committing.

Future Trends

• All three platforms have added native AI agents (2026), indicating a shift towards more advanced automation capabilities.

Introduction to n8n

• n8n is an open-source, no-code automation tool for integrating various applications like WhatsApp, Telegram, Gmail, and Google Sheets.
• It offers over 200 integrations and ready-made templates categorized by use cases (e.g., Sales, AI).
• While n8n cloud offers a 14-day free trial, unlimited usage can be achieved by setting it up via Docker or NodeJS.

Building Your First AI Agent (Email Automation)

• The process involves creating a workflow on the n8n canvas using "nodes."
• A Schedule trigger node is used to define when the workflow should run (e.g., daily).
• An AI agent node is configured with a prompt to generate email content (e.g., an emergency leave request).
• A chat model node (like Groq with Llama 3.3) is required for the AI agent to generate text. This involves setting up API key credentials.
• A Gmail node is used to send the generated email. This also requires setting up Gmail credentials.
• The output from the AI agent node is directed to the message field of the Gmail node.
• The "append attribution" option in the Gmail node can be turned off to prevent adding "mail sent automatically by n8n" to the email.

Workflow Management and Templates

• Workflows can be saved, downloaded as JSON files, and their execution history (successes and errors) can be viewed.
• n8n provides a "Build with AI" feature to auto-generate workflows based on user commands.
• Pre-built templates can be directly used by clicking "Use for free," with users only needing to set up the required credentials.

Recap of Previous Sessions

• Discussed trigger nodes, webhook, and schedule nodes.
• Learned about workflow canvas (main workspace for building automations).
• Understood nodes as building blocks for tasks (e.g., sending emails).
• Covered node configuration panel for setting node parameters.
• Reviewed execution logs for debugging workflow errors.

Trigger Nodes Explained

• Trigger nodes initiate workflow execution when an event occurs.
• Types of trigger nodes include manual, webhook, schedule, form, and email triggers.
• Manual trigger: Executes each node separately, often requiring manual input.

Webhook Node Details

• A webhook is a special URL that waits for incoming data.
• When data arrives, the webhook URL activates and starts the workflow automatically.
• Real-life analogy: A doorbell (webhook) waits for someone to ring it (event) before alerting you (starting workflow).
• Distinction between test URL (for testing) and production URL (for live use).

Schedule Trigger Node

• Schedule triggers initiate workflows at a predefined time.
• Automates tasks like sending messages daily or running processes at specific intervals without manual intervention.
• Can be configured for daily, weekly, monthly, or custom schedules.

Live Weather Data Workflow Demo

• Demonstrated creating a workflow using a schedule trigger.
• Fetched live weather data using an HTTP node with a weather API.
• Used a reverse API (also HTTP node) to convert latitude/longitude to address.
• Configured nodes to display location data and suggested logging or emailing the information.

Webhook vs. Schedule Trigger Comparison

• Webhook: Waits for an event and starts when data arrives.
• Schedule: Waits for a specific time and starts at a fixed interval (daily, weekly, etc.).

Outline Improvement

• Filters articles where 'article status' is 'draft'.
• Uses an AI agent to rewrite and improve the initial outline.
• Prompt instructs AI to act as an SEO content strategist, expand on initial outline bullets, add introduction sentences for each section, use SEO titles, and remove numbering.
• Guides AI to add 5-10 detailed bullets per section based on intent guidance and use comparison/listical formats where appropriate.
• Appends the improved outline back to the spreadsheet, updating 'article status' to 'outline ready'.

Article Writing

• Sets up an AI agent to write the full article based on the improved outline.
• Prompt instructs AI to act as an expert SEO content writer.
• Specifies article structure: 2-4 introductory paragraphs (no header), then main sections with markdown headings.
• Instructs AI to expand each outline bullet into 2-4 detailed paragraphs with examples, weaving in nested bullets and explicit comparisons.
• Writing rules include: no article title as a heading, start with intro paragraphs, use markdown headings (H2, H3), clear/specific tone, avoid vague advice.
• Output rules: only valid markdown, no HTML/JSON/XML wrappers, no code fences, no preamble, first line must be the intro paragraph.
• Acknowledges potential issues with AI models including unwanted titles and plans to use an Open Router with a cheaper model to fix this.

Post-Writing Steps

• Optional step: Creates Google Docs for each article using the article title and content.
• Updates the created Google Docs with the article text from the AI output.
• Notes that some AI outputs may incorrectly include the article title as a heading, which needs to be addressed by using a better AI model (like Open Router) in future steps.
• Marks Phase 2 (Outline Improvement to Article Writing) as complete within the workflow.
• Prepares for the next video: converting markdown to HTML, creating posts, generating images, and uploading to WordPress.

Workflow Setup

• Google Sheet created in Google Drive to store article ideas and information.
• Columns include: Niche, Theme, Article Title, Search Intent, Guidance, Keywords, Excerpt, Initial Outline, Improved Outline, Article Status, WordPress URL.
• AI tools used: LM Studio (free local AI) and Open Router AI (paid, cost-effective for articles/images).

AI-Powered Idea Generation

• Workflow starts with an "On Form Submission" node to get Niche and Number of Articles.
• An AI agent (using Mistral 7B on LM Studio) generates article ideas based on the niche and requested number of articles.
• The AI is prompted to output a JSON object containing Title, Keywords, Excerpt, and Theme for each article.
• Rules provided to the AI include focusing on useful content, clear titles, relevant keywords, and a broad theme within the niche.

Data Structuring and Refinement

• An "Edit Set" node is used to parse the AI's JSON output for better readability.
• A "Split Out" node is introduced to separate each article's data, making individual fields (Title, Keywords, Excerpt, Theme) accessible for subsequent steps.
• This prevents issues where only the first article's data might be accessed in later processing.

Determining Search Intent and Guidance

• A new AI agent is configured to determine the primary search intent (Informational, Transactional, Commercial, Navigational) based on the article title and keywords.
• It also generates a paragraph of guidance on how to write the article to match that intent.
• The AI uses pre-defined rules for each intent type.
• Output is structured as JSON with "Intent" and "Intent Guidance" fields.
• Another "Edit Set" node separates these into distinct fields for easier access.

Outline Generation and Google Sheet Integration

• A final AI agent generates a structured outline for each article.
• The prompt includes the theme, excerpt, keywords, title, search intent, and intent guidance.
• The outline format includes an introduction, sections with titles, introductory sentences, and 2-3 bullet points per section.
• A "Google Sheets" node appends the generated data to the previously set up Google Sheet.
• Data mapped includes Niche, Theme, Article Title, Search Intent, Intent Guidance, Keywords, Excerpt, Outline, and Article Status set to "Draft".
• The article title is used as a unique identifier for updating rows.

Job Description Processing

• The automation retrieves job descriptions and parses them into JSON format.
• It then processes these JSON outputs to separate resume and cover letter content.

Document Creation and Storage

• Folders are created in Google Drive for each job application, named after the company.
• Individual documents for resumes and cover letters are created within these folders.
• Documents are updated with the generated resume and cover letter content.

AI Formatting

• Two AI agents are introduced: "Format Resume" and "Format Covering Letter."
• Prompts are designed to instruct the AI to format the text using markdown, ensuring professional headings, spacing, and structure.
• Additional rules are added to prevent code fences and ensure raw markdown output.

Model Testing and Refinement

• The initial automation run uses a free local AI model, which yields inconsistent formatting results.
• A second run uses the OpenRouter platform with Gemini 2.5 Pro, resulting in significantly improved and consistent formatting for both resumes and cover letters.
• The cost for generating three resumes and cover letters using OpenRouter is approximately 24 cents.
• Potential areas for further refinement include ensuring the correct current date is inserted into the cover letters.

Automation Setup

• Created a "Ré and Cover Letter Assistant" automation to customize resumes and cover letters for specific job descriptions.
• The process involves taking an existing resume and multiple job descriptions from a Google Drive folder.
• The automation rewrites the resume and generates a cover letter for each job description.
• Final output includes a dedicated folder for each job application in Google Drive, containing the tailored resume and cover letter.

Google Drive Structure

• Jobseeker Helper folder: Contains a current resume and a folder with job descriptions.
• Job Descriptions folder: Holds individual job description documents.
• Applications folder: Stores the generated output, with subfolders for each job application.

Trigger and Initial Steps

• A form trigger is used, requiring the resume's Google Drive ID and the job description folder's ID.
• The automation retrieves the resume content using a "Get Document" node.
• It then uses a "Search Files and Folders" node to get a list of all job description documents within the specified folder.
• For each job description found, the automation will perform subsequent steps.

AI Prompt Engineering

• A single AI agent is used to rewrite the resume and write the cover letter.
• The prompt instructs the AI to act as a career assistant and expert resume writer.
• Key Instructions: Analyze job listing and resume, identify company, skills, and keywords. Tailor resume using only existing experience. Write a cover letter. Do not invent or exaggerate.
• Safety Rules: Do not add new jobs, companies, degrees, or change dates/titles. Rephrase and emphasize existing content.
• Tasks:
  • Job Analysis: Identify job title, company, location, key responsibilities, skills, tools, keywords, and cultural clues.
  • Tailored Resume: Rewrite resume to match job description, maintain structure, reorder/rephrase bullet points, emphasize relevant achievements. Add a targeted summary if applicable.
  • Cover Letter: Write a tailored cover letter using company and applicant details. Maintain a professional tone. Follow a specific paragraph structure (intro, matching experience, closing).
• Handling Missing Skills: Provides specific phrasing options for the AI to address skills present in the job description but missing from the resume (e.g., "I am currently developing my skills in...").
• Output Format: Strict JSON output is specified with keys "resume" and "cover_letter" to ensure structured data. Includes critical formatting rules for the JSON output.

Social Media Content Factory Setup

• Automation takes a long article and rewrites it for different social media channels (X, Facebook, LinkedIn).
• Starts with an "On Form Submission" trigger to input an article title and article ID.
• A "Project Title" is used for saving the final document.
• Fetches the article content from Google Drive using the provided article ID.

AI Agent Configuration and Prompt Engineering

• Utilizes an AI agent (initially Mistral 7B for testing, later Gemini 2.5 Pro).
• The prompt is structured with:
  • Role: Expert social media copywriter and content repurposing assistant.
  • Task: Create platform-specific social media content and image prompts from a long-form article.
  • Goals: Adapt tone, length, and style for X, LinkedIn, and Facebook; include emojis and hashtags; generate image prompts with correct aspect ratios.
  • Content Rules: General rules (focus on main message, simple language, no verbatim copying) and platform-specific rules (X: short, informal; LinkedIn: professional, practical insights; Facebook: conversational, encourage comments).
  • Image Prompt Details: Specify prompt content, avoid jargon, include aspect ratios (X: 1:1, LinkedIn: 16:9, Facebook: 4:5).
  • Output Format: Structured markdown with H1/H2 headers, posts, and image prompts.

Workflow Execution and Results

• The AI processes the article based on the detailed prompt.
• Outputs are saved as a markdown document in Google Drive.
• Initial test with Mistral 7B showed inconsistencies, particularly with paragraph counts for LinkedIn and Facebook.
• Switching to Gemini 2.5 Pro via Open Router yielded much better results, adhering more closely to prompt instructions.
• Generated images from prompts were visually appealing and appropriate for the platforms.

Potential Modifications

• For local AI models that struggle with complex prompts, consider splitting the AI agent into separate agents for each social media platform (X, LinkedIn, Facebook).

N8N Automation Setup

• The workflow is named "AI Humanizer".
• It aims to identify AI tells in content rather than directly rewriting it, allowing for manual review.

Identifying AI Tells

• NotebookLM (notebooklm.google.com) is used to research common AI writing patterns.
• Sources include articles on "AI tells," "signs of AI writing," and "why ChatGPT writes like that."
• Key AI tells identified: repetitive vocabulary, formulaic structure, constant parallelism, superficial analysis, overuse of punctuation (e.g., em dashes), lack of "human wonkiness," and excessive hedging.
• The "rule of three" (grouping adjectives or phrases into triplets) is highlighted as a common AI pattern.

Workflow Construction

• Trigger: On Form Submission, collecting "text to anonymize" and a "title of project".
• Retrieve the "AI tells" document from Google Docs.
• Create a new Google Doc in a designated "Reports" folder for the output.
• Use an OpenAI Chat Model (local AI via LM Studio or cloud models like Gemini Pro) for analysis.
• Prompt Engineering:
• Defines "AI Tells" and "Document to Check" sections.
• Sets the role to "AI Content Authenticity Analyst".
• Task: Analyze the "Document to Check" against "AI Tells", flag issues, explain the tell, its location, and relevance.
• Output Format: A three-line block per issue (Issue Type, Original Text, Suggested Rewrite), separated by a blank line.
• Includes a markdown header: #AI tells for [Project Title].
• General rules: Don't change facts, avoid repeating misspellings, don't add content, don't rewrite whole paragraphs unless necessary, preserve meaning, and avoid em dashes.
• Update the newly created Google Doc with the AI agent's findings.

Testing and Results

• Testing with Mistral 7B shows basic identification of tells but inconsistent formatting.
• Testing with Gemini Pro yields more comprehensive results, identifying more AI tells and providing rewrites.
• A short story generated by ChatGPT is tested, revealing patterns like parallelism, rule of three, superficial analysis, and excessive hedging.
• The output report allows users to manually review flagged sections and make desired edits.

Introduction to n8n

• n8n is an automation tool that connects different apps to eliminate manual copy-pasting.
• It acts as a "conductor" for apps, enabling seamless integration.
• Automations can be built without writing code.

Core Concepts: Workflows and Nodes

• Workflows: The blueprint for an automation, defining the entire sequence of tasks.
• Nodes: Individual steps or actions within a workflow. Each node performs a single, specific task.

Triggers: Starting Automations

• Triggers: Special nodes that initiate a workflow.
• Schedule Trigger: Runs a workflow at a set time (e.g., daily at 9 a.m.).
• Webhook Trigger: Activates a workflow instantly when an event occurs in another app (e.g., form submission).

Data Manipulation and Advanced Logic

• Set Node: Used to transform and format data as it moves between nodes. It can rename fields, add new data, or modify existing information.
• Code Node: Allows for custom JavaScript to handle complex business logic or specific requirements not covered by pre-built nodes.

Connecting to Any Service

• n8n offers hundreds of pre-built connections.
• HTTP Request Node: A universal tool to connect to any service with an API.
• Common commands include GET (to retrieve data) and POST (to send data).

The Future: AI Agents

• n8n is integrating AI agents that can understand broad goals and autonomously determine the necessary tools and nodes to achieve them.
• This signifies the future of more intelligent and adaptive automation.

Line Editor Setup

• Connects the line editor to the same AI model as the spelling/grammar tool.
• Prompt is edited to define the role of a line editor focused on clarity, flow, and conciseness.
• Instructions include line-by-line suggestions, removing redundancy, and preserving original meaning/tone.
• Output format requires a markdown header (#lineedits4) and two spaces after each line.
• General rules prevent changing facts, creating new content, or altering the original meaning.

Testing and Results

• The automation tests the line editor with a sample document.
• The output includes suggestions for word choice (e.g., "generate" instead of "deliver") and redundancy removal (e.g., "thrive" implies optimal growth).
• The cost for using OpenRouter with the line editor is 8 cents.
• Testing with the Mistral 7B free model yields poorer results, failing to obey layout and offering less precise suggestions.
• The video suggests experimenting with different AI models (e.g., Gemini 2.5 Pro) for better results.

Resources

• The line editor and spelling/grammar prompts are provided as resources for viewers to use and modify.

Automation Setup

• Automation triggered by a form submission.
• Form includes fields for: Title, Article ID, Level of Edits (Spelling & Grammar or Line Edit), and Language (ENGB or ENUS).

Document Retrieval and AI Branching

• Fetches the document from Google Drive using the Article ID.
• Uses an "If" node to branch the workflow based on the selected "Level of Edits".
• Separate AI agents are designated for "Spelling & Grammar" and "Line Editor" tasks.
• An OpenAI Chat model is used for both AI pathways.

Spelling & Grammar AI Prompt Engineering

• A "super prompt" is constructed with specific instructions for the AI.
• Prompt includes: AI role (spelling and grammar specialist), task definition (correcting errors, enforcing consistency), output format (markdown header, issue list with original text and suggested rewrite), general rules (do not change facts, avoid duplication, preserve style), and the document text.
• Emphasis on using a high-quality AI model for better results.

Testing and Results

• Initial test with a 4B model produced formatting errors and missed some spelling corrections.
• Second test with Open Router using Gemini 2.5 Pro yielded significantly better results, correctly identifying spelling, grammar, and punctuation issues.
• The Gemini 2.5 Pro model cost 9 cents for the task but provided superior output.

Next Steps

• The video concludes by stating the next part will cover setting up the "Line Editor" functionality.

Workflow Setup

• Created an n8n workflow named "Tone Rewriter".
• Used "On Form Submission" trigger to collect user input.
• Form fields include: Document Title, Target Tone (dropdown: Professional, Friendly, Persuasive), Formality (dropdown: 1-5), Length (dropdown: Shorter, Same, Longer), and Text to Modify (textarea).

AI Prompt Configuration

• Integrated with LM Studio using OpenAI Chat mode.
• Prompt defined as an AI content editor to rewrite text based on specified tone, formality, and length, while preserving original meaning and facts.
• Specific tone rules for Professional, Friendly, and Persuasive are detailed.
• Formality scale (1-5) and length options are incorporated into prompt instructions.
• Safety constraints: no changes to hard facts, numbers, dates, URLs, names, specific promises, prices, discounts, or guarantees.

Output and Testing

• Created a Google Docs document to save the rewritten text.
• Used a Google Docs Update node to insert the AI's output.
• Tested with a rude customer service email.
• Successfully rewrote the text to be Professional and Formal.
• Successfully rewrote the text to be Friendly and informal.
• Added a "Comedian" tone option and tested it, resulting in a humorous rewrite.

WordPress Integration Setup

• Create WordPress API credentials in n8n using your WordPress username and a generated application password.
• The password is not your main login password but one specifically created for the application (e.g., n8n).
• Test the connection to ensure it's successful.

Workflow Modification for WordPress Posting

• Duplicate an existing workflow to avoid altering the original.
• Remove steps for saving articles to Google Drive if the goal is to post directly to WordPress.
• Add a "WordPress" node to the workflow.
• Select the "create post" operation.

Content Conversion and Posting

• The content from previous steps is in markdown format, which needs conversion to HTML for proper display on WordPress.
• Add a "Markdown" node to convert markdown content to HTML. Set the destination key to "data".
• In the WordPress "create post" node:
  • Use the SEO title for the post title.
  • Use the HTML output (from the "data" key of the Markdown node) for the post content.
  • Set the post status (e.g., draft, pending, published).
• Execute the workflow to create a draft post on WordPress.

Adding Excerpts via HTTP Request

• To add an excerpt, use the "HTTP Request" node.
• Construct the URL: [your-website.com]/wp-json/wp/v2/posts/[post-id].
• Use predefined WordPress API credentials for authentication.
• Enable "Send Body" and set the content type to JSON.
• Create a JSON payload to send the meta description as the "excerpt". Example: {"excerpt": "[meta description value]"}.
• Refresh the WordPress post to verify that the excerpt has been added.
• This HTTP request method can also be used for uploading featured images.

Email Notification Setup

• Automate checking Gmail for new emails and sending phone notifications.
• Utilize Pushinator, a third-party service with free accounts for testing (up to 3 devices, 200 notifications/month).

N8N Workflow Configuration

• Use the Gmail node, configured to poll every minute for new messages.
• Connect Gmail credentials via Google Console.

Initial Data Inspection

• Use an "Edit Fields" node to extract and view email subject, snippet, and sender.
• This allows monitoring of incoming email data without external services.

Pushinator Integration

• Install Pushinator as a community node in N8N.
• Set up Pushinator credentials by creating an API token in your Pushinator account and pasting it into N8N.

Channel Setup and Notification

• Create a channel in Pushinator (e.g., "phone").
• Connect the Pushinator app on your mobile device to the created channel by scanning a QR code.
• Configure the Pushinator node in N8N to send notifications to the "phone" channel.
• Customize notification messages using data from the Gmail node (e.g., "New email: [Sender] - [Snippet]").
• Run the workflow to receive push notifications on your mobile device.

Workflow Setup

• Removed the manual submission form and replaced it with a Google Drive: Search Files and Folders node.
• Configured the search to find files by name with an asterisk and filtered by the 'outlines' folder.
• Connected the search node to a Get Outline node, using the document ID from the search results.

Article Generation and Saving

• The workflow processes each found outline to generate an article.
• Articles are created in the 'articles' folder using the Google Drive: Create Document node.
• The Google Drive: Document Update node is used to save the generated article content.

Post-Processing

• A Google Drive: Move File node is added to move the processed outlines from the 'outlines' folder to the 'processed' folder.
• Initially, the wrong file (the article instead of the outline) was moved; corrected to move the document ID of the outline.

Final Run and Cost Analysis

• The entire workflow was run from start to finish.
• The 'outlines' folder was empty after the run, outlines were in 'processed', and articles were in the 'articles' folder.
• The cost for generating three articles was approximately 2 cents, as shown in OpenRouter.

Automation Setup

• Trigger: "On form submission" to input an article ID.
• Get Document: Retrieve the article outline from Google Docs using the provided ID.

AI Article Expansion

• AI Agent (OpenRouter/GPT-4.1 Mini): Expands the retrieved outline into a more detailed draft.
• Prompt Engineering: Uses structured prompts with HTML-like tags (e.g., <outline></outline>) to guide the AI.
• Key Instructions: Extract topic, audience, purpose; expand sections with SEO titles; add introductory sentences for each section.
• Output: Generates an improved outline, optionally saved to Google Docs for review.

AI Article Generation

• AI Agent (OpenRouter/GPT-4.1 Mini): Transforms the expanded outline into a full article.
• Prompt Engineering: Instructs the AI to act as an expert content writer, aiming for 2000-3000 words.
• Specific Requirements: Clear English, engaging tone, 1-2 bullet lists, SEO title (max 60 chars), 5 keywords, meta description (max 160 chars).
• JSON Output: Specifies a strict JSON output format for easy parsing of title, keywords, meta description, and the article.

Output Processing

• Edit Fields Node: Parses the JSON output from the article generation AI.
• Google Docs Integration: Creates a new document in the "articles" folder using the generated SEO title and saves the full article content.

Next Steps & Future Enhancements

• Batch Processing: Suggests automating the process for all outlines in a folder.
• Cost Discussion: Mentions covering OpenRouter costs in the next video.

Creating and Retrieving Google Docs

• N8N can be used to create a new Google Document.
• You can specify the drive and folder for the new document.
• The document can be named dynamically.
• N8N can also get an existing Google Document using its ID.

Updating Google Docs with Content

• The Update Document node allows you to insert text into a Google Doc.
• Content can be inserted at the end of the document body.
• The document ID can be dynamically passed from a previous node.

Integrating AI for Content Generation

• An AI agent can be used within the workflow to generate text.
• You can define custom prompts for the AI agent.
• The output from the AI agent can be used to update the Google Document.

Markdown Formatting in Google Docs

• Enable Markdown in Google Docs preferences (Tools > Preferences).
• N8N can paste content using Markdown formatting, allowing for rich text elements.

AI Agent Node Overview

• The AI Agent node integrates AI into n8n workflows.
• It requires input, typically via a chat trigger or other data sources.

Connecting AI and Triggers

• When added without a trigger, the AI Agent node defaults to a "When Chat Message Received" trigger.
• The AI Agent node has a "Source for Prompt" setting.
• This can be connected to a chat trigger, using incoming messages as the prompt.
• Alternatively, prompts can be manually entered in an "Open Chat" interface for testing.
• AI models (e.g., Llama Chat Model E2B) need to be connected to the AI Agent node.

Using Different Data Sources for Prompts

• If not using a chat trigger, the prompt source must be defined manually.
• Prompts can be sent from other nodes, such as an "On Form Submission" node.
• Data from form fields (e.g., a "prompt" text area) can be dragged into the AI Agent's prompt box.
• The prompt box allows for dynamic prompts, combining static text with incoming data.
• Example: "Can you write two sentences on [topic from form submission]?"

Prompt Engineering with AI Agent

• The AI Agent's prompt box can be used to construct complex prompts.
• These "super prompts" can incorporate data passed from previous nodes.
• The video demonstrates how the AI Agent processes these dynamic prompts to generate output.

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.

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.

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.

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 Marketing Team Overview

• The system uses one AI agent to perform marketing tasks: creating videos, LinkedIn posts, blog posts, images, editing images, and searching an image database.
• Communication is through Telegram (voice or text).
• The agent utilizes six n8n workflows as tools.
• All resources (templates, workflows, Google Sheet, Createmate template) are available for free in a "Free School community."

Live Demo and Capabilities

• Image Creation: User requests a flyer for a cat food flash sale; the AI generates an image.
• Image Editing: User requests the generated image be made more realistic; the AI edits it.
• Blog Post Creation: User requests a blog post about sleep and productivity; the AI generates a post with references and a graphic.
• Video Creation: User requests a video of a beaver building a house; the AI generates a video with sound effects (though the initial request resulted in a dam/house hybrid).

Workflow Breakdown: Core Agent and Tools

• The main agent receives input from Telegram (voice or text) and processes it.
• System Prompt: The agent is instructed to act as a marketing AI, detailing its tools and their uses (create image, edit image, search image database, blog post, LinkedIn post, video, think tool).
• Tool Integration: Each tool corresponds to a specific n8n workflow that the main agent calls.
• Input/Output: Workflows define specific inputs (e.g., image title, prompt, chat ID) and outputs are returned via Telegram and logged in a Google Sheet.

Detailed Workflow Explanations

• Create Image:
  • Takes image title, prompt, and chat ID as input.
  • Uses an OpenAI image model (e.g., GPT-4 Vision's model) to generate an image based on a detailed prompt.
  • Converts the output (base64 JSON) to binary data.
  • Sends the image to Telegram and uploads it to Google Drive.
  • Logs the image details (title, type, prompt, ID, link) to a Google Sheet.
• Edit Image:
  • Requires an image (via ID), the edit request, and chat ID.
  • Downloads the image from Google Drive using its ID.
  • Uses OpenAI's edit endpoint to modify the image based on the request.
  • Converts the edited image to binary, sends it to Telegram, uploads to Google Drive, and logs it.
• Search Images:
  • Takes an image title and intent (get or edit) as input.
  • Searches a Google Sheet (marketing team log) for the image.
  • Returns the image ID and link if found; otherwise, reports "not found."
  • If the intent is "edit," it passes the image ID back to the main workflow.
• Blog Post:
  • Takes blog topic, target audience, and chat ID.
  • Uses a Tavali web search agent to research the topic.
  • Generates a blog post tailored to the audience, including sources.
  • Creates a text prompt for a related image.
  • Generates the image using OpenAI.
  • Sends both the blog post and the image to Telegram, uploads to Google Drive, and logs them.
• LinkedIn Post: (Similar to blog post workflow, with specific prompts for LinkedIn content and graphics)
• Video Creation:
  • Takes a video topic and chat ID.
  • Breaks the topic into four cohesive parts for visual storytelling.
  • Generates four image prompts for these parts.
  • Uses Flux (via PI API) to generate four images (approx. 1.5 cents each).
  • Waits for image generation and retrieves URLs.
  • Uses Runway (approx. 25 cents per 5-second clip) to convert images to short video clips.
  • Generates text prompts for sound effects using an AI sound prompt generator.
  • Uses 11 Labs (approx. $5/month starter plan) to create 5-second sound effect clips for each video segment.
  • Merges video clips and audio using a Createmate template (approx. 1 credit per 20-second render).
  • Sends the final video to Telegram and logs it.

Pricing and Setup

• n8n: Cloud hosting is approximately $27/month.
• OpenAI Image Generation/Edit: $0.19-$0.20 per image/edit.
• OpenAI Text Generation (for prompts): GPT-4.1 Mini is cost-effective ($0.40/million input tokens, $1.60/million output tokens).
• Flux Image Generation: Approx. $0.015 per image.
• Runway Video: Approx. $0.25 per 5-second clip ($1.00 total for four clips per video).
• Createmate: Free trial available; paid plans offer credits for rendering (e.g., 2000 credits for ~200 videos).
• 11 Labs: Starter plan is $5/month for generous sound credit.
• Setup:
• Download seven n8n workflow JSON files (main agent + 6 tools) from the Free School community.
• Import workflows into n8n.
• Configure API keys (OpenAI, OpenRouter, Google Drive, Google Sheets, Telegram).
• Make a copy of the provided Google Sheet template for logging.
• Set up the Createmate template by pasting the script and importing the curl command into n8n.
• Connect Telegram credentials.