Skip to main content

​
AI Workflows in n8n

n8n provides a comprehensive suite of AI nodes built on top of LangChain, enabling you to create sophisticated AI-powered automation workflows. From simple LLM chains to complex autonomous agents with memory and tool use, n8n makes it easy to integrate AI capabilities into your workflows.

​
What You Can Build

With n8n’s AI nodes, you can build:

AI Agents

Autonomous agents that can use tools, make decisions, and interact with your workflows

RAG Pipelines

Retrieval Augmented Generation systems that combine vector stores with LLMs for context-aware responses

Document Processing

Extract, analyze, and summarize information from documents using AI

Conversational AI

Build chatbots and conversational interfaces with memory and context

​
Core AI Components

​
Language Models

Connect to various LLM providers to power your AI workflows:
  • OpenAI: GPT-4, GPT-3.5-turbo, and other OpenAI models
  • Anthropic: Claude models for advanced reasoning
  • Google: Gemini and Vertex AI models
  • Open Source: Ollama, Hugging Face, and more
  • Others: Cohere, Groq, Mistral, DeepSeek, and many more

​
Chains

Chains are pre-built workflows for common AI tasks:
  • Basic LLM Chain: Simple prompting with structured output
  • Question & Answer Chain: RAG-powered Q&A over your documents
  • Summarization Chain: Summarize long documents efficiently
  • Information Extractor: Extract structured data from unstructured text
  • Text Classifier: Classify text into categories
  • Sentiment Analysis: Analyze sentiment in text

​
Agents

Agents are autonomous AI systems that can use tools and make decisions:
  • Execute multi-step reasoning
  • Use tools like web search, calculators, and custom workflows
  • Maintain conversation context with memory
  • Handle complex tasks autonomously
Learn more about AI Agents →

​
Vector Stores & Embeddings

Store and retrieve information using semantic search:
  • Vector Stores: Pinecone, Qdrant, Supabase, Weaviate, and more
  • Embeddings: OpenAI, Cohere, Google, and others
  • Document Loaders: Load data from various sources
  • Text Splitters: Break documents into chunks for processing
Learn more about Vector Stores → | Learn more about Embeddings →

​
Getting Started

1

Choose Your Use Case

Decide what you want to build - a simple LLM chain, a RAG system, or an autonomous agent.
2

Add a Language Model

Add a language model node (e.g., OpenAI Chat Model) and configure your credentials.
3

Build Your Chain or Agent

Add a Chain or Agent node and connect it to your language model.
4

Add Tools or Memory (Optional)

Enhance your agent with tools, memory, or vector store retrieval.
5

Test and Deploy

Test your workflow and deploy it as a webhook, scheduled task, or integration.

​
Quick Example: Simple Q&A with Memory

Here’s a basic example of building a conversational AI with memory: 
{
  "nodes": [
    {
      "name": "When chat message received",
      "type": "@n8n/n8n-nodes-langchain.chatTrigger"
    },
    {
      "name": "OpenAI Chat Model",
      "type": "@n8n/n8n-nodes-langchain.lmChatOpenAi"
    },
    {
      "name": "Simple Memory",
      "type": "@n8n/n8n-nodes-langchain.memoryBufferWindow"
    },
    {
      "name": "AI Agent",
      "type": "@n8n/n8n-nodes-langchain.agent"
    }
  ]
}
This example uses the Chat Trigger node to receive messages, connects to OpenAI’s chat model, adds simple memory for context, and processes everything through an AI Agent.

​
Architecture Patterns

​
RAG (Retrieval Augmented Generation)

RAG combines vector search with LLMs to provide context-aware responses: 
Documents → Embeddings → Vector Store → Retriever → Q&A Chain → Response

​
Agent with Tools

Agents can use multiple tools to accomplish complex tasks: 
User Input → Agent → Tool Selection → Tool Execution → Agent Reasoning → Response

​
Multi-Agent Systems

Combine multiple specialized agents for complex workflows: 
Coordinator Agent → Research Agent → Analysis Agent → Writing Agent → Final Output

​
Best Practices

Start Simple: Begin with a Basic LLM Chain before moving to more complex agents.
  • Use Structured Output: Enable output parsers for reliable data extraction
  • Implement Memory Wisely: Choose the right memory type for your use case
  • Optimize Token Usage: Use text splitters and limit context window size
  • Handle Errors: Enable “Continue on Fail” for production workflows
  • Monitor Costs: Track API usage, especially with external LLM providers
  • Test Thoroughly: Test with various inputs before deploying

​
Advanced Features

​
Output Parsers

Structure LLM responses into reliable JSON schemas:
  • Structured Output Parser: Define custom schemas
  • Auto-fixing Parser: Automatically fix malformed outputs
  • Item List Parser: Extract lists from responses

​
Memory Types

Choose from various memory implementations:
  • Simple Memory: In-memory buffer (development)
  • Redis Memory: Distributed memory (production)
  • Postgres Memory: Persistent SQL-based memory
  • MongoDB Memory: Document-based memory
  • Zep Memory: Specialized memory with automatic summarization

​
Tools & Integrations

Extend agent capabilities with built-in tools:
  • HTTP Request Tool: Make API calls
  • Calculator Tool: Perform calculations
  • Wikipedia Tool: Search Wikipedia
  • Workflow Tool: Call other n8n workflows
  • Code Tool: Execute JavaScript/Python code
  • Vector Store Tool: Query vector databases

​
Next Steps

Build Your First Agent

Learn how to create autonomous AI agents

LangChain Nodes Reference

Explore all available LangChain nodes

Vector Stores Guide

Set up semantic search with vector databases

Embeddings Guide

Configure embedding models for your workflows

​
Resources