LangChain Integration

LangChain is a framework for developing applications powered by language models. n8n provides comprehensive integration with LangChain, allowing you to build sophisticated AI workflows with agents, chains, tools, memory, and more.

Overview

The n8n LangChain integration includes:

AI Agents

Autonomous agents that can reason, plan, and use tools

Chains

Sequential processing pipelines for AI tasks

Chat Models

Connect to various LLM providers

Tools

Extend agent capabilities with custom tools

Memory

Maintain conversation context and history

Vector Stores

Store and retrieve embeddings for RAG

Core Concepts

LangChain in n8n

n8n implements LangChain concepts as interconnected nodes: Node Types:

Root Nodes: Execute and produce outputs (AI Agent, Chain LLM)
Sub-Nodes: Provide capabilities to root nodes (Chat Model, Memory, Tools)
Connection Types: Different input types (Model, Memory, Tool, Vector Store)

AI Agents

AI Agents are autonomous systems that can reason, plan, and execute tasks using connected tools.

AI Agent Node

The AI Agent is the most powerful LangChain node in n8n.

Add AI Agent Node

Add the AI Agent node to your workflow as a root node.

Connect a Chat Model

Connect a chat model node to the Model input:

OpenAI Chat Model
Anthropic Chat Model
Google Gemini Chat Model
Other LLM providers

Add Tools (Optional)

Connect tool nodes to the Tools input:

HTTP Request Tool
Code Tool
Calculator Tool
Custom n8n Tools
Vector Store Retrieval Tool

Add Memory (Optional)

Connect a memory node to the Memory input:

Buffer Memory
Window Buffer Memory
Conversation Summary Memory

Configure Options

Set agent options:

System message
Prompt type
Max iterations
Return intermediate steps

Agent Types

Conversational Agent
ReAct Agent
OpenAI Functions Agent
Plan and Execute Agent

Best for chat-based interactions with natural conversation flow.Features:

Multi-turn conversations
Memory integration
Natural language understanding
Tool selection based on context

Use Cases:

Customer support chatbots
Virtual assistants
Interactive Q&A systems

Example Configuration:

{
  "promptType": "conversational",
  "systemMessage": "You are a helpful assistant that can search the web and access our database."
}

Reasoning and Acting agent that explicitly shows its thought process.Features:

Clear reasoning steps
Action planning
Observation feedback
Iterative problem solving

Use Cases:

Complex problem solving
Multi-step workflows
Debugging and troubleshooting

Example:

Thought: I need to find the weather in San Francisco
Action: search_web
Action Input: "San Francisco weather today"
Observation: It's 72°F and sunny
Thought: Now I have the answer
Final Answer: The weather in San Francisco is 72°F and sunny today.

Plans the entire workflow upfront, then executes step by step.Features:

Strategic planning
Sequential execution
Better for complex tasks
Can revise plans

Use Cases:

Research tasks
Multi-step projects
Complex data processing

Example:

Plan:
1. Search for company information
2. Extract key metrics
3. Compare with competitors
4. Generate report

Execution: [Executes each step]

Agent Configuration

{
  "systemMessage": "You are a helpful AI assistant.",
  "promptType": "conversational",
  "maxIterations": 10
}

Chains

Chains are sequential processing pipelines that connect multiple LangChain components.

Chain LLM Node

Simple chain for basic LLM tasks without agent complexity. Use Cases:

Simple text generation
Template-based responses
Single-step processing
Faster than agents

Example:

Chain Retrieval QA Node

Question-answering chain with vector store retrieval (RAG). Components:

Vector Store Retrieval Tool
Chat Model
(Optional) Memory

Example: Configuration:

{
  "returnSourceDocuments": true,
  "topK": 4,
  "options": {
    "chainType": "stuff"
  }
}

Chat Models

Chat models are the LLM providers that power your agents and chains.

Available Chat Models

OpenAI
Anthropic
Google Gemini
Other Providers

