AI Automation with n8n, Make and Zapiern8n in depth · Lesson 4 of 17
n8n AI: the AI Agent node, LangChain nodes and MCP
Video lecture
n8n AI: the AI Agent node, LangChain nodes and MCP
The narrated lecture is in production
Every chapter is scripted and ready. Browse the chapters and read the full transcript now — the video will appear here when it’s published.
Chapters
Transcript of the narration, chapter by chapter.
0:00 n8n AI
This is where n8n gets exciting. Its AI nodes let you add language models to any workflow: classify emails, extract fields, summarize calls, answer from your documents, or run full agents that decide which tools to call. And through MCP, n8n can both use external tools and publish your workflows as tools for AI assistants. In this lesson you'll learn the AI building blocks, when to use an agent versus a simple chain, how to configure agents well, and how MCP works in n8n.
0:37 Why AI inside workflows
Why do these AI nodes matter? Because they bring language models into the exact place your business data already flows. Instead of copying text into a chat window and pasting results back, you classify, extract, summarize and act inside the workflow, with credentials, logging, error handling and approvals around every AI step. That's the difference between personal AI productivity and business automation.
1:04 Building blocks
n8n's AI features follow LangChain concepts: root nodes with sub-nodes attached. The AI Agent node runs a language model that calls tools in a loop. The basic LLM chain takes a prompt and returns text. The information extractor pulls structured fields from text. The text classifier routes items into categories. There are nodes for sentiment, summarization and question answering over documents, plus a guardrails node for checks like personal data or jailbreak attempts. Sub-nodes supply the chat model, from OpenAI, Anthropic, Google, Mistral, local Ollama and many more, plus memory, tools, output parsers and vector stores.
1:46 Analogy: specialist vs assistant
An analogy: an AI chain is like a skilled specialist you hand one task to, like translate this or extract these fields. An AI agent is like a project assistant you give a goal and a toolbox, who decides which tools to use and in what order. Specialists are fast, cheap and predictable. Assistants are flexible but need supervision. Most workflows need specialists, and only some steps need an assistant.
2:16 Agent or chain?
Agent or chain? Use a chain or extractor when you know the steps: classify this email, extract these fields, summarize this call. They're cheaper, faster and more predictable. Use an agent when the model must choose tools dynamically, like answering a customer using order lookup, FAQ search or escalation as needed. The most robust designs use deterministic nodes for the overall flow, with small AI steps inside. Agents are powerful, but harder to test.
2:48 Configure agents well
Configure agents carefully. Write a system message covering role, goal, rules, when to use each tool, output format and what never to do. Give tools precise names and descriptions, because the description is how the model decides. Cap the maximum iterations to prevent runaway costs. Add memory only where multi-turn context is needed, keyed by session. Attach a structured output parser when later nodes need fields. Require human approval for risky tools. And choose models deliberately: fast, cheaper models for routine steps, stronger reasoning models only where needed.
3:26 MCP in n8n
MCP works in both directions in n8n. The MCP Client Tool is a sub-node that lets your AI agent call tools exposed by external MCP servers, like a CRM or documentation server. And the MCP Server Trigger does the reverse: it exposes your n8n workflows as tools that external AI assistants and agent platforms can call. So a tested workflow like create quote or lookup order becomes a safe, reusable tool for AI, with n8n handling credentials and logic. Protect these endpoints with authentication, expose only what's needed, and log every call.
4:06 Worked example: UK email triage
A UK e-commerce brand built an email triage flow. A guardrails node redacts sensitive patterns like card numbers before anything goes to the model. A text classifier sorts emails into order status, returns, product questions, complaints and spam. For order status and product questions, an AI agent uses a lookup order tool, a FAQ search tool and a think tool, and must cite order data and never promise refunds. A structured parser returns the reply, a confidence score and a needs-human flag. Complaints and low-confidence drafts go to a human. For the first two weeks, every send needs a Slack approval.
4:50 Hands-on: lead extractor
For hands-on practice, build a lead email extractor. A Gmail trigger feeds an information extractor with a JSON schema: company, service interest from a fixed list, whether a budget is mentioned, the amount and currency as an ISO code, urgency, and language, including Urdu, Arabic or mixed. If the service interest is known, upsert the CRM and notify Slack. Then test it on twenty real, anonymized emails, including Urdu and Arabic ones, and measure how accurate each field is before you trust it.
5:26 Example 2: Dubai recruitment CVs
A simple example. A Dubai recruitment agency receives CVs as PDFs. An n8n workflow extracts the text, uses the information extractor to pull out name, years of experience, key skills and languages spoken into a fixed schema, and saves the result to their applicant tracker for a recruiter to review. No agent, no decisions about candidates: just structured data that saves the recruiter typing, with a human making every judgment.
5:56 Common mistakes
Common mistakes. Using an agent where a classifier or extractor would do, which adds cost and unpredictability. Writing vague tool descriptions, so the agent calls the wrong tool. Running agents with no iteration cap or cost monitoring. And sending raw personal data to external models without need or agreement, when a guardrails or redaction step could have removed it first.
6:22 Watch me do it: AI extraction in n8n
Watch me do it. I open the process lead sub-workflow and add the AI extraction step. I add an Information Extractor node, attach a chat model sub-node using a fast, low-cost model with our API credential, and paste the JSON schema from the lesson text: company, service interest from a fixed list, budget mentioned, budget amount, currency as an ISO code, urgency, and language. In the node's instructions I add: use only information in the message, return null when a value is missing, never guess a budget. I run it on the pinned lead: we run three cafes and want Instagram ads before Ramadan, budget around eight thousand dirhams a month. Output: paid social, eight thousand, AED, urgency high, language English. Then I run it on a Roman Urdu message and an Arabic one. The Urdu one comes back with language en, which is wrong, so I add allowed examples of Roman Urdu to the field description and rerun. Next, the guardrail: before the extractor I add a Guardrails step that redacts card-number patterns, because people sometimes paste payment details into forms. Finally, I record field accuracy on twenty anonymized emails in a sheet linked from the workflow description. Budget and service are accurate; urgency needs a clearer definition.
7:53 Recap and next step
Recap. Use chains, extractors and classifiers for known steps, and agents only when tool choice must be dynamic. Configure agents with clear system messages, precise tools, iteration caps, structured outputs and approvals. Use MCP to consume external tools and to publish your workflows as tools, securely. Your next step: build the lead extractor, run it on twenty anonymized emails, and record per-field accuracy. Anything under your target gets a better schema description or a human check.
n8n's AI building blocks
n8n's AI features are built on LangChain concepts and appear as root nodes with attached sub-nodes:
| Root node | What it does |
|---|---|
| AI Agent | An LLM that can call tools in a loop to reach a goal (tools-agent pattern) |
| Basic LLM Chain | Single prompt in, text out; optional output parser |
| Information Extractor | Extract structured fields from text into a schema |
| Text Classifier | Route items into categories you define |
| Sentiment Analysis | Classify sentiment |
| Summarization Chain | Summarize long documents |
| Question and Answer Chain | Answer from a retriever (RAG) |
| Guardrails | Check text for issues such as PII, jailbreak attempts or topical violations before or after LLM steps (check current options) |
| Sub-node type | Examples |
|---|---|
| Chat model | OpenAI, Anthropic, Google Gemini, Mistral, Azure OpenAI, AWS Bedrock, Ollama (local), OpenRouter, DeepSeek, Groq and others |
| Memory | Simple (window buffer), Postgres, Redis, MongoDB chat memory |
| Tools | Call n8n Workflow, HTTP Request tool, Code tool, MCP Client Tool, Think tool, vector store tool, and app-specific tool versions of many nodes |
| Output parser | Structured output parser (JSON schema), auto-fixing parser |
| Retrieval | Vector stores (Postgres PGVector, Supabase, Pinecone, Qdrant and others), embeddings, text splitters, document loaders |
The provider list grows constantly; check the node library.
When to use an agent vs a chain
- Use a chain or extractor when the steps are known: classify this email, extract these fields, summarize this call. Cheaper, faster, more predictable.
- Use an agent when the model must choose among tools dynamically: "Answer the customer's question using our order lookup, FAQ search or escalation tool as needed."
- Many robust workflows use deterministic nodes for the flow and small AI steps inside it. Agents are powerful but harder to test.
Configuring an AI Agent well
- System message: role, goal, rules, when to use each tool, output format, what never to do.
- Tools with precise names and descriptions: the description is how the model decides; include parameter meanings.
- Max iterations: cap the tool loop to prevent runaway costs.
- Memory: only where multi-turn context is needed (chat); key it by session or user ID.
- Structured output: attach a structured output parser when downstream nodes need fields.
- Human review for risky tools: n8n supports human-in-the-loop approvals for tool calls and "send and wait for response" approvals in messaging and email nodes (see Module 6).
- Model choice: a smaller, faster model for routine steps; stronger reasoning models only where needed. Some workflows route between models with a model selector.
MCP in n8n
- MCP Client Tool (sub-node): lets your AI Agent call tools exposed by external MCP servers (for example a CRM or documentation server).
- MCP Server Trigger: exposes n8n workflows as tools to external MCP clients (for example a desktop AI assistant or another agent platform). That means your carefully built, tested workflows ("create_quote", "lookup_order") become callable tools for AI assistants, with n8n handling credentials and logic.
Secure MCP endpoints with authentication, expose only the tools needed, and log calls.
Worked example: an inbound email triage agent for a UK e-commerce brand
Trigger: new email in the support inbox. Flow:
- Guardrails node checks for PII patterns to redact before sending text to the LLM (card numbers, for example).
- Text Classifier: order_status, return_request, product_question, complaint, spam.
- For
order_statusandproduct_question, an AI Agent with tools:lookup_order(sub-workflow calling Shopify),search_faq(vector store tool over help articles), and a Think tool. System message requires citing order data and never promising refunds. - The agent drafts a reply; a structured output parser returns
{reply, confidence, needs_human}. - If
needs_humanor confidence is low, or category iscomplaint: create a helpdesk ticket for a human with the draft attached. Otherwise send via Gmail after a send-and-wait approval in Slack for the first two weeks, then auto-send for low-risk categories.
Hands-on: structured extraction with the Information Extractor
Attribute schema for lead emails:
{
"type": "object",
"properties": {
"company": {"type": "string"},
"service_interest": {"type": "string", "enum": ["seo", "paid_social", "web_design", "content", "other"]},
"budget_mentioned": {"type": "boolean"},
"budget_amount": {"type": ["number", "null"]},
"currency": {"type": ["string", "null"], "description": "ISO code such as PKR, AED, SAR, GBP, USD"},
"urgency": {"type": "string", "enum": ["low", "medium", "high"]},
"language": {"type": "string", "enum": ["en", "ur", "ar", "mixed"]}
},
"required": ["service_interest", "budget_mentioned", "urgency", "language"]
}Steps: Gmail Trigger -> Information Extractor (chat model sub-node: a fast, low-cost model; schema above) -> IF service_interest is not other -> CRM upsert with extracted fields -> Slack notification. Test with 20 real (anonymized) emails, including Urdu and Arabic ones, and measure field accuracy before trusting it.
Pitfalls
- Using an agent where a classifier would do.
- Vague tool descriptions ("does stuff with orders").
- No iteration cap or cost monitoring on agents.
- Sending raw personal data to external models without need or agreement.
Key takeaways
- n8n AI uses root nodes (AI Agent, LLM Chain, Information Extractor, Text Classifier, Guardrails) with sub-nodes for models, memory, tools, parsers and vector stores.
- Prefer chains/extractors/classifiers for known steps; use agents when tool choice must be dynamic.
- Configure agents with clear system messages, precise tool descriptions, iteration caps, structured output and human approval for risky tools.
- MCP Client Tool lets agents call external MCP servers; MCP Server Trigger exposes n8n workflows as tools, which must be secured.
Check your understanding
Quick questions to lock in the lesson. They don’t count towards your certificate.
Put it into practice
Build the lead-email extractor (Gmail -> Information Extractor -> IF -> CRM -> Slack). Run it on 20 anonymized emails including Urdu and Arabic ones and record per-field accuracy.
Enrol for free to save your progress
Reading is always free. Enrol to keep your place, take the final assessment and earn a verifiable certificate.