Node: OpenAI Chat ModelModels:

GPT-4 Turbo (most capable)
GPT-4 (balanced)
GPT-3.5 Turbo (fast and economical)
o1/o3 (advanced reasoning)

Features:

Function calling
JSON mode
Vision (GPT-4 Turbo)
128K context (GPT-4 Turbo)

Learn more →

Tools

Tools extend agent capabilities by giving them access to external systems and functions.

Built-in Tools

HTTP Request Tool

Make API calls to external services

RESTful APIs
Authentication support
Custom headers

Code Tool

Execute JavaScript or Python code

Data transformation
Custom logic
Library access

Calculator Tool

Perform mathematical calculations

Basic arithmetic
Complex expressions
Numeric operations

Vector Store Tool

Search vector databases

Semantic search
RAG workflows
Document retrieval

Custom n8n Tools

Create custom tools using any n8n workflow:

Create Tool Workflow

Build a workflow that performs your tool’s function.

Add Workflow Tool Node

Add the Workflow Tool node to your agent workflow.

Configure Tool

Select the tool workflow
Set tool name and description
Define input/output schema

Connect to Agent

Connect the tool to your AI Agent’s Tools input.

Example Tool Structure:

Agent Tool (Sub-Agents)

Create multi-agent systems with specialized sub-agents: Benefits:

Specialized expertise
Different models for different tasks
Parallel processing
Modular architecture

Memory

Memory allows agents to maintain context across multiple interactions.

Memory Types

Buffer Memory
Window Buffer Memory
Summary Memory
Redis Memory

Stores all conversation history.Features:

Complete history
Simple implementation
No data loss

Use Cases:

Short conversations
When full context is needed
Debugging

Configuration:

{
  "memoryType": "buffer",
  "contextWindowLength": 5
}

Limitations:

Can exceed token limits
More expensive with long conversations

Keeps only the last N messages.Features:

Fixed memory size
Predictable token usage
Sliding window

Use Cases:

Long conversations
Token management
Cost optimization

Configuration:

{
  "memoryType": "windowBuffer",
  "windowSize": 10
}

Recommended Settings:

Short conversations: 5-10 messages
Medium conversations: 10-20 messages
Long conversations: 20-50 messages

Summarizes old messages to save tokens.Features:

Compressed history
Token efficient
Retains key information

Use Cases:

Very long conversations
Complex context
Cost-sensitive applications

Configuration:

{
  "memoryType": "summary",
  "maxTokenLimit": 2000
}

How it works:

Keeps recent messages as-is
Summarizes older messages
Updates summary as conversation grows

Persistent memory stored in Redis.Features:

Persistent across sessions
Scalable
Shared across instances

Use Cases:

Multi-session conversations
Production deployments
User-specific context

Configuration:

{
  "memoryType": "redis",
  "sessionId": "user_123",
  "redisUrl": "redis://localhost:6379"
}

Vector Stores

Vector stores enable semantic search and retrieval-augmented generation (RAG).

Available Vector Stores

Pinecone

Managed vector database

Fully managed
Fast and scalable
Easy setup

Chroma

Open source vector store

Self-hosted option
Great for development
Cost-effective

Qdrant

High-performance vector search

Fast queries
Advanced filtering
Self-hosted or cloud

Supabase

PostgreSQL with vectors

Familiar SQL interface
Integrated with Supabase
Good for small datasets

RAG Workflow

Build a Retrieval-Augmented Generation system:

Prepare Documents

Create Retrieval Tool

Add a Vector Store Retrieval Tool that searches your vector store.

Connect to Agent

Wire the retrieval tool to your AI Agent’s tools input.

Query with Context

The agent automatically retrieves relevant documents and uses them to answer questions.

Complete RAG Example:

Common Patterns

1. Simple Q&A Agent

Basic conversational agent:

2. Research Agent

Agent with web search:

3. Data Analysis Agent

Agent with code execution:

4. Customer Support Agent

Full-featured support agent:

5. Multi-Agent System

Orchestrator with specialized agents:

Best Practices

Start Simple

Begin with a basic agent and add complexity gradually:

Single chat model
Add memory
Add one tool
Add more tools as needed

Write Clear Tool Descriptions

Tools are selected based on descriptions:

Be specific about what the tool does
Include when to use it
Mention input/output format
Give examples if helpful

Manage Context Windows

Use appropriate memory types
Consider token limits
Summarize when needed
Choose models with larger context for complex tasks

Handle Errors Gracefully

Implement retry logic
Provide fallback options
Log agent reasoning
Monitor tool failures

Optimize for Cost

Use cheaper models when possible
Limit max iterations
Cache results
Use window buffer memory
Monitor token usage

Test Tools Independently

Verify each tool works correctly
Test error cases
Check output formats
Ensure consistent behavior

Troubleshooting

Agent Not Using Tools

Possible causes:

Tool descriptions unclear
Wrong prompt type
Model doesn’t support function calling
System message overriding tool use

Solutions:

Improve tool descriptions
Use “tools” or “openai-functions” prompt type
Use compatible model (GPT-3.5-turbo+, Claude 3+, etc.)
Adjust system message

Agent Loops or Doesn’t Finish

Possible causes:

Tool returns unclear results
Max iterations too high
Circular dependencies
Poor prompt engineering

Solutions:

Lower max iterations (try 10-15)
Improve tool output clarity
Review agent reasoning (enable intermediate steps)
Refine system prompt

Memory Not Working

Possible causes:

Memory not connected
Session ID not set
Memory type mismatch
Context window exceeded

Solutions:

Verify memory connection
Set consistent session IDs
Use window buffer for long conversations
Check token usage

RAG Returns Irrelevant Results

Possible causes:

Poor document chunking
Embedding model mismatch
Top K too low
Query not specific enough

Solutions:

Adjust chunk size and overlap
Use same embedding model consistently
Increase top K (try 5-10)
Improve query formulation

Integration Catalog

AI Integrations

​LangChain Integration

​Overview

AI Agents

Chains

Chat Models

Tools

Memory

Vector Stores

​Core Concepts

​LangChain in n8n

​AI Agents

​AI Agent Node

​Agent Types

​Agent Configuration

​Chains

​Chain LLM Node

​Chain Retrieval QA Node

​Chat Models

​Available Chat Models

​Tools

​Built-in Tools

HTTP Request Tool

Code Tool

Calculator Tool

Vector Store Tool

​Custom n8n Tools

​Agent Tool (Sub-Agents)

​Memory

​Memory Types

​Vector Stores

​Available Vector Stores

Pinecone

Chroma

Qdrant

Supabase

​RAG Workflow

​Common Patterns

​1. Simple Q&A Agent

​2. Research Agent

​3. Data Analysis Agent

​4. Customer Support Agent

​5. Multi-Agent System

​Best Practices

​Troubleshooting

​Agent Not Using Tools

​Agent Loops or Doesn’t Finish

​Memory Not Working

​RAG Returns Irrelevant Results

​Resources

LangChain Integration

Overview

Core Concepts

LangChain in n8n

AI Agents

AI Agent Node

Agent Types

Agent Configuration

Chains

Chain LLM Node

Chain Retrieval QA Node

Chat Models

Available Chat Models

Tools

Built-in Tools

Custom n8n Tools

Agent Tool (Sub-Agents)

Memory

Memory Types

Vector Stores

Available Vector Stores

RAG Workflow

Common Patterns

1. Simple Q&A Agent

2. Research Agent

3. Data Analysis Agent

4. Customer Support Agent

5. Multi-Agent System

Best Practices

Troubleshooting

Agent Not Using Tools

Agent Loops or Doesn’t Finish

Memory Not Working

RAG Returns Irrelevant Results

Resources